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

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,26 @@ function createClaudeAdapter({ declaredPaths = declaredHarnessPaths().claude } =
     return { changes, conflicts, prerequisites: [], notices: [...copyTree.notices, ...mcpPlan.notices] };
   }
 
-  function apply({ changes, scope, scopeRoot, context = {} }: any) {
+  /** The hook front doors (IC-037): the one asset that holds the scripts the settings hooks run. */
+  function hookDoorAssets(assets     ) { return (assets || []).filter((asset     ) => asset.id === 'claude.hooks-scripts'); }
+
+  function planHookDoors({ assets, scope, scopeRoot, context = {}, ledger }     ) {
+    const doors = planCopyTreeAssets({ assets: hookDoorAssets(assets), scope, scopeRoot, context, ledger, removing: false });
+    return { changes: doors.changes, conflicts: doors.conflicts, prerequisites: [], notices: doors.notices };
+  }
+
+  function verifyHookDoors({ assets, scope, scopeRoot, context = {} }     ) {
+    const doors = verifyCopyTreeAssets({ assets: hookDoorAssets(assets), scope, scopeRoot, context });
+    return { ok: doors.conflicts.length === 0, statuses: doors.statuses, resources: doors.resources, conflicts: doors.conflicts };
+  }
+
+  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 +511,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 +522,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 });
@@ -536,7 +549,7 @@ function createClaudeAdapter({ declaredPaths = declaredHarnessPaths().claude } =
     return { ok: conflicts.length === 0, statuses, resources, conflicts };
   }
 
-  return { nativePaths, discover, render, plan, apply, remove, verify };
+  return { nativePaths, discover, render, plan, apply, remove, verify, planHookDoors, verifyHookDoors };
 }
 
 const singleton = createClaudeAdapter();
@@ -544,5 +557,6 @@ const singleton = createClaudeAdapter();
 module.exports = {
   nativePaths: singleton.nativePaths, discover: singleton.discover, render: singleton.render,
   plan: singleton.plan, apply: singleton.apply, remove: singleton.remove, verify: singleton.verify,
+  planHookDoors: singleton.planHookDoors, verifyHookDoors: singleton.verifyHookDoors,
   createClaudeAdapter,
 };

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

@@ -10,8 +10,8 @@
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
-const { nativeMcpCatalog } = require('../../registry/index.ts');
-const { readMcpFiles, planMcpEntries, verifyMcpEntries, ownedMcpIds, writeMcpEntries } = require('../mcp-entries.ts');
+const { nativeMcpCatalog } = require('../../registry/index.js');
+const { readMcpFiles, planMcpEntries, verifyMcpEntries, ownedMcpIds, writeMcpEntries } = require('../mcp-entries.js');
 
 const HARNESS = 'claude';
 const MCP_CONTAINER = 'mcpServers';
@@ -20,39 +20,39 @@ const MCP_RENDERER = 'claude-mcp';
 // install carries.
 const MCP_ASSET_ID = 'guidance.core';
 
-function ownershipIdentity(id: any) { return `doflow:${HARNESS}:mcp-server:${id}`; }
+function ownershipIdentity(id     ) { return `doflow:${HARNESS}:mcp-server:${id}`; }
 
 /** Claude Code's own per-server shape, the one the registry's native catalog renders. */
