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

package/src/adapters/antigravity/{index.ts → index.js}

@@ -20,10 +20,10 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 
-const { MARKER_START, MARKER_END } = require('../../helper/marker-merge.ts');
-const { planTree, applyTree, removeTree, verifyTree, copyTreeAssets, ledgerFileResources, ledgerSiblingFingerprints, siblingReplacedNotices, fingerprint, readJson, sourceDirFor } = require('../copy-tree.ts');
-const { declaredHarnessPaths, resolveHarnessPaths } = require('../../helper/harness-paths.ts');
-const { readMcpFiles, planMcpEntries, verifyMcpEntries, ownedMcpIds, writeMcpEntries } = require('../mcp-entries.ts');
+const { MARKER_START, MARKER_END } = require('../../helper/marker-merge.js');
+const { planTree, applyTree, removeTree, verifyTree, copyTreeAssets, ledgerFileResources, ledgerSiblingFingerprints, siblingReplacedNotices, fingerprint, readJson, sourceDirFor } = require('../copy-tree.js');
+const { declaredHarnessPaths, resolveHarnessPaths } = require('../../helper/harness-paths.js');
+const { readMcpFiles, planMcpEntries, verifyMcpEntries, ownedMcpIds, writeMcpEntries } = require('../mcp-entries.js');
 
 const HARNESS = 'antigravity';
 const MCP_CONTAINER = 'mcpServers';
@@ -31,7 +31,7 @@ const MCP_RENDERER = 'antigravity-mcp';
 
 /** copy-tree's readJson distinguishes absent/unparseable via an {exists,value,error} envelope;
  * every caller here wants the plain object or {}. */
