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

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

@@ -13,24 +13,24 @@ const {
   parseToml,
   newViolation,
   atomicWrite,
-} = require('./config.ts');
-const { selectMcpServers, nativeMcpCatalog } = require('../../registry/index.ts');
-const { NOTICES } = require('../mcp-entries.ts');
-const { stripComment } = require('../../helper/toml.ts');
+} = require('./config.js');
+const { selectMcpServers, nativeMcpCatalog } = require('../../registry/index.js');
+const { NOTICES } = require('../mcp-entries.js');
+const { stripComment } = require('../../helper/toml.js');
 
 const MCP_KIND = 'mcp-server';
 const MCP_PREFIX = 'mcp_servers.';
 
 /** @param {object} registry a loaded registry (src/registry#loadRegistry) */
-function readCodexMcpCatalog(registry: any) {
+function readCodexMcpCatalog(registry     ) {
   return nativeMcpCatalog(selectMcpServers(registry));
 }
 
-function isSafeServerName(name: any) {
+function isSafeServerName(name     ) {
   return /^[A-Za-z0-9_-]+$/.test(name);
 }
 
-function tomlValue(value: any): string {
+function tomlValue(value     )         {
   if (typeof value === 'string') return JSON.stringify(value);
   if (typeof value === 'boolean' || typeof value === 'number') return String(value);
   if (Array.isArray(value)) return `[${value.map(tomlValue).join(', ')}]`;
@@ -40,7 +40,7 @@ function tomlValue(value: any): string {
   throw new Error('Codex MCP definitions may only contain TOML-compatible values');
 }
 
-function renderServer(name: any, definition: any) {
+function renderServer(name     , definition     ) {
   if (!isSafeServerName(name)) throw new Error(`Unsupported Codex MCP server name '${name}'`);
   if (!definition || typeof definition !== 'object' || Array.isArray(definition)) {
     throw new Error(`Codex MCP server '${name}' requires an object definition`);
@@ -56,7 +56,7 @@ function renderServer(name: any, definition: any) {
   return `${lines.join('\n')}\n`;
 }
 
-function resourceFor({ name, scope, definition, sourceVersion, recoveryPoint }: any) {
+function resourceFor({ name, scope, definition, sourceVersion, recoveryPoint }     ) {
   return {
     target: 'codex', scope, kind: MCP_KIND, identity: name,
     sourceVersion, selection: true, recoveryPoint,
@@ -64,12 +64,12 @@ function resourceFor({ name, scope, definition, sourceVersion, recoveryPoint }:
   };
 }
 
-function isOwnedRecord(resource: any, scope: any) {
+function isOwnedRecord(resource     , scope     ) {
   return resource && resource.target === 'codex' && resource.scope === scope &&
     resource.kind === MCP_KIND && typeof resource.identity === 'string';
 }
 
-function tableRanges(text: any) {
+function tableRanges(text     ) {
   const lines = text.split(/\r?\n/);
   const tables = [];
   for (let index = 0; index < lines.length; index++) {
@@ -96,25 +96,25 @@ function tableRanges(text: any) {
   return { lines, tables };
 }
 
-function fullServerRange(tables: any, name: any) {
-  return tables.find((table: any) => table.name === name) ?? null;
+function fullServerRange(tables     , name     ) {
+  return tables.find((table     ) => table.name === name) ?? null;
 }
 
 /** One table's text as its fingerprint is taken. */
-function tableText(lines: any, range: any) {
+function tableText(lines     , range     ) {
   return `${lines.slice(range.start, range.end).join('\n').replace(/\n*$/, '\n')}`;
 }
 
 /** Whether config.toml defines server `name` in any form: a bare `[mcp_servers.<name>]` header, a
  * quoted header, a sub-table, or dotted keys and inline tables under `mcp_servers`. */
-function definedInFile(name: any, { tables, parsed }: any) {
-  const own = (key: any) => key === `${MCP_PREFIX}${name}` || key.startsWith(`${MCP_PREFIX}${name}.`);
-  return tables.some((table: any) => table.name === name) || parsed.headers.some((header: any) => own(header.table))
+function definedInFile(name     , { tables, parsed }     ) {
+  const own = (key     ) => key === `${MCP_PREFIX}${name}` || key.startsWith(`${MCP_PREFIX}${name}.`);
+  return tables.some((table     ) => table.name === name) || parsed.headers.some((header     ) => own(header.table))
     || [...parsed.entries.keys()].some(own);
 }
 
 /** The text of server `name`'s bare table, as its fingerprint is taken, or null when it has none. */
-function serverTableText(text: any, name: any) {
+function serverTableText(text     , name     ) {
   const { lines, tables } = tableRanges(text);
   const range = fullServerRange(tables, name);
   return range ? tableText(lines, range) : null;
@@ -122,35 +122,35 @@ function serverTableText(text: any, name: any) {
 
 /** The names among `names` that config.toml defines with no owned record: the user's own servers,
  * which DoFlow never writes, removes or records. A file that cannot be read or parsed yields none. */
-function userDefinedCodexMcpIds({ file, scope, names = [], managedResources = [], fsImpl = fs }: any) {
+function userDefinedCodexMcpIds({ file, scope, names = [], managedResources = [], fsImpl = fs }     ) {
   let text; let parsed;
   try {
     text = fsImpl.existsSync(file) ? fsImpl.readFileSync(file, 'utf8') : '';
     parsed = parseToml(text);
   } catch { return []; }
   const { tables } = tableRanges(text);
-  const owned = new Set(managedResources.filter((resource: any) => isOwnedRecord(resource, scope)).map((resource: any) => resource.identity));
+  const owned = new Set(managedResources.filter((resource     ) => isOwnedRecord(resource, scope)).map((resource     ) => resource.identity));
   return [...new Set(names)].filter((name) => !owned.has(name) && definedInFile(name, { tables, parsed }));
 }
 
 /** The tables DoFlow owns in config.toml now: owned records whose table is present with the
  * fingerprint the record holds. A file that cannot be read or parsed yields none. */
-function ownedCodexMcpIds({ file, scope, managedResources = [], fsImpl = fs }: any) {
+function ownedCodexMcpIds({ file, scope, managedResources = [], fsImpl = fs }     ) {
   let text;
   try {
     text = fsImpl.existsSync(file) ? fsImpl.readFileSync(file, 'utf8') : '';
     parseToml(text);
   } catch { return []; }
   const { lines, tables } = tableRanges(text);
-  return managedResources.filter((resource: any) => isOwnedRecord(resource, scope)).filter((resource: any) => {
+  return managedResources.filter((resource     ) => isOwnedRecord(resource, scope)).filter((resource     ) => {
     const range = fullServerRange(tables, resource.identity);
     return range !== null && fingerprint(tableText(lines, range)) === resource.fingerprint;
-  }).map((resource: any) => resource.identity);
+  }).map((resource     ) => resource.identity);
 }
 
 /** How to stop managing a server whose table the user changed: the same run without it selected. */
-function modifiedConflict(name: any, desired: any, scopeArg: any) {
-  const rest = desired.filter((item: any) => item !== name);
+function modifiedConflict(name     , desired     , scopeArg     ) {
+  const rest = desired.filter((item     ) => item !== name);
   // Quoted for a POSIX shell when it holds anything a shell would split or expand, so the command
   // works as copied for a project root with a space in it.
   const arg = /^[A-Za-z0-9_@%+=:,./-]+$/.test(scopeArg) ? scopeArg : `'${scopeArg.replace(/'/g, "'\\''")}'`;
@@ -165,27 +165,27 @@ function modifiedConflict(name: any, desired: any, scopeArg: any) {
  * @param {string} [options.scopeArg='-g'] the scope as the user types it (`-g` or the project root),
  *   for the command a conflict names.
  */
-function planCodexMcp({ file, scope, managedResources = [], selected = [], allServers, serverDefs, sourceVersion, recoveryPoint, removing = false, scopeArg = '-g' }: any) {
+function planCodexMcp({ file, scope, managedResources = [], selected = [], allServers, serverDefs, sourceVersion, recoveryPoint, removing = false, scopeArg = '-g' }     ) {
   const original = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
   let parsed;
-  try { parsed = parseToml(original); } catch (error: any) {
+  try { parsed = parseToml(original); } catch (error     ) {
     return { ok: false, status: 'malformed', file, original, changes: [], conflicts: [error.message], managedResources };
   }
   if (!Array.isArray(allServers) || !serverDefs || typeof serverDefs !== 'object') {
     return { ok: false, status: 'invalid-request', file, original, changes: [], conflicts: ['Codex MCP catalog is required'], managedResources };
   }
-  const unknown = selected.filter((name: any) => !allServers.includes(name));
+  const unknown = selected.filter((name     ) => !allServers.includes(name));
   if (unknown.length) return { ok: false, status: 'invalid-request', file, original, changes: [], conflicts: [`Unknown MCP server(s): ${unknown.join(', ')}`], managedResources };
-  const desired: any[] = [...new Set<any>(selected)];
-  try { for (const name of desired) renderServer(name, serverDefs[name]); } catch (error: any) {
+  const desired        = [...new Set     (selected)];
+  try { for (const name of desired) renderServer(name, serverDefs[name]); } catch (error     ) {
     return { ok: false, status: 'invalid-request', file, original, changes: [], conflicts: [error.message], managedResources };
   }
 
   const { lines, tables } = tableRanges(original);
-  const owned = new Map<string, any>(managedResources.filter((resource: any) => isOwnedRecord(resource, scope)).map((resource: any) => [resource.identity, resource]));
-  const changes: any[] = [];
-  const conflicts: string[] = [];
-  const notices: string[] = [];
+  const owned = new Map             (managedResources.filter((resource     ) => isOwnedRecord(resource, scope)).map((resource     ) => [resource.identity, resource]));
+  const changes        = [];
+  const conflicts           = [];
+  const notices           = [];
   const userDefined = allServers.filter((name) => !owned.has(name) && definedInFile(name, { tables, parsed }));
   const names = new Set([...desired, ...owned.keys()]);
   for (const name of names) {
@@ -235,24 +235,24 @@ function planCodexMcp({ file, scope, managedResources = [], selected = [], allSe
   const invalid = newViolation({ file, original, content, identities: changes.map((change) => change.identity) });
   if (invalid) return { ok: false, status: 'conflict', file, original, changes: [], conflicts: [invalid], managedResources };
 
-  const nextManagedResources = managedResources.filter((resource: any) => !isOwnedRecord(resource, scope) || desired.includes(resource.identity));
+  const nextManagedResources = managedResources.filter((resource     ) => !isOwnedRecord(resource, scope) || desired.includes(resource.identity));
   for (const name of desired) {
     if (userDefined.includes(name)) continue;
     const next = resourceFor({ name, scope, definition: serverDefs[name], sourceVersion, recoveryPoint });
-    const index = nextManagedResources.findIndex((resource: any) => isOwnedRecord(resource, scope) && resource.identity === name);
+    const index = nextManagedResources.findIndex((resource     ) => isOwnedRecord(resource, scope) && resource.identity === name);
     if (index >= 0) nextManagedResources[index] = next;
     else nextManagedResources.push(next);
   }
   return { ok: true, status: changes.length ? 'change' : 'unchanged', file, original, content, changes, conflicts: [], notices, userDefined, managedResources: nextManagedResources };
 }
 
-function applyCodexMcp(plan: any, { dryRun = false, fsImpl = fs } = {}) {
+function applyCodexMcp(plan     , { dryRun = false, fsImpl = fs } = {}) {
   if (!plan.ok || dryRun || plan.status === 'unchanged') return { ...plan, applied: false };
   atomicWrite(plan.file, plan.content, fsImpl);
   return { ...plan, applied: true };
 }
 
-function reconcileCodexMcp(options: any) {
+function reconcileCodexMcp(options     ) {
   const file = options.file ?? configPath(options);
   return applyCodexMcp(planCodexMcp({ ...options, file }), options);
 }

package/src/adapters/codex/{native-projection.ts → native-projection.js}

@@ -3,25 +3,25 @@
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): run directly by Node native type-stripping.
 
 // Codex's native-projection normalizer, moved here from the common adapter module (review A3:
-// `nativeProjectionFor` in src/adapters/index.ts contained this Codex-specific shape inline, so
+// `nativeProjectionFor` in src/adapters/index.js contained this Codex-specific shape inline, so
 // per-harness knowledge lived on the shared side of the adapter boundary). The common module now
 // only dispatches by adapter name; the shape below — configResources / mcp catalog / agents dir /
 // hooks trust — is Codex's own and belongs to its adapter directory.
 
-const { resolveRegistrySource } = require('../resolve-source.ts');
+const { resolveRegistrySource } = require('../resolve-source.js');
 
 /** Normalize the validated Codex registry declaration into its adapter's named
  * input. Source paths always come from the registry; runtime overrides only
  * affect an explicitly safe trust acknowledgement. */
-function normalizeNativeProjection(registry: any, harness: any, mcp: any[], context: any): any {
+function normalizeNativeProjection(registry     , harness     , mcp       , context     )      {
   const declaration = harness.nativeProjection;
   const override = context.projectionOverrides?.[harness.id] ?? {};
   if (!override || typeof override !== 'object' || Array.isArray(override)) throw new Error(`Projection override for '${harness.id}' must be an object`);
   const trusted = override.hooks?.trusted;
   if (trusted !== undefined && typeof trusted !== 'boolean') throw new Error(`Projection override '${harness.id}.hooks.trusted' must be boolean`);
   return Object.freeze({
-    configResources: Object.freeze((declaration.config?.resources || []).map((resource: any) => Object.freeze({ ...resource }))),
-    mcp: Object.freeze({ catalog: Object.freeze(mcp.map((server: any) => Object.freeze({ ...server }))), selected: Object.freeze(mcp.map((server: any) => server.id)) }),
+    configResources: Object.freeze((declaration.config?.resources || []).map((resource     ) => Object.freeze({ ...resource }))),
+    mcp: Object.freeze({ catalog: Object.freeze(mcp.map((server     ) => Object.freeze({ ...server }))), selected: Object.freeze(mcp.map((server     ) => server.id)) }),
     agents: Object.freeze({ sourceDir: resolveRegistrySource(registry, declaration.agents?.source, `${harness.id} agents`) }),
     hooks: Object.freeze({
       sourceFile: resolveRegistrySource(registry, declaration.hooks?.configSource, `${harness.id} hooks config`),

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

@@ -25,10 +25,10 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-const { MARKER_START, MARKER_END } = require('../../helper/marker-merge.ts');
-const { planTree, applyTree, removeTree, verifyTree, copyTreeDestDir, ledgerFileResources, ledgerSiblingFingerprints, siblingReplacedNotices, fingerprint, sourceDirFor, resolveTransform } = require('../copy-tree.ts');
-const { readMcpFiles, planMcpEntries, verifyMcpEntries, ownedMcpIds, writeMcpEntries } = require('../mcp-entries.ts');
-const { declaredHarnessPaths, resolveHarnessPaths } = require('../../helper/harness-paths.ts');
+const { MARKER_START, MARKER_END } = require('../../helper/marker-merge.js');
+const { planTree, applyTree, removeTree, verifyTree, copyTreeDestDir, ledgerFileResources, ledgerSiblingFingerprints, siblingReplacedNotices, fingerprint, sourceDirFor, resolveTransform } = require('../copy-tree.js');
+const { readMcpFiles, planMcpEntries, verifyMcpEntries, ownedMcpIds, writeMcpEntries } = require('../mcp-entries.js');
+const { declaredHarnessPaths, resolveHarnessPaths } = require('../../helper/harness-paths.js');
 
 const HARNESS = 'copilot';
 /** Message text naming the instruction file the declared paths.instruction surface installs.
@@ -59,13 +59,13 @@ function createCopilotAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
   // Parity note: Copilot's historical nativePaths() derived even its user-scope root from scopeRoot
   // (the CLI passes $HOME there for -g installs), never from a separate homeDir argument — 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 });
   }
 
   /** Discovery keeps the MCP files as plan read them (`mcpSnapshot`), which verify compares against,
    * and reports the servers DoFlow owns in Copilot's MCP config now (`mcpOwned`). */
-  function discover({ scope, scopeRoot, mcp = [], mcpAdoptable = [], ledger, fsImpl = fs }: any) {
+  function discover({ scope, scopeRoot, mcp = [], mcpAdoptable = [], ledger, fsImpl = fs }     ) {
     const paths = nativePaths({ scope, scopeRoot });
     const instruction = paths.instruction && fsImpl.existsSync(paths.instruction) ? fsImpl.readFileSync(paths.instruction, 'utf8') : null;
     const entries = mcpEntriesInput({ paths, mcp, mcpAdoptable, ledger });
@@ -76,7 +76,7 @@ function createCopilotAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
     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`;
   }
 
@@ -85,7 +85,7 @@ function createCopilotAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
    * their own shared instruction files, and for the same reason: where DoFlow's content belongs in a
    * file it doesn't fully own is a decision for the file's owner, not a guess for the installer. Add
    * an empty marker pair to opt in. */
-  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);
@@ -97,7 +97,7 @@ function createCopilotAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
 
   /** Strip DoFlow's span, leaving the rest of a shared copilot-instructions.md intact. Returns null
    * when there is nothing to do, so plan() can skip the change entirely. */
-  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);
@@ -110,11 +110,11 @@ function createCopilotAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
   /** Plan the single instructions change (or none). Global scope always yields no change and no
    * conflict — Copilot documents no global instructions file, so there is nothing to skip *to*,
    * mirroring how other adapters skip a capability with no native equivalent for a given scope. */
-  function planInstructionsChange({ assets, found, context, removing, fsImpl }: any) {
+  function planInstructionsChange({ assets, found, context, removing, fsImpl }     ) {
     if (!found.paths.instruction) return { changes: [], conflicts: [] };
     // The marker-managed instruction file is one specific asset: exclude tree-projected rule
     // assets (copilot-rule-instructions), whose `source` is a directory, not a file.
-    const guidance = assets.find((asset: any) => asset.capability === 'instructions' && asset.renderer !== 'copilot-rule-instructions');
+    const guidance = assets.find((asset     ) => asset.capability === 'instructions' && asset.renderer !== 'copilot-rule-instructions');
     if (!guidance) return { changes: [], conflicts: [] };
     const outcome = removing
       ? { ok: true, operation: 'remove', content: strippedInstruction(found.instruction) }
@@ -145,13 +145,13 @@ function createCopilotAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
    * one adapter's asset, not a shape another harness also needs. Format logic, not a path fact —
    * it stays code rather than moving into the registry's path declarations.
    */
-  function agentFileLayout(sourceRel: any) {
+  function agentFileLayout(sourceRel     ) {
     const ext = path.extname(sourceRel);
     const base = sourceRel.slice(0, sourceRel.length - ext.length);
     return `${base}.agent${ext || '.md'}`;
   }
 
-  function planTreeAssets({ assets, renderer, destRoot, scopeRoot, layout, context, ledger, removing, fsImpl = fs }: any) {
+  function planTreeAssets({ assets, renderer, destRoot, scopeRoot, layout, context, ledger, removing, fsImpl = fs }     ) {
     const changes = [];
     const conflicts = [];
     const treeResults = [];
@@ -167,10 +167,10 @@ function createCopilotAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
         // 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(scopeRoot, item.target)}; DoFlow no longer manages it`));
+      notices.push(...result.kept.map((item     ) => `kept hand-edited ${path.relative(scopeRoot, 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,
@@ -186,7 +186,7 @@ function createCopilotAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
     return { changes, conflicts, notices: [...siblingReplacedNotices(treeResults), ...notices] };
   }
 
-  function applyCopyTreeAssets(changes: any, { fsImpl = fs }: any = {}) {
+  function applyCopyTreeAssets(changes     , { fsImpl = fs }      = {}) {
     let applied = 0;
     const grouped = new Map();
     for (const change of changes) {
@@ -201,13 +201,13 @@ function createCopilotAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
     return applied;
   }
 
-  function removeCopyTreeAssets(changes: any, { fsImpl = fs }: any = {}) {
-    const treeChanges = changes.filter((change: any) => change.projection?.renderer === 'copy-tree' && 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     , { fsImpl = fs }      = {}) {
+    const treeChanges = changes.filter((change     ) => change.projection?.renderer === 'copy-tree' && 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, fsImpl }).removed;
   }
 
-  function verifyTreeAssets({ assets, renderer, destRoot, layout, context, fsImpl = fs }: any) {
+  function verifyTreeAssets({ assets, renderer, destRoot, layout, context, fsImpl = fs }     ) {
     const statuses = [];
     const resources = [];
     const conflicts = [];
@@ -215,7 +215,7 @@ function createCopilotAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
       const destDir = copyTreeDestDir(destRoot, asset);
       const sourceDir = sourceDirFor(asset, context, fsImpl, 'Copilot');
       const result = verifyTree({ sourceDir, destDir, fsImpl, layout: 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:${HARNESS}:copy-tree:${asset.id}:${resource.relPath}`,
@@ -233,7 +233,7 @@ function createCopilotAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
 
   /** Copilot's own per-server shape. The file may be shared with another tool (Claude Code reads the
    * same project `.mcp.json`), so DoFlow only ever writes the entries it owns. */
-  function buildServerEntry(server: any) {
+  function buildServerEntry(server     ) {
     return {
       command: server.command,
       ...(server.args?.length ? { args: [...server.args] } : {}),
@@ -241,43 +241,43 @@ function createCopilotAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
     };
   }
 
-  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. */
-  function mcpEntriesInput({ paths, mcp = [], mcpAdoptable = [], ledger, assets = [] }: any) {
-    const rendered = (servers: any) => servers.map((server: any) => ({ id: server.id, entry: buildServerEntry(server) }));
-    const rows = (ledger?.resources || []).filter((row: any) => row.kind === 'mcp-server');
+  function mcpEntriesInput({ paths, mcp = [], mcpAdoptable = [], ledger, assets = [] }     ) {
+    const rendered = (servers     ) => servers.map((server     ) => ({ id: server.id, entry: buildServerEntry(server) }));
+    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: pseudoAssetId(assets), renderer: MCP_RENDERER, label: 'Copilot MCP',
     };
   }
 
   /** The release of the 1.18.0 whole-map row, under the asset id it was recorded with so the ledger
    * drops exactly that row. The file is not touched. */
-  function legacyRegistrationReleases(ledger: any) {
-    return (ledger?.resources || []).filter((row: any) => row.harness === HARNESS && row.ownershipIdentity === LEGACY_MCP_REGISTRATION)
-      .map((row: any) => ({ assetId: row.assetId, target: row.target, operation: 'remove', release: true,
+  function legacyRegistrationReleases(ledger     ) {
+    return (ledger?.resources || []).filter((row     ) => row.harness === HARNESS && row.ownershipIdentity === LEGACY_MCP_REGISTRATION)
+      .map((row     ) => ({ assetId: row.assetId, target: row.target, operation: 'remove', release: true,
         ownershipIdentity: row.ownershipIdentity, harness: HARNESS, projection: { renderer: MCP_RENDERER } }));
   }
 
   /** Copilot's MCP entry changes have no asset of their own in core/registry/assets.json (they are a
    * registration side-effect of the selected MCP servers, not a projected asset), so they piggyback
    * on a real asset id already routed to this harness — the same "pseudo-component" technique
-   * src/adapters/gemini/index.ts#hooksAssetId and src/adapters/kiro/index.ts#pseudoAssetId use. The
+   * src/adapters/gemini/index.js#hooksAssetId and src/adapters/kiro/index.js#pseudoAssetId use. The
    * lifecycle layer validates every change's assetId against the harness's actual asset list, so an
    * invented id like a literal 'copilot.mcp' string is rejected as unknown. */
-  function pseudoAssetId(assets: any) {
-    return assets.find((asset: any) => asset.capability === 'instructions')?.id ?? assets[0]?.id;
+  function pseudoAssetId(assets     ) {
+    return assets.find((asset     ) => asset.capability === 'instructions')?.id ?? assets[0]?.id;
   }
 
   // ---- shared adapter contract ----
 
-  function plan({ scope, scopeRoot, assets = [], mcp = [], mcpAdoptable = [], discovery, context = {}, ledger, fsImpl = fs }: any) {
+  function plan({ scope, scopeRoot, assets = [], mcp = [], mcpAdoptable = [], discovery, context = {}, ledger, fsImpl = fs }     ) {
     const found = discovery || discover({ scope, scopeRoot, mcp, mcpAdoptable, ledger, fsImpl });
     const changes = [];
     const conflicts = [];
@@ -308,12 +308,12 @@ function createCopilotAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
     return { changes, conflicts, notices: [...skills.notices, ...agents.notices, ...rules.notices, ...mcpPlan.notices], paths: found.paths };
   }
 
-  function writeChange(change: any, fsImpl: any) {
+  function writeChange(change     , fsImpl     ) {
     fsImpl.mkdirSync(path.dirname(change.target), { recursive: true });
     fsImpl.writeFileSync(change.target, change.content, 'utf8');
   }
 
-  function apply({ changes = [], fsImpl = fs }: any) {
+  function apply({ changes = [], fsImpl = fs }     ) {
     let applied = 0;
     for (const change of changes) {
       if (change.operation === 'remove') continue;
@@ -329,7 +329,7 @@ function createCopilotAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
     return { applied };
   }
 
-  function remove({ changes = [], fsImpl = fs }: any) {
+  function remove({ changes = [], fsImpl = fs }     ) {
     let removed = 0;
     for (const change of changes) {
       if (change.operation !== 'remove') continue;
@@ -343,7 +343,7 @@ function createCopilotAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
     return { removed };
   }
 
-  function verify({ scope, scopeRoot, assets = [], mcp = [], mcpAdoptable = [], discovery, ledger, operation, context = {}, fsImpl = fs }: any) {
+  function verify({ scope, scopeRoot, assets = [], mcp = [], mcpAdoptable = [], discovery, ledger, operation, context = {}, fsImpl = fs }     ) {
     const found = discover({ scope, scopeRoot, mcp, mcpAdoptable, ledger, fsImpl });
     const statuses = [];
     const resources = [];
@@ -352,7 +352,7 @@ function createCopilotAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
     if (found.paths.instruction) {
       // The marker-managed instruction file is one specific asset: exclude tree-projected rule
       // assets (copilot-rule-instructions), whose `source` is a directory, not a file.
-      const guidance = assets.find((asset: any) => asset.capability === 'instructions' && asset.renderer !== 'copilot-rule-instructions');
+      const guidance = assets.find((asset     ) => asset.capability === 'instructions' && asset.renderer !== 'copilot-rule-instructions');
       const hasSection = typeof found.instruction === 'string' && found.instruction.includes(MARKER_START) && found.instruction.includes(MARKER_END);
       const assetId = guidance?.id ?? 'guidance.codex-pointer';
       statuses.push({ harness: HARNESS, assetId, capability: 'instructions',
@@ -397,8 +397,8 @@ function createCopilotAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
     agentFileLayout };
 }
 
-function treeAssetsFor(assets: any, renderer: any) {
-  return (assets || []).filter((asset: any) => asset?.renderer === renderer);
+function treeAssetsFor(assets     , renderer     ) {
+  return (assets || []).filter((asset     ) => asset?.renderer === renderer);
 }
 
 const singleton = createCopilotAdapter();