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

package/src/adapters/pi/{mcp.ts → mcp.js}

@@ -15,8 +15,8 @@ const fs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
 
-const { fingerprint } = require('../copy-tree.ts');
-const { SKELETON, readDocument, insertMember, replaceValue, removeMember, replaceInner, renderNewDocument } = require('./json-members.ts');
+const { fingerprint } = require('../copy-tree.js');
+const { SKELETON, readDocument, insertMember, replaceValue, removeMember, replaceInner, renderNewDocument } = require('./json-members.js');
 
 const HARNESS = 'pi';
 const ASSET_ID = 'guidance.codex-pointer';
@@ -30,47 +30,47 @@ const NOTICES = Object.freeze({
   trust: 'MCP: Pi reads .pi/mcp.json only after this project is trusted (/trust or --approve); DoFlow does not grant trust.',
 });
 
-function sha256(text: any): string { return crypto.createHash('sha256').update(text).digest('hex'); }
+function sha256(text     )         { return crypto.createHash('sha256').update(text).digest('hex'); }
 
-function shorten(name: string): string { return name.length > 40 ? `${name.slice(0, 37)}...` : name; }
+function shorten(name        )         { return name.length > 40 ? `${name.slice(0, 37)}...` : name; }
 
-function collisionNotice(key: string, id: string): string {
+function collisionNotice(key        , id        )         {
   return `MCP: kept your own entry '${shorten(key)}' and did not register DoFlow's '${shorten(id)}'; rename or remove yours to let DoFlow manage it.`;
 }
 
-function releasedNotice(id: string): string {
+function releasedNotice(id        )         {
   return `MCP: entry '${shorten(id)}' was changed outside DoFlow; it is yours now and DoFlow no longer updates or removes it.`;
 }
 
 /** Pi treats two server names that differ only in `-` versus `_` as one server. */
-function piServerKey(name: string): string { return name.replace(/_/g, '-'); }
+function piServerKey(name        )         { return name.replace(/_/g, '-'); }
 
-function refusalFor(file: string, reason: string): string { return `Pi MCP: ${file}: ${reason}; DoFlow did not change the file`; }
+function refusalFor(file        , reason        )         { return `Pi MCP: ${file}: ${reason}; DoFlow did not change the file`; }
 
-function untouchedNotice(file: string): string {
+function untouchedNotice(file        )         {
   const shown = file.length > 80 ? `...${file.slice(-77)}` : file;
   return `MCP: left ${shown} untouched because it cannot be edited safely; DoFlow no longer manages the entries in it.`;
 }
 
 /** DoFlow's entry for one catalog server, or the reason Pi cannot take it. */
-function renderPiEntry(server: any): any {
+function renderPiEntry(server     )      {
   if (server.transport !== 'stdio' || typeof server.command !== 'string' || !server.command) {
     return { refusal: `Pi MCP: server '${server.id}' is not a stdio server; DoFlow writes only stdio entries for Pi` };
   }
   if (typeof server.id !== 'string' || !SERVER_NAME.test(server.id)) {
     return { refusal: `Pi MCP: server id '${server.id}' is not a valid Pi server name` };
   }
-  const entry: any = { command: server.command };
+  const entry      = { command: server.command };
   if (Array.isArray(server.args) && server.args.length) entry.args = [...server.args];
   if (server.env && typeof server.env === 'object' && Object.keys(server.env).length) entry.env = { ...server.env };
   return { entry };
 }
 
-function mcpRows(ledger: any): any[] {
-  return (ledger?.resources || []).filter((row: any) => row.harness === HARNESS && row.kind === 'mcp-server');
+function mcpRows(ledger     )        {
+  return (ledger?.resources || []).filter((row     ) => row.harness === HARNESS && row.kind === 'mcp-server');
 }
 
-function readSnapshotFile(file: string, fsImpl: any): any {
+function readSnapshotFile(file        , fsImpl     )      {
   if (!fsImpl.existsSync(file)) return { exists: false, text: '', hash: sha256(''), doc: ABSENT_DOCUMENT };
   const bytes = fsImpl.readFileSync(file);
   const text = bytes.toString('utf8');
@@ -82,31 +82,31 @@ function readSnapshotFile(file: string, fsImpl: any): any {
 
 /** Read the selected server file and every file a ledger row names. Nothing is read when there is
  * neither a selection nor a row, so a run with no Pi MCP work touches no MCP file. */
-function discoverPiMcp({ selected = [], rows = [], file, fsImpl = fs }: any): any {
-  const files = new Set<string>(rows.map((row: any) => row.target));
+function discoverPiMcp({ selected = [], rows = [], file, fsImpl = fs }     )      {
+  const files = new Set        (rows.map((row     ) => row.target));
   if (selected.length) files.add(file);
   return Object.fromEntries([...files].map((target) => [target, readSnapshotFile(target, fsImpl)]));
 }
 
-function memberOf(doc: any, key: string): any { return doc.servers?.members.find((member: any) => member.key === key) ?? null; }
+function memberOf(doc     , key        )      { return doc.servers?.members.find((member     ) => member.key === key) ?? null; }
 
 /** The servers DoFlow owns in Pi's mcp.json now: rows whose entry still holds the value they record. */
-function ownedPiMcpIds({ rows = [], snapshot = {} }: any): string[] {
-  const owned = rows.filter((row: any) => {
+function ownedPiMcpIds({ rows = [], snapshot = {} }     )           {
+  const owned = rows.filter((row     ) => {
     const doc = snapshot[row.target]?.doc;
     const member = doc?.ok ? memberOf(doc, row.identity) : null;
     return member !== null && fingerprint(member.value) === row.fingerprint;
   });
-  return [...new Set<string>(owned.map((row: any) => row.identity))];
+  return [...new Set        (owned.map((row     ) => row.identity))];
 }
 
-function twinOf(doc: any, key: string): any {
-  return doc.servers?.members.find((member: any) => member.key !== key && piServerKey(member.key) === piServerKey(key)) ?? null;
+function twinOf(doc     , key        )      {
+  return doc.servers?.members.find((member     ) => member.key !== key && piServerKey(member.key) === piServerKey(key)) ?? null;
 }
 
-function sameValue(a: any, b: any): boolean { return JSON.stringify(a) === JSON.stringify(b); }
+function sameValue(a     , b     )          { return JSON.stringify(a) === JSON.stringify(b); }
 
-function baseChange({ target, operation, id, snapshot }: any): any {
+function baseChange({ target, operation, id, snapshot }     )      {
   return {
     assetId: ASSET_ID, target, operation,
     ownershipIdentity: `doflow:${HARNESS}:mcp-server:${id}`,
@@ -115,36 +115,36 @@ function baseChange({ target, operation, id, snapshot }: any): any {
   };
 }
 
-function writeChange({ target, operation, id, entry, snapshot }: any): any {
+function writeChange({ target, operation, id, entry, snapshot }     )      {
   return { ...baseChange({ target, operation, id, snapshot }), entry, fingerprint: fingerprint(entry), afterFingerprint: fingerprint(entry) };
 }
 
-function releaseChange({ row, snapshot }: any): any {
+function releaseChange({ row, snapshot }     )      {
   const id = row.identity;
   return { ...baseChange({ target: row.target, operation: 'remove', id, snapshot }), release: true, fingerprint: row.fingerprint };
 }
 
-function planPiMcp({ selected = [], rows = [], file, scope, removing = false, snapshot = {}, assets = [] }: any): any {
-  const changes: any[] = [];
-  const conflicts: string[] = [];
-  const notices: string[] = [];
+function planPiMcp({ selected = [], rows = [], file, scope, removing = false, snapshot = {}, assets = [] }     )      {
+  const changes        = [];
+  const conflicts           = [];
+  const notices           = [];
   if (!removing && !selected.length && !rows.length) return { changes, conflicts, notices };
   if (removing && !rows.length) return { changes, conflicts, notices };
-  if (!assets.some((asset: any) => asset.id === ASSET_ID)) {
+  if (!assets.some((asset     ) => asset.id === ASSET_ID)) {
     return { changes, conflicts: [`Pi MCP needs the ${ASSET_ID} asset to record ownership`], notices };
   }
 
   // An install or update refuses a file it cannot edit; a removal must still uninstall everything
   // else, so it releases the rows for that file and leaves the file as it is.
-  const refused = new Set<string>();
-  for (const [target, entry] of Object.entries(snapshot) as [string, any][]) {
+  const refused = new Set        ();
+  for (const [target, entry] of Object.entries(snapshot)                   ) {
     if (entry.doc.ok) continue;
     refused.add(target);
     if (removing) notices.push(untouchedNotice(target));
     else conflicts.push(refusalFor(target, entry.doc.reason));
   }
 
-  const matched = new Set<any>();
+  const matched = new Set     ();
   if (!removing) {
     if (selected.length) {
       notices.push(NOTICES.surface, NOTICES.extension);
@@ -154,7 +154,7 @@ function planPiMcp({ selected = [], rows = [], file, scope, removing = false, sn
     for (const server of selected) {
       const { entry: desired, refusal } = renderPiEntry(server);
       if (refusal) { conflicts.push(refusal); continue; }
-      const row = rows.find((item: any) => item.identity === server.id && item.target === file);
+      const row = rows.find((item     ) => item.identity === server.id && item.target === file);
       if (row) matched.add(row);
       const member = memberOf(doc, server.id);
       const twin = twinOf(doc, server.id);
@@ -189,21 +189,21 @@ function planPiMcp({ selected = [], rows = [], file, scope, removing = false, sn
     }
   }
 
-  return { changes: changes.filter((change: any) => !refused.has(change.target) || (removing && change.release)), conflicts, notices };
+  return { changes: changes.filter((change     ) => !refused.has(change.target) || (removing && change.release)), conflicts, notices };
 }
 
-function isSymlink(file: string, fsImpl: any): boolean {
+function isSymlink(file        , fsImpl     )          {
   try { return fsImpl.lstatSync(file).isSymbolicLink(); } catch { return false; }
 }
 
 /** Where a write to `file` lands: a symlinked mcp.json is written through to the file it points at,
  * so the link stays a link and its target receives the entries. */
-function writePath(file: string, fsImpl: any): string {
+function writePath(file        , fsImpl     )         {
   if (!isSymlink(file, fsImpl)) return file;
   try { return fsImpl.realpathSync(file); } catch { return path.resolve(path.dirname(file), fsImpl.readlinkSync(file)); }
 }
 
-function atomicWrite(file: string, content: string, fsImpl: any): void {
+function atomicWrite(file        , content        , fsImpl     )       {
   const dest = writePath(file, fsImpl);
   fsImpl.mkdirSync(path.dirname(dest), { recursive: true });
   // The rename gives the file the temp file's mode; an mcp.json kept private for its tokens stays so.
@@ -219,28 +219,28 @@ function atomicWrite(file: string, content: string, fsImpl: any): void {
 }
 
 /** Replay one file's edits against the text read now, each against a fresh parse of the last result. */
-function editedText(text: string, group: any[]): string {
-  const parse = (current: string) => {
+function editedText(text        , group       )         {
+  const parse = (current        ) => {
     const doc = readDocument(current);
     if (!doc.ok) throw new Error(`Pi MCP: cannot edit the planned file: ${doc.reason}`);
     return doc;
   };
   let next = text;
-  for (const change of group.filter((item: any) => item.operation === 'remove')) {
+  for (const change of group.filter((item     ) => item.operation === 'remove')) {
     const doc = parse(next);
     const member = memberOf(doc, change.identity);
     if (member) next = removeMember(next, doc.servers, member);
   }
-  for (const change of group.filter((item: any) => item.operation === 'update')) {
+  for (const change of group.filter((item     ) => item.operation === 'update')) {
     const doc = parse(next);
     const member = memberOf(doc, change.identity);
     if (member) next = replaceValue(next, member, change.entry, doc);
   }
-  const creates = group.filter((item: any) => item.operation === 'create');
+  const creates = group.filter((item     ) => item.operation === 'create');
   for (const [index, change] of creates.entries()) {
     const doc = parse(next);
     if (!doc.servers) {
-      const entries = Object.fromEntries(creates.slice(index).map((item: any) => [item.identity, item.entry]));
+      const entries = Object.fromEntries(creates.slice(index).map((item     ) => [item.identity, item.entry]));
       return insertMember(next, doc.root, 'mcpServers', entries, doc);
     }
     next = insertMember(next, doc.servers, change.identity, change.entry, doc);
@@ -251,33 +251,33 @@ function editedText(text: string, group: any[]): string {
 /** Undo what DoFlow added around its entries once the last of them is gone: the mcpServers member
  * it inserted, or the inner whitespace of the container it first wrote into. `origin` is recorded
  * on the ledger rows (see originFor); without it the emptied container is left as it is. */
-function restoredText(text: string, origin: any): string {
+function restoredText(text        , origin     )         {
   const doc = readDocument(text);
   if (!doc.ok || !doc.servers || doc.servers.members.length) return text;
   if (origin.created === 'member') return replaceInner(text, doc.servers, origin.inner);
-  const next = removeMember(text, doc.root, doc.root.members.find((member: any) => member.key === 'mcpServers'));
+  const next = removeMember(text, doc.root, doc.root.members.find((member     ) => member.key === 'mcpServers'));
   if (origin.inner === undefined) return next;
   const after = readDocument(next);
   return after.root.members.length ? next : replaceInner(next, after.root, origin.inner);
 }
 
-function applyPiMcp(changes: any[], { fsImpl = fs }: { fsImpl?: any } = {}): { applied: number } {
-  const groups = new Map<string, any[]>();
+function applyPiMcp(changes       , { fsImpl = fs }                   = {})                      {
+  const groups = new Map               ();
   for (const change of changes) {
     if (!groups.has(change.target)) groups.set(change.target, []);
-    groups.get(change.target)!.push(change);
+    groups.get(change.target) .push(change);
   }
   let applied = 0;
   for (const [target, all] of groups) {
-    const group = all.filter((change: any) => !change.release);
+    const group = all.filter((change     ) => !change.release);
     if (!group.length) continue;
     const exists = fsImpl.existsSync(target);
     const bytes = exists ? fsImpl.readFileSync(target) : Buffer.alloc(0);
     if (sha256(bytes) !== group[0].baseHash) throw new Error(`Pi MCP: ${target} changed after planning; nothing was written, re-run the command`);
     const text = bytes.toString('utf8');
-    const creates = group.filter((change: any) => change.operation === 'create');
-    const origin = group.find((change: any) => change.origin)?.origin;
-    let next = exists ? editedText(text, group) : renderNewDocument(creates.map((change: any) => [change.identity, change.entry]));
+    const creates = group.filter((change     ) => change.operation === 'create');
+    const origin = group.find((change     ) => change.origin)?.origin;
+    let next = exists ? editedText(text, group) : renderNewDocument(creates.map((change     ) => [change.identity, change.entry]));
     // Only a file DoFlow created is deleted, and never through a symlink; a user's own file that
     // happens to equal the skeleton stays.
     if (exists && origin?.created === 'file' && next === SKELETON) {
@@ -291,12 +291,12 @@ function applyPiMcp(changes: any[], { fsImpl = fs }: { fsImpl?: any } = {}): { a
   return { applied };
 }
 
-function statusFor({ id, target, status }: { id: string, target: string, status: string }): any {
+function statusFor({ id, target, status }                                                )      {
   return { harness: HARNESS, assetId: ASSET_ID, capability: 'mcp', identity: id, target,
     ownershipIdentity: `doflow:${HARNESS}:mcp-server:${id}`, status };
 }
 
-function resourceFor({ id, target, value, origin }: { id: string, target: string, value: any, origin?: any }): any {
+function resourceFor({ id, target, value, origin }                                                          )      {
   return { assetId: ASSET_ID, target, ownershipIdentity: `doflow:${HARNESS}:mcp-server:${id}`, kind: 'mcp-server', identity: id,
     fingerprint: fingerprint(value), sourceVersion: 'registry-v1', projection: { renderer: RENDERER }, ...(origin ? { origin } : {}) };
 }
@@ -305,15 +305,15 @@ function resourceFor({ id, target, value, origin }: { id: string, target: string
  * the whole file, the mcpServers member, or the first member of an empty mcpServers (with the
  * container's original inner whitespace). A row already carrying it passes it on; otherwise it is
  * read from the file as plan saw it. Only whitespace is recorded, never file content. */
-function originFor(target: string, rows: any[], snapshot: any): any {
-  const carried = rows.find((row: any) => row.target === target && row.origin)?.origin;
+function originFor(target        , rows       , snapshot     )      {
+  const carried = rows.find((row     ) => row.target === target && row.origin)?.origin;
   if (carried) return carried;
   const before = snapshot[target];
   if (!before) return undefined;
   if (!before.exists) return { created: 'file' };
   const { doc, text } = before;
   if (!doc.ok) return undefined;
-  const inner = (node: any) => text.slice(node.open + 1, node.close);
+  const inner = (node     ) => text.slice(node.open + 1, node.close);
   if (!doc.servers) return doc.root.members.length ? { created: 'key' } : { created: 'key', inner: inner(doc.root) };
   return doc.servers.members.length ? undefined : { created: 'member', inner: inner(doc.servers) };
 }
@@ -321,26 +321,26 @@ function originFor(target: string, rows: any[], snapshot: any): any {
 /** Statuses and ledger resources for the Pi MCP entries. `snapshot` is what plan read before apply:
  * an entry it held that DoFlow did not own then, or held with a value its row no longer matched, is
  * the user's, whatever it holds now. */
-function verifyPiMcp({ selected = [], rows = [], file, snapshot = {}, removing = false, fsImpl = fs }: any): any {
-  const statuses: any[] = [];
-  const resources: any[] = [];
-  const conflicts: string[] = [];
-  const current: Record<string, any> = {};
-  for (const target of new Set<string>([...(selected.length ? [file] : []), ...rows.map((row: any) => row.target)])) {
+function verifyPiMcp({ selected = [], rows = [], file, snapshot = {}, removing = false, fsImpl = fs }     )      {
+  const statuses        = [];
+  const resources        = [];
+  const conflicts           = [];
+  const current                      = {};
+  for (const target of new Set        ([...(selected.length ? [file] : []), ...rows.map((row     ) => row.target)])) {
     current[target] = readSnapshotFile(target, fsImpl).doc;
     if (!current[target].ok && !removing) conflicts.push(refusalFor(target, current[target].reason));
   }
-  const memberNow = (target: string, id: string) => (current[target]?.ok ? memberOf(current[target], id) : null);
-  const foreign = (target: string, id: string) => {
+  const memberNow = (target        , id        ) => (current[target]?.ok ? memberOf(current[target], id) : null);
+  const foreign = (target        , id        ) => {
     const before = snapshot[target]?.doc;
     if (!before?.ok) return false;
-    const row = rows.find((item: any) => item.identity === id && item.target === target);
+    const row = rows.find((item     ) => item.identity === id && item.target === target);
     const member = memberOf(before, id);
     if (!member) return Boolean(twinOf(before, id));
     return !row || fingerprint(member.value) !== row.fingerprint;
   };
 
-  const verified = new Set<string>();
+  const verified = new Set        ();
   if (!removing) {
     for (const server of selected) {
       const { entry: desired } = renderPiEntry(server);
@@ -359,7 +359,7 @@ function verifyPiMcp({ selected = [], rows = [], file, snapshot = {}, removing =
     const id = row.identity;
     if (verified.has(`${row.target}\u0000${id}`)) continue;
     const member = memberNow(row.target, id);
-    let status: string;
+    let status        ;
     if (!current[row.target].ok) status = 'not-managed';
     else if (!member) status = 'absent';
     else if (foreign(row.target, id) || fingerprint(member.value) !== row.fingerprint) status = 'not-managed';

package/src/adapters/{resolve-source.ts → resolve-source.js}

@@ -7,7 +7,7 @@ const path = require('node:path');
 /** Resolve a registry-declared source path against the repo root, refusing escapes. Shared by the
  * common projection module and by per-adapter native-projection normalizers, which is why it lives
  * in its own module rather than in index.js — a normalizer importing index.js would be a cycle. */
-function resolveRegistrySource(registry: any, source: any, label: string): string {
+function resolveRegistrySource(registry     , source     , label        )         {
   if (typeof registry.repoRoot !== 'string' || !registry.repoRoot) throw new Error(`Registry repoRoot is required for ${label}`);
   if (typeof source !== 'string' || !source) throw new Error(`Registry ${label} source is required`);
   const root = path.resolve(registry.repoRoot);

package/src/cli/commands/{install.ts → install.js}

@@ -4,31 +4,31 @@
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): run directly by Node native type-stripping.
 const os = require('node:os');
 const path = require('node:path');
-const { resolveTargets, toolDirs } = require('../../install/targets.ts');
-const { resolveContext, printContext } = require('../../install/context.ts');
+const { resolveTargets, toolDirs } = require('../../install/targets.js');
+const { resolveContext, printContext } = require('../../install/context.js');
 const {
   BackupError, DEFAULT_BACKUP_RETENTION, createFileBackup, applyRetention, formatBytes, retentionNote,
-} = require('../../install/backup.ts');
-const { backupSetFromPlan } = require('../../install/backup-set.ts');
-const { ledgerPath } = require('../../state/index.ts');
-const { writeManifest, readInstallManifest } = require('../../install/manifest.ts');
-const { confirm } = require('../../helper/prompt.ts');
-const { sourceCommit } = require('../../helper/git.ts');
-const { chmodHooksExecutable } = require('../../helper/settings-scope.ts');
-const { promptMcpCheckbox, resolveMcpSelections } = require('../../install/mcp.ts');
-const { loadRegistry } = require('../../registry/index.ts');
-const { storageAfterInstall } = require('../../runtime/storage/upkeep.ts');
-const { applyLifecycle, applyMcpIndex, recordMcpOwnership } = require('../../lifecycle/index.ts');
+} = require('../../install/backup.js');
+const { backupSetFromPlan } = require('../../install/backup-set.js');
+const { ledgerPath } = require('../../state/index.js');
+const { writeManifest, readInstallManifest } = require('../../install/manifest.js');
+const { confirm } = require('../../helper/prompt.js');
+const { sourceCommit } = require('../../helper/git.js');
+const { chmodHooksExecutable } = require('../../helper/settings-scope.js');
+const { promptMcpCheckbox, resolveMcpSelections } = require('../../install/mcp.js');
+const { loadRegistry } = require('../../registry/index.js');
+const { storageAfterInstall } = require('../../runtime/storage/upkeep.js');
+const { applyLifecycle, applyMcpIndex, recordMcpOwnership } = require('../../lifecycle/index.js');
 const {
   codexScope, registryLifecycleView, printRegistryLifecycle, printPlanNotices, assertSafeRegistryPlan,
   lockDocument, recordLock,
-} = require('../../lifecycle/view.ts');
+} = require('../../lifecycle/view.js');
 const {
   REPO_ROOT, SCRIPT_DIR, pkg, scopeOf, installPaths, reportRetiredMcp, scopeSelectionState, printMcpSelection, plannedMcpSelections,
   printRecordedMcpOwnership, buildAdapterRegistry, refuseHomeRootedProject, holdRunLock, checkpointRunLock,
-} = require('../shared.ts');
+} = require('../shared.js');
 
-function cmdInstall(o: any): void {
+function cmdInstall(o     )       {
   refuseHomeRootedProject(o, 'install');
   const targets = resolveTargets(o.targets);
   const scope = scopeOf(o);
@@ -55,7 +55,7 @@ function cmdInstall(o: any): void {
     // One lifecycle view across every requested target — computed unconditionally (not only under
     // --dry-run) so its safety gate and its plan are the exact same object the real apply below uses.
     const lifecycleView = registryLifecycleView({ registry, repoRoot: REPO_ROOT, scope, dirs, targets,
-      mcpSelections: selection.selections, mcpAdoptable: selection.adoptable, retainedMcpIds: selection.retainedMcpIds,
+      mcpSelections: selection.selections, mcpAdoptable: selection.adoptable, retainedMcpIds: selection.retainedMcpIds, operation: 'install',
       force: o.force, adopt: o.adopt === true, permissions: o.permissions === true, statusline: o.statusline === true });
     if (!lifecycleView.plan.safe) { assertSafeRegistryPlan(lifecycleView); return; }
 
@@ -117,7 +117,7 @@ function cmdInstall(o: any): void {
         stateRoot: lifecycleView.stateRoot, ledger: lifecycleView.ledger });
       for (const target of lifecycleView.plan.targets) {
         if (target.skipped || !target.changes.length) continue;
-        const owned = result.ledger.resources.filter((resource: any) => resource.harness === target.harness).length;
+        const owned = result.ledger.resources.filter((resource     ) => resource.harness === target.harness).length;
         console.log(`[INFO] ${target.harness}: lifecycle verified (${owned} owned resource(s))`);
       }
       ledgerAfter = result.ledger;
@@ -167,10 +167,10 @@ function cmdInstall(o: any): void {
 }
 
 /** Run a backup step; a BackupError stops the command before anything is changed. */
-function backupStep(step: () => any): any {
+function backupStep(step           )      {
   try {
     return step();
-  } catch (error: any) {
+  } catch (error     ) {
     if (!(error instanceof BackupError)) throw error;
     console.error(`[ERROR] Backup failed, nothing was changed: ${error.message}`);
     process.exit(1);
@@ -178,7 +178,7 @@ function backupStep(step: () => any): any {
 }
 
 /** Print what a backup step wrote and return its id ('' when there was nothing to back up). */
-function reportBackup(backup: any): string {
+function reportBackup(backup     )         {
   if (!backup) {
     console.error('[INFO]  Backup: nothing to back up (no file changes)');
     return '';
@@ -188,22 +188,22 @@ function reportBackup(backup: any): string {
 }
 
 /** The dry-run backup lines for a set the real run would back up. */
-function printBackupDryRun(set: any, destination: string): void {
+function printBackupDryRun(set     , destination        )       {
   if (set.count === 0) {
     console.log('[DRY]  Backup: nothing to back up (no file changes)');
   } else {
     console.log(`[DRY]  Would back up ${set.count} file(s), ${formatBytes(set.bytes)} (${set.bytes} bytes; ${set.absent} not present yet) to ${destination}`);
   }
-  const mcpOnly = set.excluded.filter((item: any) => item.reason === 'mcp-entries-only').length;
+  const mcpOnly = set.excluded.filter((item     ) => item.reason === 'mcp-entries-only').length;
   if (mcpOnly > 0) console.log(`[DRY]  Not backed up: ${mcpOnly} file(s) holding only MCP entries`);
 }
 
 /** Keep the newest backups after a run that changed files; never changes the exit code. */
-function applyBackupRetention({ backupRoot, prune, keep, bid }: any): void {
+function applyBackupRetention({ backupRoot, prune, keep, bid }     )       {
   let retention;
   try {
     retention = applyRetention({ backupRoot, keep, protect: bid ? [bid] : [] });
-  } catch (error: any) {
+  } catch (error     ) {
     console.error(`[WARN]  Backups: could not apply retention: ${error.message}`);
     return;
   }

package/src/cli/commands/{list-backups.ts → list-backups.js}

@@ -2,10 +2,10 @@
 // `doflow list-backups` — the backup table for this scope. Takes no project-path positional
 // (rollback's one positional slot is the backup id); scope is -g/--global vs cwd-rooted project.
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): run directly by Node native type-stripping.
-const { listBackups } = require('../../install/backup.ts');
-const { installPaths, printBackupTable } = require('../shared.ts');
+const { listBackups } = require('../../install/backup.js');
+const { installPaths, printBackupTable } = require('../shared.js');
 
-function cmdListBackups(o: any): void {
+function cmdListBackups(o     )       {
   // rollback/list-backups don't take a project-path positional (their one positional slot is the
   // backup id for rollback) — scope is -g/--global vs default project rooted at cwd.
   const scope = { global: o.global, projectRoot: '.' };
@@ -14,7 +14,7 @@ function cmdListBackups(o: any): void {
   // listBackups now reads the canonical root AND the legacy pre-.doflow one, so the footer must name
   // the roots the rows actually came from: reporting restore points as living in a directory that
   // does not exist on this machine sends a user looking for recovery material to the wrong place.
-  const roots = [...new Set(rows.map((r: any) => r.backupRoot))];
+  const roots = [...new Set(rows.map((r     ) => r.backupRoot))];
   printBackupTable(rows, roots.length ? roots.join(', ') : lifecyclePaths.backupRoot);
 }
 

package/src/cli/commands/{reconcile.ts → reconcile.js}

@@ -2,31 +2,31 @@
 // `doflow reconcile` — converge observed state onto the doflow.lock pin: report drift, then heal
 // it on confirmation. Never re-prompts for MCP; selections ride exactly as pinned.
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): run directly by Node native type-stripping.
-const { toolDirs } = require('../../install/targets.ts');
-const { resolveContext, printContext } = require('../../install/context.ts');
-const { writeManifest } = require('../../install/manifest.ts');
-const { confirm } = require('../../helper/prompt.ts');
-const { sourceCommit } = require('../../helper/git.ts');
-const { loadRegistry } = require('../../registry/index.ts');
-const { applyLifecycle, recordMcpOwnership } = require('../../lifecycle/index.ts');
+const { toolDirs } = require('../../install/targets.js');
+const { resolveContext, printContext } = require('../../install/context.js');
+const { writeManifest } = require('../../install/manifest.js');
+const { confirm } = require('../../helper/prompt.js');
+const { sourceCommit } = require('../../helper/git.js');
+const { loadRegistry } = require('../../registry/index.js');
+const { applyLifecycle, recordMcpOwnership } = require('../../lifecycle/index.js');
 const {
   registryLifecycleView, assertSafeRegistryPlan,
-} = require('../../lifecycle/view.ts');
-const { recordedMcpSelections } = require('../../install/mcp.ts');
+} = require('../../lifecycle/view.js');
+const { recordedMcpSelections } = require('../../install/mcp.js');
 const {
   REPO_ROOT, SCRIPT_DIR, pkg, scopeOf, installPaths, scopeSelectionState, printRecordedMcpOwnership, buildAdapterRegistry,
   refuseHomeRootedProject, holdRunLock, checkpointRunLock,
-} = require('../shared.ts');
+} = require('../shared.js');
 
 /** Classify desired-vs-observed drift for one lifecycle view. The plan IS the diff: its changes
  * are the operations needed to converge, its conflicts and prerequisites are the drift that must
  * not be silently healed. */
-function reconcileReport(view: any): any {
+function reconcileReport(view     )      {
   const drifts = [];
   const perHarness = new Map();
   for (const target of view.plan.targets) {
     if (target.skipped) continue;
-    const entry: any = { create: 0, update: 0, remove: 0 };
+    const entry      = { create: 0, update: 0, remove: 0 };
     for (const change of target.changes) {
       if (entry[change.operation] !== undefined) entry[change.operation] += 1;
       drifts.push({ harness: target.harness, operation: change.operation, assetId: change.assetId, target: change.target });
@@ -42,9 +42,9 @@ function reconcileReport(view: any): any {
   };
 }
 
-function printReconcileReport(report: any, lock: any): void {
+function printReconcileReport(report     , lock     )       {
   console.log(`[INFO] Reconciling against doflow.lock (sourceVersion ${lock.sourceVersion ?? 'unknown'})`);
-  for (const [harness, counts] of Object.entries<any>(report.perHarness)) {
+  for (const [harness, counts] of Object.entries     (report.perHarness)) {
     const total = counts.create + counts.update + counts.remove;
     console.log(`[INFO] ${harness}: ${total === 0 ? 'clean' : `${total} drift(s) (${counts.create} create, ${counts.update} update, ${counts.remove} remove)`}`);
   }
@@ -53,7 +53,7 @@ function printReconcileReport(report: any, lock: any): void {
   if (report.clean) console.log('[OK] Observed state matches doflow.lock.');
 }
 
-function cmdReconcile(o: any): void {
+function cmdReconcile(o     )       {
   refuseHomeRootedProject(o, 'reconcile');
   const scope = scopeOf(o);
   const hold = holdRunLock(o, scope, 'reconcile');
@@ -63,10 +63,10 @@ function cmdReconcile(o: any): void {
     const { lock, ledger, manifestServers } = scopeSelectionState(scope);
     // A harness the ledger holds but the lock does not pin is installed and outside reconcile's reach.
     // Said, not converged: the lock records choices, and reconcile has no choice to record for it.
-    const pinned = new Set((lock?.targets ?? []).map((entry: any) => entry.harness));
-    const unpinned = [...new Set((ledger?.resources ?? []).map((resource: any) => resource.harness))].filter((harness) => !pinned.has(harness)).sort();
+    const pinned = new Set((lock?.targets ?? []).map((entry     ) => entry.harness));
+    const unpinned = [...new Set((ledger?.resources ?? []).map((resource     ) => resource.harness))].filter((harness) => !pinned.has(harness)).sort();
     for (const harness of unpinned) {
-      const count = ledger.resources.filter((resource: any) => resource.harness === harness).length;
+      const count = ledger.resources.filter((resource     ) => resource.harness === harness).length;
       console.log(`[WARN] ${harness}: installed (ledger holds ${count} resource(s)) but absent from doflow.lock; reconcile does not converge it.`);
     }
     if (!lock || !lock.targets.length) {
@@ -76,7 +76,7 @@ function cmdReconcile(o: any): void {
       console.log('[INFO] No doflow.lock in this scope — nothing pinned to reconcile against. Run `doflow install` first.');
       return;
     }
-    const targets = lock.targets.map((entry: any) => entry.harness);
+    const targets = lock.targets.map((entry     ) => entry.harness);
     const registry = loadRegistry({ repoRoot: REPO_ROOT });
     printContext(resolveContext({ repoRoot: REPO_ROOT, targets, dirs, sourceCommit: sourceCommit(SCRIPT_DIR), ...scope }));
     // Each harness converges onto its own pinned selection — reconcile never re-prompts and never

package/src/cli/commands/{remove.ts → remove.js}

@@ -4,28 +4,28 @@
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): run directly by Node native type-stripping.
 const os = require('node:os');
 const path = require('node:path');
-const { resolveTargets, toolDirs } = require('../../install/targets.ts');
-const { confirm } = require('../../helper/prompt.ts');
-const { loadRegistry } = require('../../registry/index.ts');
-const { storageForgetScope } = require('../../runtime/storage/upkeep.ts');
-const { removeLifecycle, retentionSummary } = require('../../lifecycle/index.ts');
+const { resolveTargets, toolDirs } = require('../../install/targets.js');
+const { confirm } = require('../../helper/prompt.js');
+const { loadRegistry } = require('../../registry/index.js');
+const { storageForgetScope } = require('../../runtime/storage/upkeep.js');
+const { removeLifecycle, retentionSummary } = require('../../lifecycle/index.js');
 const {
   codexScope, registryLifecycleView, printRegistryLifecycle, LIFECYCLE_HARNESSES,
   assertSafeRegistryPlan, lockDocument, recordLock,
-} = require('../../lifecycle/view.ts');
-const { recordedMcpSelections } = require('../../install/mcp.ts');
+} = require('../../lifecycle/view.js');
+const { recordedMcpSelections } = require('../../install/mcp.js');
 const {
   REPO_ROOT, scopeOf, scopeSelectionState, buildAdapterRegistry, refuseHomeRootedProject, holdRunLock, checkpointRunLock,
-} = require('../shared.ts');
+} = require('../shared.js');
 
-function cmdRemove(o: any): void {
+function cmdRemove(o     )       {
   refuseHomeRootedProject(o, 'remove');
   const targets = resolveTargets(o.targets);
   const scope = scopeOf(o);
   const hold = holdRunLock(o, scope, 'remove');
   try {
     const dirs = toolDirs(scope);
-    const lifecycleTargets = targets.filter((t: string) => LIFECYCLE_HARNESSES.includes(t));
+    const lifecycleTargets = targets.filter((t        ) => LIFECYCLE_HARNESSES.includes(t));
     if (!lifecycleTargets.length) {
       console.log('[INFO] No lifecycle-owned native resources selected; legacy compatibility assets are never broadly removed.');
       return;