-function readJsonObject(file: any, { fsImpl = fs }: any = {}) {
+function readJsonObject(file     , { fsImpl = fs }      = {}) {
   const result = readJson(file, { fsImpl });
   if (!result || !result.exists || result.error) return {};
   return result.value ?? {};
@@ -54,20 +54,20 @@ const GATE_MATCHER = 'write_to_file|replace_file_content|multi_replace_file_cont
 /** Build DoFlow's hooks.json groups from the projected scripts' on-disk locations. Absolute command
  * path: the docs' own examples use relative ./scripts paths whose resolution base is not stated,
  * and an absolute path is unambiguous for a per-workspace install. */
-function hookGroups({ gateCommand, stopCommand }: any) {
+function hookGroups({ gateCommand, stopCommand }     ) {
   return {
     [HOOKS_GROUP]: { PreToolUse: [{ matcher: GATE_MATCHER, hooks: [{ type: 'command', command: gateCommand }] }] },
     [STOP_HOOKS_GROUP]: { Stop: [{ type: 'command', command: stopCommand }] },
   };
 }
 
-function hookScriptTarget(identity: any, paths: any) {
+function hookScriptTarget(identity     , paths     ) {
   return identity === 'pre-implementation-gate.sh' ? paths.hookScript : paths.stopHookScript;
 }
 
-function planHooks({ paths, scope, neutralResources, removing, repoRoot, fsImpl = fs }: any) {
-  const changes: any[] = [];
-  const conflicts: any[] = [];
+function planHooks({ paths, scope, neutralResources, removing, repoRoot, fsImpl = fs }     ) {
+  const changes        = [];
+  const conflicts        = [];
   if (scope !== 'project') {
     // The shims resolve the workspace via git/transcriptPath; a user-scope hooks.json would fire
     // against every project including non-git ones. Project-only until a documented user story exists.
@@ -76,9 +76,9 @@ function planHooks({ paths, scope, neutralResources, removing, repoRoot, fsImpl
   const target = paths.hooksJson;
   const scriptSource = sourceDirFor({ source: 'core/harnesses/antigravity/hooks' }, { repoRoot }, fsImpl, HARNESS);
 
-  const previousHookRows = (neutralResources || []).filter((r: any) => r.harness === HARNESS && r.assetId === HOOKS_ASSET_ID && r.kind === 'hooks-json');
-  const previousScriptRows = (neutralResources || []).filter((r: any) => r.harness === HARNESS && r.assetId === HOOKS_ASSET_ID && r.kind === 'copy-tree-file');
-  const docRow = previousHookRows.find((r: any) => r.target === target);
+  const previousHookRows = (neutralResources || []).filter((r     ) => r.harness === HARNESS && r.assetId === HOOKS_ASSET_ID && r.kind === 'hooks-json');
+  const previousScriptRows = (neutralResources || []).filter((r     ) => r.harness === HARNESS && r.assetId === HOOKS_ASSET_ID && r.kind === 'copy-tree-file');
+  const docRow = previousHookRows.find((r     ) => r.target === target);
 
   if (removing) {
     if (docRow || fsImpl.existsSync(target)) {
@@ -89,7 +89,7 @@ function planHooks({ paths, scope, neutralResources, removing, repoRoot, fsImpl
     }
     for (const identity of HOOK_SCRIPTS) {
       const scriptTarget = hookScriptTarget(identity, paths);
-      const scriptRow = previousScriptRows.find((r: any) => r.identity === identity);
+      const scriptRow = previousScriptRows.find((r     ) => r.identity === identity);
       if (scriptRow && fsImpl.existsSync(scriptTarget)) {
         const current = sha256File(fsImpl, scriptTarget);
         if (current === scriptRow.fingerprint) {
@@ -130,7 +130,7 @@ function planHooks({ paths, scope, neutralResources, removing, repoRoot, fsImpl
   return { changes, conflicts };
 }
 
-function sha256File(fsImpl: any, file: any) {
+function sha256File(fsImpl     , file     ) {
   return require('node:crypto').createHash('sha256').update(fsImpl.readFileSync(file)).digest('hex');
 }
 
@@ -138,7 +138,7 @@ function sha256File(fsImpl: any, file: any) {
  * ("paths"): project customization lives at <root>/.agents, global config at ~/.gemini/config
  * (the shared-customization root); instructions and skills are project-only surfaces, so no user
  * rule is declared for them and they resolve to null there. */
-function resolveNativePaths(declaredPaths: any, { scope, scopeRoot, homeDir }: any = {}) {
+function resolveNativePaths(declaredPaths     , { scope, scopeRoot, homeDir }      = {}) {
   if (scope !== 'project' && scope !== 'global') throw new Error(`Unsupported Antigravity scope '${scope}'`);
   const resolved = resolveHarnessPaths(declaredPaths, { scope, scopeRoot, homeDir });
   return {
@@ -168,33 +168,33 @@ function nativePaths(options = {}) {
  * keeps its planners module-level (they already thread resolved `paths` explicitly), so injection
  * flows through an optional `impl.nativePaths` seam instead of a full closure rewrite.
  */
-function createAntigravityAdapter({ declaredPaths = DEFAULT_DECLARED_PATHS }: any = {}) {
-  const nativePathsFor = (options: any) => resolveNativePaths(declaredPaths, options);
+function createAntigravityAdapter({ declaredPaths = DEFAULT_DECLARED_PATHS }      = {}) {
+  const nativePathsFor = (options     ) => resolveNativePaths(declaredPaths, options);
   return {
     nativePaths: nativePathsFor,
-    discover: (options: any, impl = {}) => discover(options, { ...impl, nativePaths: nativePathsFor }),
+    discover: (options     , impl = {}) => discover(options, { ...impl, nativePaths: nativePathsFor }),
     render,
-    plan: (options: any, impl = {}) => plan(options, { ...impl, nativePaths: nativePathsFor }),
+    plan: (options     , impl = {}) => plan(options, { ...impl, nativePaths: nativePathsFor }),
     apply,
     remove,
-    verify: (options: any, impl = {}) => verify(options, { ...impl, nativePaths: nativePathsFor }),
+    verify: (options     , impl = {}) => verify(options, { ...impl, nativePaths: nativePathsFor }),
   };
 }
 
 const singleton = createAntigravityAdapter();
 
 /** The scope's paths exactly as plan() and verify() resolve them, so discovery reads the same files. */
-function scopePaths(options: any, resolvePaths = singleton.nativePaths) {
+function scopePaths(options     , resolvePaths = singleton.nativePaths) {
   return resolvePaths({ ...options, scope: options.scope ?? 'project', homeDir: options.context?.homeDir });
 }
 
-function ledgerResources(options: any) {
+function ledgerResources(options     ) {
   return options.ledger?.resources ?? options.managedResources ?? [];
 }
 
 /** Discovery keeps the MCP files as plan read them (`mcpSnapshot`), which verify compares against,
  * and reports the servers DoFlow owns in mcp_config.json now (`mcpOwned`). */
-function discover(options: any, { fsImpl = fs, nativePaths: resolvePaths = singleton.nativePaths }: any = {}) {
+function discover(options     , { fsImpl = fs, nativePaths: resolvePaths = singleton.nativePaths }      = {}) {
   const paths = scopePaths(options, resolvePaths);
   const instruction = paths.instruction && fsImpl.existsSync(paths.instruction)
     ? fsImpl.readFileSync(paths.instruction, 'utf8') : null;
@@ -206,11 +206,11 @@ function discover(options: any, { fsImpl = fs, nativePaths: resolvePaths = singl
   return { paths, instruction, mcpSnapshot, mcpOwned: ownedMcpIds({ ...entries, files: mcpSnapshot }), mcpConfigured };
 }
 
-function render({ content = '' }: any = {}) {
+function render({ content = '' }      = {}) {
   return `${MARKER_START}\n${String(content).trimEnd()}\n${MARKER_END}\n`;
 }
 
-function managedInstruction(existing: any, rendered: any) {
+function managedInstruction(existing     , rendered     ) {
   if (existing === null) return { ok: true, operation: 'create', content: rendered };
   const start = existing.indexOf(MARKER_START);
   const end = existing.indexOf(MARKER_END);
@@ -224,7 +224,7 @@ function managedInstruction(existing: any, rendered: any) {
   return { ok: true, operation: content === existing ? 'none' : 'merge', content };
 }
 
-function strippedInstruction(existing: any) {
+function strippedInstruction(existing     ) {
   if (typeof existing !== 'string') return null;
   const start = existing.indexOf(MARKER_START);
   const end = existing.indexOf(MARKER_END);
@@ -239,7 +239,7 @@ function strippedInstruction(existing: any) {
 /** Scope policy mirrors the registry notes, resolved from each asset's own flat nativeDir:
  *   ../x or .agents/x or .doflow/x  → rooted at the install root (project scope)
  *   plain names (bin, agents)       → inside the scope's config dir (.agents | ~/.gemini/config) */
-function treeDestFor(asset: any, paths: any, scope: any) {
+function treeDestFor(asset     , paths     , scope     ) {
   const nativeDir = asset.nativeDir;
   if (!nativeDir) return null;
   if (asset.id === 'skills.doflow') {
@@ -263,7 +263,7 @@ function treeDestFor(asset: any, paths: any, scope: any) {
   return path.join(paths.configDir, nativeDir);
 }
 
-function planTrees({ assets, paths, scope, neutralResources, removing, repoRoot, force = false, fsImpl = fs }: any) {
+function planTrees({ assets, paths, scope, neutralResources, removing, repoRoot, force = false, fsImpl = fs }     ) {
   const changes = [];
   const conflicts = [];
   const treeResults = [];
@@ -285,10 +285,10 @@ function planTrees({ assets, paths, scope, neutralResources, removing, repoRoot,
       // planTrees as well, since its signature did not carry the context the others already had.
       force: !removing && force === true });
     treeResults.push(result);
-    conflicts.push(...result.conflicts.map((reason: any) => `${asset.id}: ${reason}`));
+    conflicts.push(...result.conflicts.map((reason     ) => `${asset.id}: ${reason}`));
     // A hand-edited file at a path DoFlow no longer writes is the user's: it stays, only its
     // ownership row is released.
-    notices.push(...result.kept.map((item: any) => `kept hand-edited ${path.relative(paths.root, item.target)}; DoFlow no longer manages it`));
+    notices.push(...result.kept.map((item     ) => `kept hand-edited ${path.relative(paths.root, item.target)}; DoFlow no longer manages it`));
     for (const change of result.changes) {
       changes.push({
         assetId: asset.id, target: change.target, source: change.source, operation: change.operation,
@@ -303,15 +303,15 @@ function planTrees({ assets, paths, scope, neutralResources, removing, repoRoot,
   return { changes, conflicts, targets, notices: [...siblingReplacedNotices(treeResults), ...notices] };
 }
 
-function runTreeChanges(changes: any, mode: any) {
+function runTreeChanges(changes     , mode     ) {
   // Route by what each change IS, not by which verb invoked us: remove() delegates here with a
   // plan full of operation:'remove' changes, and applyTree deliberately skips those — so routing
   // everything through one engine call silently deleted nothing (verification then correctly
   // refused to journal the no-op). Writes go to applyTree, removals to removeTree, always.
   void mode;
   const treeChanges = changes
-    .filter((c: any) => c.projection?.renderer === 'copy-tree' || c.kind === 'copy-tree-file')
-    .map((c: any) => ({ relPath: c.identity ?? c.relPath, target: c.target,
+    .filter((c     ) => c.projection?.renderer === 'copy-tree' || c.kind === 'copy-tree-file')
+    .map((c     ) => ({ relPath: c.identity ?? c.relPath, target: c.target,
       source: c._text ? undefined : c.source, operation: c.operation,
       fingerprint: c.fingerprint, pruneGuard: c.pruneGuard, ...(c._text ? { _text: c._text } : {}) }));
   // Content-managed tree files (hook scripts): write rendered text with +x, not a byte copy.
@@ -324,17 +324,17 @@ function runTreeChanges(changes: any, mode: any) {
   }
   return {
     applied: 0, removed: 0,
-    ...(function (): any {
-      const plain = treeChanges.filter((t: any) => t._text === undefined);
-      const writes = plain.filter((c: any) => c.operation !== 'remove');
-      const removals = plain.filter((c: any) => c.operation === 'remove');
+    ...(function ()      {
+      const plain = treeChanges.filter((t     ) => t._text === undefined);
+      const writes = plain.filter((c     ) => c.operation !== 'remove');
+      const removals = plain.filter((c     ) => c.operation === 'remove');
       const applied = writes.length ? applyTree({ changes: writes }).applied : 0;
       const removed = removals.length ? removeTree({ changes: removals }).removed : 0;
       return { applied, removed };
     })(),
   };
-  const writes = treeChanges.filter((c: any) => c.operation !== 'remove');
-  const removals = treeChanges.filter((c: any) => c.operation === 'remove');
+  const writes = treeChanges.filter((c     ) => c.operation !== 'remove');
+  const removals = treeChanges.filter((c     ) => c.operation === 'remove');
   const applied = writes.length ? applyTree({ changes: writes }).applied : 0;
   const removed = removals.length ? removeTree({ changes: removals }).removed : 0;
   return { applied, removed };
@@ -342,7 +342,7 @@ function runTreeChanges(changes: any, mode: any) {
 
 // ---- instructions component ----
 
-function planInstructions({ paths, assets, removing, repoRoot, fsImpl = fs }: any) {
+function planInstructions({ paths, assets, removing, repoRoot, fsImpl = fs }     ) {
   if (scopeOf(paths) !== 'project') return { changes: [], conflicts: [] };
   void repoRoot;
   if (removing) {
@@ -380,7 +380,7 @@ function planInstructions({ paths, assets, removing, repoRoot, fsImpl = fs }: an
   };
 }
 
-function pointerBody(fsImpl: any) {
+function pointerBody(fsImpl     ) {
   // The shared pointer prose ships once; read it through the same repo-relative anchor the other
   // AGENTS-style adapters use.
   try {
@@ -388,11 +388,11 @@ function pointerBody(fsImpl: any) {
   } catch { return null; }
 }
 
-function scopeOf(paths: any) { return paths.scope; }
+function scopeOf(paths     ) { return paths.scope; }
 
 // ---- MCP component ----
 
-function mcpDefinitionFor(server: any) {
+function mcpDefinitionFor(server     ) {
   // Remote transports project url/httpUrl -> serverUrl per the current Antigravity schema.
   if (server.transport === 'stdio') {
     return { command: server.command, ...(server.args?.length ? { args: server.args } : {}) };
@@ -400,27 +400,27 @@ function mcpDefinitionFor(server: any) {
   return { serverUrl: server.url ?? server.httpUrl };
 }
 
-function ownershipIdentity(id: any) { return `doflow:${HARNESS}:mcp-server:${id}`; }
+function ownershipIdentity(id     ) { return `doflow:${HARNESS}:mcp-server:${id}`; }
 
 /** Everything the shared entry-ownership rules (../mcp-entries.ts) need from this adapter. Rows
  * recorded before entries were fingerprinted carry `fingerprint: null`; such a row owns its entry
  * only while the entry still equals DoFlow's rendering. */
-function mcpEntriesInput({ paths, mcp = [], mcpAdoptable = [], resources = [] }: any) {
-  const rendered = (servers: any) => servers.map((server: any) => ({ id: server.id, entry: mcpDefinitionFor(server) }));
-  const rows = resources.filter((row: any) => row.kind === 'mcp-server');
+function mcpEntriesInput({ paths, mcp = [], mcpAdoptable = [], resources = [] }     ) {
+  const rendered = (servers     ) => servers.map((server     ) => ({ id: server.id, entry: mcpDefinitionFor(server) }));
+  const rows = resources.filter((row     ) => row.kind === 'mcp-server');
   return {
     file: paths.mcpFile, selected: rendered(mcp), adoptable: rendered(mcpAdoptable),
-    ownRows: rows.filter((row: any) => row.harness === HARNESS).map((row: any) => ({
+    ownRows: rows.filter((row     ) => row.harness === HARNESS).map((row     ) => ({
       identity: row.identity, target: row.target, fingerprint: row.fingerprint ?? null, ownershipIdentity: row.ownershipIdentity, legacy: false,
     })),
-    foreignRows: rows.filter((row: any) => row.harness !== HARNESS).map((row: any) => ({ harness: row.harness, identity: row.identity, target: row.target })),
+    foreignRows: rows.filter((row     ) => row.harness !== HARNESS).map((row     ) => ({ harness: row.harness, identity: row.identity, target: row.target })),
     identityFor: ownershipIdentity, assetId: POINTER_ASSET_ID, renderer: MCP_RENDERER, label: 'Antigravity MCP',
   };
 }
 
 // ---- required six-function surface ----
 
-function plan(options: any = {}, impl: any = {}) {
+function plan(options      = {}, impl      = {}) {
   const fsImpl = impl.fsImpl || fs;
   const context = options.context ?? {};
   const scope = options.scope ?? 'project';
@@ -449,7 +449,7 @@ function plan(options: any = {}, impl: any = {}) {
   };
 }
 
-function apply(options: any = {}, impl: any = {}) {
+function apply(options      = {}, impl      = {}) {
   const fsImpl = impl.fsImpl || fs;
   // apply()/verify() are reached through the lifecycle with the same scope inputs plan() saw, so
   // they re-derive paths instead of trusting plan-private state. `paths` itself is unused here —
@@ -458,7 +458,7 @@ function apply(options: any = {}, impl: any = {}) {
   (impl.nativePaths ?? singleton.nativePaths)(options);
   const changes = options.changes ?? [];
 
-  for (const change of changes.filter((c: any) => c.projection?.renderer === 'antigravity-instructions')) {
+  for (const change of changes.filter((c     ) => c.projection?.renderer === 'antigravity-instructions')) {
     if (change.operation === 'remove') {
       // pi precedent: strip only the managed span; the file survives even when nothing remains.
       if (!fsImpl.existsSync(change.target)) continue;
@@ -469,7 +469,7 @@ function apply(options: any = {}, impl: any = {}) {
     fsImpl.mkdirSync(path.dirname(change.target), { recursive: true });
     fsImpl.writeFileSync(change.target, change._content ?? render({ content: '' }), 'utf8');
   }
-  for (const change of changes.filter((c: any) => c.projection?.renderer === 'antigravity-hooks')) {
+  for (const change of changes.filter((c     ) => c.projection?.renderer === 'antigravity-hooks')) {
     if (change.kind === 'copy-tree-file') continue;          // handled by runTreeChanges below
     if (change.operation === 'remove') {
       // Unmerge only DoFlow's groups (one per policy); a user's own hook groups survive.
@@ -502,11 +502,11 @@ function apply(options: any = {}, impl: any = {}) {
 // Removal flows through apply(): plan(context.operation='remove') emits operation:'remove'
 // changes, and the branches above already know how to execute each kind. The six-function
 // contract still requires the verb itself.
-function remove(options: any = {}, impl: any = {}) {
+function remove(options      = {}, impl      = {}) {
   return apply(options, impl);
 }
 
-function verify(options: any = {}, impl: any = {}) {
+function verify(options      = {}, impl      = {}) {
   const fsImpl = impl.fsImpl || fs;
   const context = options.context ?? {};
   const scope = options.scope ?? 'project';
@@ -565,7 +565,7 @@ function verify(options: any = {}, impl: any = {}) {
   // Hooks projection (project scope): the shims' bytes and the registered groups.
   if (scope === 'project') {
     const hooksTarget = paths.hooksJson;
-    const scriptTargets: Record<string, any> = {
+    const scriptTargets                      = {
       'pre-implementation-gate.sh': paths.hookScript,
       'stop-check.sh': paths.stopHookScript,
     };
@@ -573,7 +573,7 @@ function verify(options: any = {}, impl: any = {}) {
     // projection, not an install destination — the destination is declared as the paths above).
     const scriptSourceDir = path.join(path.resolve(registryRepoRoot(options)), 'core', 'harnesses', 'antigravity', 'hooks');
     const removingOp = (context.operation ?? options.operation ?? '') === 'remove';
-    const fingerprints: Record<string, any> = {};
+    const fingerprints                      = {};
     let scriptsOk = true;
     let anyPresent = false;
     for (const identity of HOOK_SCRIPTS) {
@@ -617,11 +617,11 @@ function verify(options: any = {}, impl: any = {}) {
   return { ok: conflicts.length === 0, statuses, resources, conflicts };
 }
 
-function registryRepoRoot(options: any) {
+function registryRepoRoot(options     ) {
   return options.registry?.repoRoot ?? process.cwd();
 }
 
-function conflictsToStatuses(conflicts: any, assetId: any, statuses: any) {
+function conflictsToStatuses(conflicts     , assetId     , statuses     ) {
   for (const reason of conflicts) statuses.push({ assetId, capability: 'scripts', status: 'conflict', reason });
 }
 

package/src/adapters/claude/{index.ts → index.js}

@@ -7,13 +7,13 @@
 const crypto = require('node:crypto');
 const fs = require('node:fs');
 const path = require('node:path');
-const { mergeMarkedSection, removeMarkedSection, MARKER_START, MARKER_END } = require('../../helper/marker-merge.ts');
-const { selectMcpServers } = require('../../registry/index.ts');
-const { GLOBAL_HOOK_PREFIX, PROJECT_HOOK_PREFIX } = require('../../helper/settings-scope.ts');
-const { mergeSettings, settingsContains, settingsContainsAny, stripManagedSettings } = require('../../helper/settings-merge.ts');
-const { planTree, applyTree, removeTree, verifyTree, copyTreeAssets, copyTreeDestDir, ledgerFileResources, ledgerSiblingFingerprints, siblingReplacedNotices, resolveTransform } = require('../copy-tree.ts');
-const { declaredHarnessPaths, resolveHarnessPaths } = require('../../helper/harness-paths.ts');
-const { discoverMcp, planMcp, writeMcp, verifyMcp } = require('./mcp.ts');
+const { mergeMarkedSection, removeMarkedSection, MARKER_START, MARKER_END } = require('../../helper/marker-merge.js');
+const { selectMcpServers } = require('../../registry/index.js');
+const { GLOBAL_HOOK_PREFIX, PROJECT_HOOK_PREFIX } = require('../../helper/settings-scope.js');
+const { mergeSettings, settingsContains, settingsContainsAny, stripManagedSettings } = require('../../helper/settings-merge.js');
+const { planTree, applyTree, removeTree, verifyTree, copyTreeAssets, copyTreeDestDir, ledgerFileResources, ledgerSiblingFingerprints, siblingReplacedNotices, resolveTransform } = require('../copy-tree.js');
+const { declaredHarnessPaths, resolveHarnessPaths } = require('../../helper/harness-paths.js');
+const { discoverMcp, planMcp, writeMcp, verifyMcp } = require('./mcp.js');
 
 const INSTRUCTION_RENDERER = 'claude-instructions';
 const SETTINGS_RENDERER = 'claude-settings';
@@ -30,11 +30,11 @@ const SETTINGS_RENDERER = 'claude-settings';
  */
 const SETTINGS_FILES = ['settings.json', 'keybindings.json'];
 
-function sha256(value: any) {
+function sha256(value     ) {
   return crypto.createHash('sha256').update(value).digest('hex');
 }
 
-function sourcePath(asset: any, context: any = {}) {
+function sourcePath(asset     , context      = {}) {
   if (!asset || typeof asset.source !== 'string') throw new Error('Claude asset requires a source path');
   const repoRoot = context.repoRoot ? path.resolve(context.repoRoot) : process.cwd();
   const source = path.resolve(repoRoot, asset.source);
@@ -44,7 +44,7 @@ function sourcePath(asset: any, context: any = {}) {
   return source;
 }
 
-function markerState(file: any) {
+function markerState(file     ) {
   if (!fs.existsSync(file)) return { exists: false, managed: false, malformed: false };
   const text = fs.readFileSync(file, 'utf8');
   const starts = text.split(MARKER_START).length - 1;
@@ -53,8 +53,8 @@ function markerState(file: any) {
 }
 
 /** Single serialization form for every settings write, so repeated runs are byte-stable. */
-const serializeSettings = (value: any) => `${JSON.stringify(value, null, 2)}\n`;
-const settingsChangeExtras = (fileName: any) => ({ kind: 'settings-file', identity: fileName });
+const serializeSettings = (value     ) => `${JSON.stringify(value, null, 2)}\n`;
+const settingsChangeExtras = (fileName     ) => ({ kind: 'settings-file', identity: fileName });
 
 /**
  * Native path facts live in core/registry/harnesses.json under this harness's "paths" section and
@@ -67,18 +67,18 @@ function createClaudeAdapter({ declaredPaths = declaredHarnessPaths().claude } =
   // Parity note: Claude's historical nativePaths() resolved BOTH scopes' root from scopeRoot (the
   // CLI passes $HOME there for -g installs) and never consulted homeDir — so the resolver is fed
   // no homeDir and "root" keeps resolving exactly as before.
-  function nativePaths({ scope, scopeRoot }: any = {}) {
+  function nativePaths({ scope, scopeRoot }      = {}) {
     return resolveHarnessPaths(declaredPaths, { scope, scopeRoot });
   }
 
-  function discover({ scope, scopeRoot, mcp = [], mcpAdoptable = [], ledger, registry, homeDir, context = {} }: any) {
+  function discover({ scope, scopeRoot, mcp = [], mcpAdoptable = [], ledger, registry, homeDir, context = {} }     ) {
     const paths = nativePaths({ scope, scopeRoot });
     return {
       paths,
       instructions: markerState(paths.instructions),
       settingsExists: fs.existsSync(paths.settings),
       mcpExists: fs.existsSync(paths.mcp),
-      knownMcpServers: registry ? selectMcpServers(registry).map((server: any) => server.id) : [],
+      knownMcpServers: registry ? selectMcpServers(registry).map((server     ) => server.id) : [],
       ...discoverMcp({ paths, mcp, mcpAdoptable, ledger, scope, scopeRoot, homeDir: context.homeDir || homeDir || undefined }),
     };
   }
@@ -88,11 +88,11 @@ function createClaudeAdapter({ declaredPaths = declaredHarnessPaths().claude } =
   /** Every asset materialised through the copy-tree engine, whatever its declared renderer:
    * verbatim mirrors declare 'copy-tree', transformed projections (output styles) declare their
    * own name so the registry can tell the shapes apart. Routing is on `kind`, which both share. */
-  function claudeTreeAssets(assets: any) {
-    return [...copyTreeAssets(assets), ...(assets || []).filter((asset: any) => asset.renderer === 'claude-output-styles')];
+  function claudeTreeAssets(assets     ) {
+    return [...copyTreeAssets(assets), ...(assets || []).filter((asset     ) => asset.renderer === 'claude-output-styles')];
   }
 
-  function planCopyTreeAssets({ assets, scope, scopeRoot, context, ledger, removing }: any) {
+  function planCopyTreeAssets({ assets, scope, scopeRoot, context, ledger, removing }     ) {
     const paths = nativePaths({ scope, scopeRoot });
     const changes = [];
     const conflicts = [];
@@ -109,10 +109,10 @@ function createClaudeAdapter({ declaredPaths = declaredHarnessPaths().claude } =
         // is never deleted on removal, forced or not.
         force: !removing && context?.force === true, });
       treeResults.push(result);
-      conflicts.push(...result.conflicts.map((reason: any) => `${asset.id}: ${reason}`));
+      conflicts.push(...result.conflicts.map((reason     ) => `${asset.id}: ${reason}`));
       // A hand-edited file at a path DoFlow no longer writes is the user's: it stays, only its
       // ownership row is released.
-      notices.push(...result.kept.map((item: any) => `kept hand-edited ${path.relative(paths.root, item.target)}; DoFlow no longer manages it`));
+      notices.push(...result.kept.map((item     ) => `kept hand-edited ${path.relative(paths.root, item.target)}; DoFlow no longer manages it`));
       for (const change of result.changes) {
         changes.push({
           assetId: asset.id, target: change.target, source: change.source, operation: change.operation,
@@ -128,7 +128,7 @@ function createClaudeAdapter({ declaredPaths = declaredHarnessPaths().claude } =
     return { changes, conflicts, notices: [...siblingReplacedNotices(treeResults), ...notices] };
   }
 
-  function applyCopyTreeAssets(changes: any) {
+  function applyCopyTreeAssets(changes     ) {
     let applied = 0;
     const grouped = new Map();
     for (const change of changes) {
@@ -143,13 +143,13 @@ function createClaudeAdapter({ declaredPaths = declaredHarnessPaths().claude } =
     return applied;
   }
 
-  function removeCopyTreeAssets(changes: any) {
-    const treeChanges = changes.filter((change: any) => change.kind === 'copy-tree-file' && change.operation === 'remove' && !change.retained)
-      .map((change: any) => ({ relPath: change.identity, target: change.target, operation: 'remove', fingerprint: change.fingerprint, pruneGuard: change.pruneGuard }));
+  function removeCopyTreeAssets(changes     ) {
+    const treeChanges = changes.filter((change     ) => change.kind === 'copy-tree-file' && change.operation === 'remove' && !change.retained)
+      .map((change     ) => ({ relPath: change.identity, target: change.target, operation: 'remove', fingerprint: change.fingerprint, pruneGuard: change.pruneGuard }));
     return removeTree({ changes: treeChanges }).removed;
   }
 
-  function verifyCopyTreeAssets({ assets, scope, scopeRoot, context }: any) {
+  function verifyCopyTreeAssets({ assets, scope, scopeRoot, context }     ) {
     const paths = nativePaths({ scope, scopeRoot });
     const statuses = [];
     const resources = [];
@@ -158,7 +158,7 @@ function createClaudeAdapter({ declaredPaths = declaredHarnessPaths().claude } =
       const destDir = copyTreeDestDir(paths.configDir, asset);
       const sourceDir = sourcePath(asset, context);
       const result = verifyTree({ sourceDir, destDir, layout: asset.layout, transform: asset.transform, plannedWrites: context?.plannedWrites });
-      conflicts.push(...result.conflicts.map((reason: any) => `${asset.id}: ${reason}`));
+      conflicts.push(...result.conflicts.map((reason     ) => `${asset.id}: ${reason}`));
       for (const resource of result.resources) {
         resources.push({
           assetId: asset.id, target: resource.target, ownershipIdentity: `doflow:claude:copy-tree:${asset.id}:${resource.relPath}`,
@@ -174,16 +174,16 @@ function createClaudeAdapter({ declaredPaths = declaredHarnessPaths().claude } =
 
   // ---- claude-settings asset (settings.json + keybindings.json) ----
 
-  function settingsAsset(assets: any) { return (assets || []).find((asset: any) => asset?.renderer === SETTINGS_RENDERER); }
-  function settingsTarget(fileName: any, paths: any) {
+  function settingsAsset(assets     ) { return (assets || []).find((asset     ) => asset?.renderer === SETTINGS_RENDERER); }
+  function settingsTarget(fileName     , paths     ) {
     // Per-file dispatch across the two DECLARED settings surfaces (paths.settings / paths.keybindings):
     // residue because the authored file list is content-shaped, not a single declarable destination.
     return fileName === 'settings.json' ? paths.settings : paths.keybindings;
   }
-  function settingsContent(fileName: any, raw: any, scope: any) {
+  function settingsContent(fileName     , raw     , scope     ) {
     return fileName === 'settings.json' && scope !== 'global' ? raw.split(GLOBAL_HOOK_PREFIX).join(PROJECT_HOOK_PREFIX) : raw;
   }
-  function settingsLedgerResources(ledger: any, assetId: any) {
+  function settingsLedgerResources(ledger     , assetId     ) {
     const byFile = new Map();
     for (const resource of ledger?.resources || []) {
       if (resource.harness === 'claude' && resource.assetId === assetId && resource.kind === 'settings-file') byFile.set(resource.identity, resource);
@@ -194,7 +194,7 @@ function createClaudeAdapter({ declaredPaths = declaredHarnessPaths().claude } =
 
   /** Inject (or leave untouched) the statusLine key pointing at the projected script. Refuses to
    * overwrite a user's existing custom status line unless forced: their script is theirs. */
-  function withStatusLineKey(rawSettingsJson: any, scriptPath: any, force: any) {
+  function withStatusLineKey(rawSettingsJson     , scriptPath     , force     ) {
     let parsed;
     try {
       parsed = JSON.parse(rawSettingsJson);
@@ -207,10 +207,10 @@ function createClaudeAdapter({ declaredPaths = declaredHarnessPaths().claude } =
     return serializeSettings(parsed);
   }
 
-  function planSettingsAsset({ assets, scope, scopeRoot, context, ledger, removing }: any) {
+  function planSettingsAsset({ assets, scope, scopeRoot, context, ledger, removing }     ) {
     const asset = settingsAsset(assets);
-    const changes: any[] = [];
-    const conflicts: any[] = [];
+    const changes        = [];
+    const conflicts        = [];
     if (!asset) return { changes, conflicts };
     const paths = nativePaths({ scope, scopeRoot });
     const sourceDir = sourcePath(asset, context);
@@ -311,7 +311,7 @@ function createClaudeAdapter({ declaredPaths = declaredHarnessPaths().claude } =
   // other copy-tree/settings write in this codebase — planSettingsAsset's own change detection is
   // fingerprint(sha256)-based, not mtime-based, so this is a consistency convention, not a
   // correctness requirement.
-  function applySettingsAsset(changes: any) {
+  function applySettingsAsset(changes     ) {
     let applied = 0;
     for (const change of changes) {
       if (change.projection?.renderer !== SETTINGS_RENDERER || change.operation === 'remove') continue;
@@ -328,7 +328,7 @@ function createClaudeAdapter({ declaredPaths = declaredHarnessPaths().claude } =
   // is deleted outright only when nothing but schema pointers remains — i.e. DoFlow created it.
   // Previously this rmSync'd unconditionally, which on a user-maintained settings.json would have
   // destroyed their model, permissions, env, and every foreign tool's hooks along with ours.
-  function removeSettingsAsset(changes: any) {
+  function removeSettingsAsset(changes     ) {
     let removed = 0;
     for (const change of changes) {
       if (change.projection?.renderer !== SETTINGS_RENDERER || change.operation !== 'remove') continue;
@@ -347,11 +347,11 @@ function createClaudeAdapter({ declaredPaths = declaredHarnessPaths().claude } =
     return removed;
   }
 
-  function verifySettingsAsset({ assets, scope, scopeRoot, context }: any) {
+  function verifySettingsAsset({ assets, scope, scopeRoot, context }     ) {
     const asset = settingsAsset(assets);
-    const statuses: any[] = [];
-    const resources: any[] = [];
-    const conflicts: any[] = [];
+    const statuses        = [];
+    const resources        = [];
+    const conflicts        = [];
     if (!asset) return { statuses, resources, conflicts };
     const paths = nativePaths({ scope, scopeRoot });
     const sourceDir = sourcePath(asset, context);
@@ -424,9 +424,9 @@ function createClaudeAdapter({ declaredPaths = declaredHarnessPaths().claude } =
 
   /** Render native Claude input without writing it.
    * `asset` is the lifecycle-projected shape (flat `renderer`/`capability` fields — see
-   * src/adapters/index.ts#projectAdapterInput), not the raw registry asset's nested
+   * src/adapters/index.js#projectAdapterInput), not the raw registry asset's nested
    * `asset.projection.claude`. Every adapter method below shares that same expectation. */
-  function render({ asset, scope, scopeRoot, context = {} }: any) {
+  function render({ asset, scope, scopeRoot, context = {} }     ) {
     const paths = nativePaths({ scope, scopeRoot });
     if (asset?.renderer === INSTRUCTION_RENDERER) {
       const source = sourcePath(asset, context);
@@ -444,7 +444,7 @@ function createClaudeAdapter({ declaredPaths = declaredHarnessPaths().claude } =
     return { type: 'unsupported', assetId: asset?.id, renderer: asset?.renderer ?? null };
   }
 
-  function plan({ assets, scope, scopeRoot, mcp = [], mcpAdoptable = [], discovery, context = {}, ledger }: any) {
+  function plan({ assets, scope, scopeRoot, mcp = [], mcpAdoptable = [], discovery, context = {}, ledger }     ) {
     const changes = [];
     const conflicts = [];
     const paths = nativePaths({ scope, scopeRoot });
@@ -480,13 +480,13 @@ function createClaudeAdapter({ declaredPaths = declaredHarnessPaths().claude } =
     return { changes, conflicts, prerequisites: [], notices: [...copyTree.notices, ...mcpPlan.notices] };
   }
 
-  function apply({ changes, scope, scopeRoot, context = {} }: any) {
+  function apply({ changes, scope, scopeRoot, context = {} }     ) {
     for (const change of changes) {
       if (change.projection?.renderer !== INSTRUCTION_RENDERER) continue;
       // A plan records the resolved source. This keeps apply self-contained when
       // the lifecycle supplies normalized changes rather than the original asset
       // array, while still avoiding any implicit source discovery at write time.
-      const source = change.source ?? sourcePath((context.assets || []).find((item: any) => item.id === change.assetId), context);
+      const source = change.source ?? sourcePath((context.assets || []).find((item     ) => item.id === change.assetId), context);
       mergeMarkedSection(source, change.target ?? nativePaths({ scope, scopeRoot }).instructions);
     }
     applyCopyTreeAssets(changes);
@@ -498,7 +498,7 @@ function createClaudeAdapter({ declaredPaths = declaredHarnessPaths().claude } =
     return { applied: changes.length };
   }
 
-  function remove({ changes }: any) {
+  function remove({ changes }     ) {
     let removed = 0;
     for (const change of changes) {
       if (change.projection?.renderer === INSTRUCTION_RENDERER && removeMarkedSection(change.target)) removed += 1;
@@ -509,11 +509,11 @@ function createClaudeAdapter({ declaredPaths = declaredHarnessPaths().claude } =
     return { removed };
   }
 
-  function verify({ assets, scope, scopeRoot, mcp = [], mcpAdoptable = [], discovery, ledger, operation, context = {} }: any) {
+  function verify({ assets, scope, scopeRoot, mcp = [], mcpAdoptable = [], discovery, ledger, operation, context = {} }     ) {
     const paths = nativePaths({ scope, scopeRoot });
     const statuses = [];
     const resources = [];
-    const instruction = assets.find((asset: any) => asset?.renderer === INSTRUCTION_RENDERER);
+    const instruction = assets.find((asset     ) => asset?.renderer === INSTRUCTION_RENDERER);
     const state = markerState(paths.instructions);
     if (instruction) {
       statuses.push({ assetId: instruction.id, status: state.managed ? 'managed' : 'absent', target: paths.instructions });