-function rendered(servers: any) {
+function rendered(servers     ) {
   const { serverDefs } = nativeMcpCatalog(servers);
-  return servers.map((server: any) => ({ id: server.id, entry: serverDefs[server.id] }));
+  return servers.map((server     ) => ({ id: server.id, entry: serverDefs[server.id] }));
 }
 
 /** Everything the shared entry-ownership rules need from this adapter. */
-function mcpEntriesInput({ paths, mcp = [], mcpAdoptable = [], ledger }: any) {
-  const rows = (ledger?.resources || []).filter((row: any) => row.kind === 'mcp-server');
+function mcpEntriesInput({ paths, mcp = [], mcpAdoptable = [], ledger }     ) {
+  const rows = (ledger?.resources || []).filter((row     ) => row.kind === 'mcp-server');
   return {
     file: paths.mcp, 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: MCP_ASSET_ID, renderer: MCP_RENDERER, label: 'Claude MCP',
   };
 }
 
-function readFiles(entries: any, fsImpl: any) {
+function readFiles(entries     , fsImpl     ) {
   return readMcpFiles({ file: entries.file, ownRows: entries.ownRows, container: MCP_CONTAINER, fsImpl });
 }
 
 /** Server names Claude Code merges into a project from `~/.claude.json` beside the project's own
  * `.mcp.json`: the local scope (`projects[<root>].mcpServers`) and the user scope (`mcpServers`).
  * Read-only and for reach alone; a file that cannot be read contributes nothing (null). */
-function claudeJsonNames({ scopeRoot, homeDir, fsImpl }: any) {
+function claudeJsonNames({ scopeRoot, homeDir, fsImpl }     ) {
   let doc;
   try { doc = JSON.parse(fsImpl.readFileSync(path.join(homeDir, '.claude.json'), 'utf8')); } catch { return null; }
   if (!doc || typeof doc !== 'object' || Array.isArray(doc)) return null;
-  const names = (servers: any) => (servers && typeof servers === 'object' && !Array.isArray(servers) ? Object.keys(servers) : []);
+  const names = (servers     ) => (servers && typeof servers === 'object' && !Array.isArray(servers) ? Object.keys(servers) : []);
   const projects = doc.projects && typeof doc.projects === 'object' ? doc.projects : {};
   let real = scopeRoot;
   try { real = fsImpl.realpathSync(scopeRoot); } catch { /* the path as given */ }
@@ -64,7 +64,7 @@ function claudeJsonNames({ scopeRoot, homeDir, fsImpl }: any) {
  * (`mcpConfigured`): the scope's file, plus at project scope the local- and user-scope entries in
  * `~/.claude.json`. Claude Code also loads plugin, managed and connector servers DoFlow does not
  * read, so the view is never complete (`mcpComplete: false`) and absence is never proof. */
-function discoverMcp({ paths, mcp, mcpAdoptable, ledger, scope, scopeRoot, homeDir = os.homedir(), fsImpl = fs }: any) {
+function discoverMcp({ paths, mcp, mcpAdoptable, ledger, scope, scopeRoot, homeDir = os.homedir(), fsImpl = fs }     ) {
   const entries = mcpEntriesInput({ paths, mcp, mcpAdoptable, ledger });
   const mcpSnapshot = readFiles(entries, fsImpl);
   // `null` while nothing could be read; every name otherwise, whoever wrote it.
@@ -75,17 +75,17 @@ function discoverMcp({ paths, mcp, mcpAdoptable, ledger, scope, scopeRoot, homeD
   return { mcpSnapshot, mcpOwned: ownedMcpIds({ ...entries, files: mcpSnapshot }), mcpConfigured, mcpComplete: false };
 }
 
-function planMcp({ paths, mcp, mcpAdoptable, ledger, snapshot, removing, fsImpl = fs }: any) {
+function planMcp({ paths, mcp, mcpAdoptable, ledger, snapshot, removing, fsImpl = fs }     ) {
   const entries = mcpEntriesInput({ paths, mcp, mcpAdoptable, ledger });
   return planMcpEntries({ ...entries, files: snapshot ?? readFiles(entries, fsImpl), removing });
 }
 
 /** An emptied `mcpServers` stays as `{}`, as Claude Code itself leaves it. */
-function writeMcp(changes: any, { fsImpl = fs } = {}) {
+function writeMcp(changes     , { fsImpl = fs } = {}) {
   return writeMcpEntries(changes, { container: MCP_CONTAINER, keepEmptyContainer: true, fsImpl });
 }
 
-function verifyMcp({ paths, mcp, mcpAdoptable, ledger, snapshot, removing, sourceVersion, fsImpl = fs }: any) {
+function verifyMcp({ paths, mcp, mcpAdoptable, ledger, snapshot, removing, sourceVersion, fsImpl = fs }     ) {
   const entries = mcpEntriesInput({ paths, mcp, mcpAdoptable, ledger });
   const files = readFiles(entries, fsImpl);
   return verifyMcpEntries({ ...entries, files, snapshot: snapshot ?? files, removing, harness: HARNESS, sourceVersion });

package/src/adapters/codex/{agents.ts → agents.js}

@@ -8,7 +8,7 @@
 const crypto = require('node:crypto');
 const fs = require('node:fs');
 const path = require('node:path');
-const { atomicWrite } = require('./config.ts');
+const { atomicWrite } = require('./config.js');
 
 const AGENT_DIRECTORY = 'agents';
 const AGENT_KIND = 'custom-agent';
@@ -23,38 +23,38 @@ const IMPLEMENTATION_ROLES = new Set([
 ]);
 const ALLOWED_FIELDS = new Set([...REQUIRED_FIELDS, 'sandbox_mode']);
 
-function fingerprint(content: string): string {
+function fingerprint(content        )         {
   return `sha256:${crypto.createHash('sha256').update(content).digest('hex')}`;
 }
 
-function assertAgentName(name: any, label: string = 'agent name'): string {
+function assertAgentName(name     , label         = 'agent name')         {
   if (typeof name !== 'string' || !/^[a-z][a-z0-9-]*$/.test(name)) {
     throw new Error(`${label} must be a lowercase kebab-case identifier`);
   }
   return name;
 }
 
-function filenameFor(name: string): string {
+function filenameFor(name        )         {
   assertAgentName(name);
   return `${name}.toml`;
 }
 
-function expectedName(fileName: any): string {
+function expectedName(fileName     )         {
   if (typeof fileName !== 'string' || path.basename(fileName) !== fileName || !fileName.endsWith('.toml')) {
     throw new Error('Agent filename must be a direct .toml filename');
   }
   return assertAgentName(fileName.slice(0, -'.toml'.length), 'Agent filename');
 }
 
-function parseQuoted(value: string, field: string, line: number): string {
+function parseQuoted(value        , field        , line        )         {
   if (!/^"(?:[^"\\\n]|\\.)*"$/.test(value)) throw new Error(`${field} must be a quoted TOML string on line ${line}`);
   try { return JSON.parse(value); } catch { throw new Error(`${field} has an invalid quoted value on line ${line}`); }
 }
 
 /** Parse the intentionally small TOML contract supported by Codex agent definitions. */
-function parseAgentToml(source: any, { fileName }: { fileName?: string } = {}): Record<string, string> {
+function parseAgentToml(source     , { fileName }                        = {})                         {
   if (typeof source !== 'string') throw new Error('Agent TOML source must be text');
-  const values: Record<string, string> = {};
+  const values                         = {};
   const lines = source.split(/\r?\n/);
   for (let index = 0; index < lines.length; index++) {
     const line = lines[index];
@@ -64,7 +64,7 @@ function parseAgentToml(source: any, { fileName }: { fileName?: string } = {}):
       const field = triple[1];
       if (!ALLOWED_FIELDS.has(field)) throw new Error(`Unsupported agent field '${field}'`);
       if (Object.hasOwn(values, field)) throw new Error(`Duplicate agent field '${field}'`);
-      const body: string[] = [];
+      const body           = [];
       let closed = false;
       while (++index < lines.length) {
         if (/^"""\s*$/.test(lines[index])) { closed = true; break; }
@@ -85,7 +85,7 @@ function parseAgentToml(source: any, { fileName }: { fileName?: string } = {}):
   return values;
 }
 
-function validateAgentContract(source: any, { fileName }: { fileName?: string } = {}): any {
+function validateAgentContract(source     , { fileName }                        = {})      {
   const agent = parseAgentToml(source, { fileName });
   for (const field of REQUIRED_FIELDS) {
     if (typeof agent[field] !== 'string' || !agent[field].trim()) throw new Error(`Agent is missing required '${field}'`);
@@ -106,7 +106,7 @@ function validateAgentContract(source: any, { fileName }: { fileName?: string }
   return Object.freeze({ ...agent, fileName: filenameFor(agent.name) });
 }
 
-function agentDirectory({ scope, codexDir, projectRoot, paths }: { scope?: string, codexDir?: string, projectRoot?: string, paths?: any } = {}): string {
+function agentDirectory({ scope, codexDir, projectRoot, paths }                                                                           = {})         {
   // Preferred: the declared path resolved by the adapter (harnesses.json "paths".agentsDirectory).
   if (paths?.agentsDirectory) return paths.agentsDirectory;
   // Legacy derivation for direct callers passing raw scope inputs; kept byte-compatible with the
@@ -122,19 +122,19 @@ function agentDirectory({ scope, codexDir, projectRoot, paths }: { scope?: strin
   throw new Error(`Unsupported Codex agent scope: ${scope}`);
 }
 
-function destinationFor(directory: string, name: string): string {
+function destinationFor(directory        , name        )         {
   const file = path.resolve(directory, filenameFor(name));
   const root = `${path.resolve(directory)}${path.sep}`;
   if (!file.startsWith(root)) throw new Error(`Refusing to write agent '${name}' outside the Codex agents directory`);
   return file;
 }
 
-function discoverCodexAgents(sourceDir: any, fsImpl: any = fs): any[] {
+function discoverCodexAgents(sourceDir     , fsImpl      = fs)        {
   if (!sourceDir) throw new Error('sourceDir is required for Codex agents');
   const directory = path.resolve(sourceDir);
   if (!fsImpl.existsSync(directory)) throw new Error(`Codex agent source directory does not exist: ${sourceDir}`);
-  const agents: any[] = [];
-  for (const entry of fsImpl.readdirSync(directory, { withFileTypes: true }).sort((a: any, b: any) => a.name.localeCompare(b.name))) {
+  const agents        = [];
+  for (const entry of fsImpl.readdirSync(directory, { withFileTypes: true }).sort((a     , b     ) => a.name.localeCompare(b.name))) {
     if (!entry.name.endsWith('.toml')) continue;
     if (!entry.isFile()) throw new Error(`Codex agent source '${entry.name}' must be a regular file`);
     const name = expectedName(entry.name);
@@ -145,11 +145,11 @@ function discoverCodexAgents(sourceDir: any, fsImpl: any = fs): any[] {
   return agents;
 }
 
-function isOwnedResource(resource: any, scope: any): boolean {
+function isOwnedResource(resource     , scope     )          {
   return resource && resource.target === 'codex' && resource.scope === scope && resource.kind === AGENT_KIND && typeof resource.identity === 'string';
 }
 
-function resourceFor(agent: any, scope: any, sourceVersion: any): any {
+function resourceFor(agent     , scope     , sourceVersion     )      {
   return {
     target: 'codex', scope, kind: AGENT_KIND, identity: `agent:${agent.name}`,
     sourceVersion, fingerprint: agent.fingerprint, selection: true,
@@ -163,13 +163,13 @@ function resourceFor(agent: any, scope: any, sourceVersion: any): any {
  *   recording ownership instead of refusing. See planCodexConfig for why this is not `force`: a
  *   record that disagrees with the file on disk stays a conflict regardless of `adopt`.
  */
-function planCodexAgents({ scope, codexDir, projectRoot, sourceDir, sourceVersion = 'unknown', managedResources = [], adopt = false, fsImpl = fs }: any): any {
+function planCodexAgents({ scope, codexDir, projectRoot, sourceDir, sourceVersion = 'unknown', managedResources = [], adopt = false, fsImpl = fs }     )      {
   const directory = agentDirectory({ scope, codexDir, projectRoot });
   const agents = discoverCodexAgents(sourceDir, fsImpl);
-  const owned = new Map<string, any>(managedResources.filter((resource: any) => isOwnedResource(resource, scope)).map((resource: any) => [resource.identity, resource]));
-  const changes: any[] = [];
-  const conflicts: string[] = [];
-  const nextManagedResources = managedResources.filter((resource: any) => !isOwnedResource(resource, scope));
+  const owned = new Map             (managedResources.filter((resource     ) => isOwnedResource(resource, scope)).map((resource     ) => [resource.identity, resource]));
+  const changes        = [];
+  const conflicts           = [];
+  const nextManagedResources = managedResources.filter((resource     ) => !isOwnedResource(resource, scope));
   for (const agent of agents) {
     const file = destinationFor(directory, agent.name);
     const identity = `agent:${agent.name}`;
@@ -191,13 +191,13 @@ function planCodexAgents({ scope, codexDir, projectRoot, sourceDir, sourceVersio
   };
 }
 
-function applyCodexAgents(plan: any, { dryRun = false, fsImpl = fs }: { dryRun?: boolean, fsImpl?: any } = {}): any {
+function applyCodexAgents(plan     , { dryRun = false, fsImpl = fs }                                     = {})      {
   if (!plan.ok || dryRun || plan.status === 'unchanged') return { ...plan, applied: false };
   for (const change of plan.changes) atomicWrite(change.file, change.content, fsImpl);
   return { ...plan, applied: true };
 }
 
-function reconcileCodexAgents(options: any): any {
+function reconcileCodexAgents(options     )      {
   return applyCodexAgents(planCodexAgents(options), options);
 }