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

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

@@ -7,9 +7,9 @@
 // settings/MCP/extensions as first-class native-surface results for the lifecycle UI.
 const fs = require('node:fs');
 const path = require('node:path');
-const { planTree, applyTree, removeTree, verifyTree, copyTreeAssets, copyTreeDestDir, ledgerFileResources, ledgerSiblingFingerprints, siblingReplacedNotices, fingerprint, readJson, sourceDirFor, resolveTransform } = require('../copy-tree.ts');
-const { declaredHarnessPaths, resolveHarnessPaths } = require('../../helper/harness-paths.ts');
-const { planGeminiHooks, deployGeminiHooks, planRemoveGeminiHooks, deployRemoveGeminiHooks } = require('./hooks.ts');
+const { planTree, applyTree, removeTree, verifyTree, copyTreeAssets, copyTreeDestDir, ledgerFileResources, ledgerSiblingFingerprints, siblingReplacedNotices, fingerprint, readJson, sourceDirFor, resolveTransform } = require('../copy-tree.js');
+const { declaredHarnessPaths, resolveHarnessPaths } = require('../../helper/harness-paths.js');
+const { planGeminiHooks, deployGeminiHooks, planRemoveGeminiHooks, deployRemoveGeminiHooks } = require('./hooks.js');
 
 const MARKER_START = '<!-- doflow:start -->';
 const MARKER_END = '<!-- doflow:end -->';
@@ -22,12 +22,12 @@ const MARKER_END = '<!-- doflow:end -->';
 const DEFAULTS_FILE = path.resolve(__dirname, '../../../core/harnesses/gemini/settings/adapter-defaults.json');
 const HARNESS = 'gemini';
 
-function defaults({ fsImpl = fs }: any = {}) { return JSON.parse(fsImpl.readFileSync(DEFAULTS_FILE, 'utf8')); }
+function defaults({ fsImpl = fs }      = {}) { return JSON.parse(fsImpl.readFileSync(DEFAULTS_FILE, 'utf8')); }
 
 /** Pure string helper (no path facts): replace only the span between DoFlow's markers in an
  * existing GEMINI.md body. An existing file with no DoFlow section is refused rather than appended
  * to — GEMINI.md is shared with the user and other tools. */
-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);
@@ -38,7 +38,7 @@ function managedInstruction(existing: any, rendered: any) {
 }
 
 /** Server names in one settings read, or null when the file is absent or unreadable. */
-function settingsServerNames(read: any) {
+function settingsServerNames(read     ) {
   if (!read.exists || read.error || !read.value || typeof read.value !== 'object') return null;
   const servers = read.value.mcpServers;
   return Object.keys(servers && typeof servers === 'object' ? servers : {});
@@ -50,7 +50,7 @@ function settingsServerNames(read: any) {
  * neither can be read. Gemini also merges system settings and extension servers, which DoFlow does
  * not read, so the view is never complete (`mcpComplete: false`) and absence is never proof.
  */
-function configuredGeminiMcp({ scope, settings, homeDir, fsImpl }: any) {
+function configuredGeminiMcp({ scope, settings, homeDir, fsImpl }     ) {
   const own = settingsServerNames(settings);
   const user = scope === 'project' && homeDir ? settingsServerNames(readJson(path.join(homeDir, '.gemini', 'settings.json'), { fsImpl })) : null;
   const mcpConfigured = own || user ? [...new Set([...(own || []), ...(user || [])])].sort() : null;
@@ -66,13 +66,13 @@ function configuredGeminiMcp({ scope, settings, homeDir, fsImpl }: any) {
  * historical shape.
  */
 function createGeminiAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] } = {}) {
-  function nativePaths({ scope, scopeRoot, homeDir, fsImpl = fs }: any) {
+  function nativePaths({ scope, scopeRoot, homeDir, fsImpl = fs }     ) {
     const resolved = resolveHarnessPaths(declaredPaths, { scope, scopeRoot, homeDir });
     // Non-path native fact carried alongside the resolved surfaces (see DEFAULTS_FILE residue note).
     return { ...resolved, extensionMode: defaults({ fsImpl }).extensionInstall };
   }
 
-  function discover({ scope, scopeRoot, context = {}, fsImpl = fs }: any) {
+  function discover({ scope, scopeRoot, context = {}, fsImpl = fs }     ) {
     const paths = nativePaths({ scope, scopeRoot, homeDir: context.homeDir, fsImpl });
     const instruction = fsImpl.existsSync(paths.instruction) ? fsImpl.readFileSync(paths.instruction, 'utf8') : null;
     // Gemini takes no servers from DoFlow's MCP catalog.
@@ -81,7 +81,7 @@ function createGeminiAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] }
     return { paths, instruction, settings, mcpOwned: [], mcpConfigured, mcpComplete };
   }
 
-  function render({ content = '' }: any = {}) {
+  function render({ content = '' }      = {}) {
     const body = String(content).trimEnd();
     return `${MARKER_START}\n${body}\n${MARKER_END}\n`;
   }
@@ -99,7 +99,7 @@ function createGeminiAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] }
    * (instruction vs. the guidance tree), not on any single declared path — expressible only by
    * joining and diffing, which is computation, not declaration.
    */
-  function geminiDestDir(paths: any, asset: any) {
+  function geminiDestDir(paths     , asset     ) {
     if (asset.nativeDir && asset.nativeDir.startsWith('../')) {
       const dest = path.join(paths.root, asset.nativeDir.slice(3));
       const rel = path.relative(paths.root, dest);
@@ -111,8 +111,8 @@ function createGeminiAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] }
     return copyTreeDestDir(paths.configDir, asset);
   }
 
-  function rewriteGuidanceImport(content: any, assets: any, paths: any) {
-    const guidance = assets.find((item: any) => item.id === 'guidance.context-layer');
+  function rewriteGuidanceImport(content     , assets     , paths     ) {
+    const guidance = assets.find((item     ) => item.id === 'guidance.context-layer');
     if (!guidance?.nativeDir || !paths?.instruction || !paths?.configDir) return content;
     const guidanceDir = geminiDestDir(paths, guidance);
     const rel = path.relative(path.dirname(paths.instruction), guidanceDir).split(path.sep).join('/');
@@ -123,22 +123,22 @@ function createGeminiAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] }
     return content.replace(/@\S*?(DOFLOW_CORE\.md)/g, `@${prefix}/$1`);
   }
 
-  function instructionContent({ assets, context, paths, fsImpl = fs }: any) {
+  function instructionContent({ assets, context, paths, fsImpl = fs }     ) {
     if (context.instructionContent !== undefined) return String(context.instructionContent);
-    const asset = assets.find((item: any) => item.id === 'guidance.core');
+    const asset = assets.find((item     ) => item.id === 'guidance.core');
     if (!asset || !context.repoRoot) return null;
     const source = path.resolve(context.repoRoot, asset.source);
     if (!fsImpl.existsSync(source)) return null;
     return rewriteGuidanceImport(fsImpl.readFileSync(source, 'utf8'), assets, paths);
   }
 
-  function policyStatuses(policies: any[] = []) {
-    return policies.map((policy: any) => ({ id: policy.id, status: 'unavailable', fallback: 'guidance', reason: 'Gemini policy automation is not rendered by this adapter' }));
+  function policyStatuses(policies        = []) {
+    return policies.map((policy     ) => ({ id: policy.id, status: 'unavailable', fallback: 'guidance', reason: 'Gemini policy automation is not rendered by this adapter' }));
   }
 
   // ---- copy-tree assets (rules, skills, agents, modes, references) ----
 
-  function planCopyTreeAssets({ assets, scope, scopeRoot, context, ledger, removing, fsImpl = fs }: any) {
+  function planCopyTreeAssets({ assets, scope, scopeRoot, context, ledger, removing, fsImpl = fs }     ) {
     const paths = nativePaths({ scope, scopeRoot, homeDir: context.homeDir, fsImpl });
     const changes = [];
     const conflicts = [];
@@ -156,10 +156,10 @@ function createGeminiAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] }
         // Found by the guard written for the six adapters that forwarded nothing.
         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 (the agents folder layout) 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,
@@ -175,7 +175,7 @@ function createGeminiAdapter({ 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) {
@@ -190,13 +190,13 @@ function createGeminiAdapter({ 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 verifyCopyTreeAssets({ assets, scope, scopeRoot, context, fsImpl = fs }: any) {
+  function verifyCopyTreeAssets({ assets, scope, scopeRoot, context, fsImpl = fs }     ) {
     const paths = nativePaths({ scope, scopeRoot, homeDir: context.homeDir, fsImpl });
     const statuses = [];
     const resources = [];
@@ -205,7 +205,7 @@ function createGeminiAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] }
       const destDir = geminiDestDir(paths, asset);
       const sourceDir = sourceDirFor(asset, context, fsImpl, 'Gemini');
       const result = verifyTree({ sourceDir, destDir, fsImpl, 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:gemini:copy-tree:${asset.id}:${resource.relPath}`,
@@ -225,15 +225,15 @@ function createGeminiAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] }
   // integration) — the lifecycle layer's normalizeChange() requires every change's assetId to
   // match a real registered asset, so this piggybacks on guidance.core's id the same way Codex's
   // assetIdFor(options, 'hooks') does, rather than inventing an unregistered 'hooks' id.
-  function hooksAssetId(assets: any) {
-    return assets.find((asset: any) => asset.id === 'guidance.core')?.id ?? assets[0]?.id;
+  function hooksAssetId(assets     ) {
+    return assets.find((asset     ) => asset.id === 'guidance.core')?.id ?? assets[0]?.id;
   }
 
   /** Plan the hooks pseudo-component's single change (or none), mirroring the {changes, conflicts}
    * shape planCopyTreeAssets already returns so plan() can fold it in the same way. The hook
    * scripts directory beside settings.json is declared (paths.hooksDirectory); the merge/remove
    * planning itself lives in ./hooks.ts. */
-  function planHooksChange({ removing, found, context, assets, fsImpl }: any) {
+  function planHooksChange({ removing, found, context, assets, fsImpl }     ) {
     if (found.settings.error) return { changes: [], conflicts: [] };
     const hooksPlan = removing
       ? planRemoveGeminiHooks({ settingsFile: found.paths.settings, fsImpl })
@@ -248,7 +248,7 @@ function createGeminiAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] }
       companionTargets: removing ? [] : (hooksPlan.companionTargets ?? []) }], conflicts: [] };
   }
 
-  function plan({ scope, scopeRoot, assets = [], mcp = [], discovery, context = {}, ledger, fsImpl = fs }: any) {
+  function plan({ scope, scopeRoot, assets = [], mcp = [], discovery, context = {}, ledger, fsImpl = fs }     ) {
     const found = discovery || discover({ scope, scopeRoot, context, fsImpl });
     const changes = []; const conflicts = [];
     const removing = context.operation === 'remove';
@@ -256,7 +256,7 @@ function createGeminiAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] }
       // Removal only ever targets a section this adapter itself owns — a foreign or absent
       // GEMINI.md yields no change, never a forced deletion of user content.
       const owns = found.instruction !== null && found.instruction.includes(MARKER_START) && found.instruction.includes(MARKER_END);
-      if (assets.some((asset: any) => asset.id === 'guidance.core') && owns) {
+      if (assets.some((asset     ) => asset.id === 'guidance.core') && owns) {
         changes.push({ assetId: 'guidance.core', target: found.paths.instruction, operation: 'remove', ownershipIdentity: 'gemini:instructions', projection: { renderer: 'gemini-instructions' } });
       }
     } else {
@@ -277,14 +277,14 @@ function createGeminiAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] }
       surfaces: {
         instructions: { status: 'supported', target: found.paths.instruction },
         settings: { status: found.settings.error ? 'invalid' : 'supported', target: found.paths.settings },
-        mcp: { status: found.settings.error ? 'blocked' : 'supported', target: found.paths.settings, selected: mcp.map((item: any) => item.id) },
+        mcp: { status: found.settings.error ? 'blocked' : 'supported', target: found.paths.settings, selected: mcp.map((item     ) => item.id) },
         extensions: { status: 'different', mode: found.paths.extensionMode, action: 'use Gemini CLI extension management' },
         policies: policyStatuses(context.policies),
       },
     };
   }
 
-  function atomicWrite(file: any, content: any, { fsImpl = fs }: any = {}) {
+  function atomicWrite(file     , content     , { fsImpl = fs }      = {}) {
     fsImpl.mkdirSync(path.dirname(file), { recursive: true });
     const temp = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${Date.now()}.tmp`);
     try {
@@ -294,9 +294,9 @@ function createGeminiAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] }
       if (fsImpl.existsSync(temp)) fsImpl.rmSync(temp, { force: true });
     }
   }
-  function apply({ changes = [], fsImpl = fs }: any) {
+  function apply({ changes = [], fsImpl = fs }     ) {
     for (const change of changes) if (change.content !== undefined) atomicWrite(change.target, change.content, { fsImpl });
-    const hooksChange = changes.find((change: any) => change.nativeComponent === 'hooks');
+    const hooksChange = changes.find((change     ) => change.nativeComponent === 'hooks');
     if (hooksChange?.nativePlan) deployGeminiHooks(hooksChange.nativePlan, { fsImpl });
     applyCopyTreeAssets(changes, { fsImpl });
     // An update that relocates an asset (the agents folder layout -> flat files) carries the old
@@ -307,7 +307,7 @@ function createGeminiAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] }
   /** Strip only the DoFlow-managed span, exactly like the Claude adapter's removeManagedSection —
    * a file with user content before/after the managed section must keep that content. Only delete
    * the file outright once nothing but the managed section (and its separator) remains. */
-  function removeManagedSection(file: any, { fsImpl = fs }: any = {}) {
+  function removeManagedSection(file     , { fsImpl = fs }      = {}) {
     if (!fsImpl.existsSync(file)) return false;
     const existing = fsImpl.readFileSync(file, 'utf8');
     const start = existing.indexOf(MARKER_START);
@@ -324,17 +324,17 @@ function createGeminiAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] }
     else fsImpl.writeFileSync(file, next);
     return true;
   }
-  function remove({ changes = [], fsImpl = fs }: any) {
+  function remove({ changes = [], fsImpl = fs }     ) {
     for (const change of changes) if (change.target && change.projection?.renderer === 'gemini-instructions') removeManagedSection(change.target, { fsImpl });
-    const hooksChange = changes.find((change: any) => change.nativeComponent === 'hooks');
+    const hooksChange = changes.find((change     ) => change.nativeComponent === 'hooks');
     if (hooksChange?.nativePlan) deployRemoveGeminiHooks(hooksChange.nativePlan, { fsImpl });
     removeCopyTreeAssets(changes, { fsImpl });
   }
 
-  function verify({ scope, scopeRoot, assets = [], context = {}, fsImpl = fs }: any) {
+  function verify({ scope, scopeRoot, assets = [], context = {}, fsImpl = fs }     ) {
     const found = discover({ scope, scopeRoot, context, fsImpl });
     const resources = [];
-    if (assets.some((asset: any) => asset.id === 'guidance.core') && found.instruction?.includes(MARKER_START) && found.instruction.includes(MARKER_END)) {
+    if (assets.some((asset     ) => asset.id === 'guidance.core') && found.instruction?.includes(MARKER_START) && found.instruction.includes(MARKER_END)) {
       resources.push({ assetId: 'guidance.core', target: found.paths.instruction, ownershipIdentity: 'gemini:instructions', fingerprint: fingerprint(found.instruction), sourceVersion: context.sourceVersion ?? 'unknown', projection: { renderer: 'gemini-instructions' } });
     }
     const copyTree = verifyCopyTreeAssets({ assets, scope, scopeRoot, context, fsImpl });
@@ -370,7 +370,7 @@ const singleton = createGeminiAdapter();
  * @param {Object} target a lifecycle status target ({adapterInput, discovery})
  * @returns {*} the plan's trust, or null
  */
-function hookTrustFor(target: any) {
+function hookTrustFor(target     ) {
   const context = target.adapterInput?.context || {};
   const settingsFile = target.discovery?.paths?.settings;
   if (!context.geminiHooksSourceFile || !settingsFile || target.discovery?.settings?.error) return null;

package/src/adapters/{hook-commands.ts → hook-commands.js}

@@ -11,16 +11,16 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-function commandScriptNames(command: string): string[] {
+function commandScriptNames(command        )           {
   // DoFlow's wrappers are shell scripts selected from a project or CODEX_HOME hooks directory.
   // Extracting the basename works for both literal and command-substitution based paths.
   return [...new Set((command.match(/[A-Za-z0-9][A-Za-z0-9_-]*\.sh\b/g) || []))];
 }
 
-function hookHandlers(config: any): { event: string, handler: any }[] {
-  return Object.entries(config.hooks || {}).flatMap(([event, groups]: [string, any]) =>
-    (Array.isArray(groups) ? groups : []).flatMap((group: any) =>
-      (Array.isArray(group?.hooks) ? group.hooks : []).map((handler: any) => ({ event, handler }))));
+function hookHandlers(config     )                                    {
+  return Object.entries(config.hooks || {}).flatMap(([event, groups]               ) =>
+    (Array.isArray(groups) ? groups : []).flatMap((group     ) =>
+      (Array.isArray(group?.hooks) ? group.hooks : []).map((handler     ) => ({ event, handler }))));
 }
 
 // On `trusted`: both harnesses gate hook execution behind their own trust prompt — Codex through
@@ -36,8 +36,8 @@ function hookHandlers(config: any): { event: string, handler: any }[] {
 // exec-bit half of the check is POSIX-only; existence is checked everywhere.
 const EXEC_BITS_EXIST = process.platform !== 'win32';
 
-function verifyHookCommands(config: any, { scriptsDir, trusted = false, fsImpl = fs }: { scriptsDir?: string, trusted?: boolean, fsImpl?: any } = {}): any {
-  const checks: any[] = [];
+function verifyHookCommands(config     , { scriptsDir, trusted = false, fsImpl = fs }                                                           = {})      {
+  const checks        = [];
   for (const { event, handler } of hookHandlers(config)) {
     if (!handler || handler.type !== 'command' || typeof handler.command !== 'string' || !handler.command.trim()) continue;
     const names = commandScriptNames(handler.command);
@@ -54,7 +54,7 @@ function verifyHookCommands(config: any, { scriptsDir, trusted = false, fsImpl =
         requiresTrust: true, trusted });
     }
   }
-  return { ok: checks.every((check: any) => check.ok), checks, trust: { required: checks.length > 0, trusted: Boolean(trusted), status: trusted ? 'trusted' : 'review-required' } };
+  return { ok: checks.every((check     ) => check.ok), checks, trust: { required: checks.length > 0, trusted: Boolean(trusted), status: trusted ? 'trusted' : 'review-required' } };
 }
 
 module.exports = { commandScriptNames, hookHandlers, verifyHookCommands };

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

@@ -4,7 +4,7 @@
 
 // Harness adapters own native formats and paths. This module intentionally only
 // validates and resolves that boundary; it never reads or writes harness files.
-const { resolveRegistrySource } = require('./resolve-source.ts');
+const { resolveRegistrySource } = require('./resolve-source.js');
 
 const ADAPTER_METHODS = Object.freeze(['discover', 'render', 'plan', 'apply', 'remove', 'verify']);
 
@@ -12,12 +12,12 @@ const ADAPTER_METHODS = Object.freeze(['discover', 'render', 'plan', 'apply', 'r
  * A3: the Codex shape used to be inlined here, putting per-harness knowledge on the shared side of
  * the boundary); this module only dispatches by adapter name. An adapter gaining a
  * nativeProjection declaration registers its normalizer here. */
-const NATIVE_PROJECTION_NORMALIZERS: Record<string, () => any> = Object.freeze({
-  codex: () => require('./codex/native-projection.ts').normalizeNativeProjection,
+const NATIVE_PROJECTION_NORMALIZERS                            = Object.freeze({
+  codex: () => require('./codex/native-projection.js').normalizeNativeProjection,
 });
 
 /** Dispatch a harness's nativeProjection declaration to its adapter's own normalizer. */
-function nativeProjectionFor(registry: any, harness: any, mcp: any, context: any) {
+function nativeProjectionFor(registry     , harness     , mcp     , context     ) {
   if (!harness.nativeProjection) return {};
   const load = NATIVE_PROJECTION_NORMALIZERS[harness.adapter];
   if (!load) {
@@ -32,9 +32,9 @@ function nativeProjectionFor(registry: any, harness: any, mcp: any, context: any
  * adapter receives. Native serializers may add adapter-specific fields, but
  * cannot infer applicability from a missing projection.
  */
-function projectAdapterInput({ registry, harness, scope, scopeRoot, assets = [], mcp = [], mcpAdoptable = [], policies = [], context = {} }: any) {
+function projectAdapterInput({ registry, harness, scope, scopeRoot, assets = [], mcp = [], mcpAdoptable = [], policies = [], context = {} }     ) {
   if (!registry || !harness) throw new Error('registry and harness are required for adapter projection');
-  const projectAsset = (asset: any) => {
+  const projectAsset = (asset     ) => {
     const projection = asset?.projection?.[harness.id];
     if (!projection || typeof projection.renderer !== 'string' || typeof projection.capability !== 'string') {
       throw new Error(`Asset '${asset?.id ?? '?'}' lacks a projection for '${harness.id}'`);
@@ -62,16 +62,16 @@ function projectAdapterInput({ registry, harness, scope, scopeRoot, assets = [],
   return Object.freeze({
     harness, scope, scopeRoot, context,
     assets: Object.freeze(assets.map(projectAsset)),
-    mcp: Object.freeze(mcp.map((server: any) => Object.freeze({ ...server }))),
+    mcp: Object.freeze(mcp.map((server     ) => Object.freeze({ ...server }))),
     // Servers whose existing entries the adapter may take as its own while it holds no MCP row.
-    mcpAdoptable: Object.freeze(mcpAdoptable.map((server: any) => Object.freeze({ ...server }))),
-    policies: Object.freeze(policies.map((policy: any) => Object.freeze({ ...policy }))),
+    mcpAdoptable: Object.freeze(mcpAdoptable.map((server     ) => Object.freeze({ ...server }))),
+    policies: Object.freeze(policies.map((policy     ) => Object.freeze({ ...policy }))),
     nativeTargets: Object.freeze({ ...harness.nativeTargets }),
     projection: Object.freeze({ ...projection }),
   });
 }
 
-function assertAdapter(adapter: any, name = 'adapter') {
+function assertAdapter(adapter     , name = 'adapter') {
   if (!adapter || typeof adapter !== 'object') throw new Error(`${name} must be an object`);
   for (const method of ADAPTER_METHODS) {
     if (typeof adapter[method] !== 'function') throw new Error(`${name} must implement ${method}()`);
@@ -88,8 +88,8 @@ function createAdapterRegistry(adapters = {}) {
   }
   return Object.freeze({
     names: () => [...resolved.keys()],
-    has: (name: any) => resolved.has(name),
-    get(name: any) {
+    has: (name     ) => resolved.has(name),
+    get(name     ) {
       const adapter = resolved.get(name);
       if (!adapter) throw new Error(`No registered adapter '${name}'`);
       return adapter;
@@ -97,7 +97,7 @@ function createAdapterRegistry(adapters = {}) {
   });
 }
 
-function resolveAdapter(adapterRegistry: any, harness: any) {
+function resolveAdapter(adapterRegistry     , harness     ) {
   if (!adapterRegistry || typeof adapterRegistry.get !== 'function') throw new Error('adapterRegistry must expose get(name)');
   if (!harness || typeof harness.adapter !== 'string') throw new Error('Harness must declare an adapter');
   return adapterRegistry.get(harness.adapter);

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

@@ -17,9 +17,9 @@
 // https://kiro.dev/docs/hooks/
 const fs = require('node:fs');
 const path = require('node:path');
-const { planTree, applyTree, removeTree, verifyTree, resolveTransform, copyTreeAssets, copyTreeDestDir, ledgerFileResources, ledgerSiblingFingerprints, siblingReplacedNotices, sourceDirFor } = require('../copy-tree.ts');
-const { readMcpFiles, planMcpEntries, verifyMcpEntries, ownedMcpIds, writeMcpEntries } = require('../mcp-entries.ts');
-const { declaredHarnessPaths, resolveHarnessPaths } = require('../../helper/harness-paths.ts');
+const { planTree, applyTree, removeTree, verifyTree, resolveTransform, copyTreeAssets, copyTreeDestDir, ledgerFileResources, ledgerSiblingFingerprints, siblingReplacedNotices, sourceDirFor } = require('../copy-tree.js');
+const { readMcpFiles, planMcpEntries, verifyMcpEntries, ownedMcpIds, writeMcpEntries } = require('../mcp-entries.js');
+const { declaredHarnessPaths, resolveHarnessPaths } = require('../../helper/harness-paths.js');
 
 const HARNESS = 'kiro';
 const MCP_CONTAINER = 'mcpServers';
@@ -41,13 +41,13 @@ function createKiroAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] } =
   // Parity note: Kiro'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 Kiro's mcp.json 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 entries = mcpEntriesInput({ paths, mcp, mcpAdoptable, ledger });
     const mcpSnapshot = readMcpFiles({ file: entries.file, ownRows: entries.ownRows, container: MCP_CONTAINER, fsImpl });
@@ -65,7 +65,7 @@ function createKiroAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] } =
    * `kiro-agents`, so nothing reaches this function. It is kept as a pure passthrough only to
    * satisfy the six-function adapter contract every harness must implement identically.
    */
-  function render({ content = '' }: any = {}) {
+  function render({ content = '' }      = {}) {
     return String(content);
   }
 
@@ -84,11 +84,11 @@ function createKiroAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] } =
    * `kiro-agent-json` layout and `kiro-agents` transform: kiro-cli discovers agents as
    * `.kiro/agents/<name>.json`, so each shared `<name>.md` spec is rendered, not mirrored.
    */
-  function kiroTreeAssets(assets: any) {
-    return [...copyTreeAssets(assets), ...(assets || []).filter((asset: any) => asset.renderer === 'kiro-agents')];
+  function kiroTreeAssets(assets     ) {
+    return [...copyTreeAssets(assets), ...(assets || []).filter((asset     ) => asset.renderer === 'kiro-agents')];
   }
 
-  function planCopyTreeAssets({ assets, scope, scopeRoot, context, ledger, removing, fsImpl = fs }: any) {
+  function planCopyTreeAssets({ assets, scope, scopeRoot, context, ledger, removing, fsImpl = fs }     ) {
     const paths = nativePaths({ scope, scopeRoot });
     const changes = [];
     const conflicts = [];
@@ -105,10 +105,10 @@ function createKiroAdapter({ 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(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,
@@ -124,7 +124,7 @@ function createKiroAdapter({ 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) {
@@ -139,13 +139,13 @@ function createKiroAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] } =
     return applied;
   }
 
-  function removeCopyTreeAssets(changes: any, { fsImpl = fs }: 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     , { fsImpl = fs }      = {}) {
+    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, fsImpl }).removed;
   }
 
-  function verifyCopyTreeAssets({ assets, scope, scopeRoot, context, fsImpl = fs }: any) {
+  function verifyCopyTreeAssets({ assets, scope, scopeRoot, context, fsImpl = fs }     ) {
     const paths = nativePaths({ scope, scopeRoot });
     const statuses = [];
     const resources = [];
@@ -154,7 +154,7 @@ function createKiroAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] } =
       const destDir = copyTreeDestDir(paths.configDir, asset);
       const sourceDir = sourceDirFor(asset, context, fsImpl, 'Kiro');
       const result = verifyTree({ sourceDir, destDir, fsImpl, 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}`,
@@ -177,15 +177,15 @@ function createKiroAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] } =
    * registry (core/registry/mcp.json) only ever declares stdio servers today, so only the fields it
    * actually carries are emitted — this never invents a field the registry doesn't supply.
    */
-  function buildServerEntry(server: any) {
+  function buildServerEntry(server     ) {
     if (server.url) return { url: server.url, ...(server.headers ? { headers: server.headers } : {}) };
     return { command: server.command, ...(server.args?.length ? { args: server.args } : {}) };
   }
 
-  function ownershipIdentity(id: any) { return `doflow:${HARNESS}:mcp-server:${id}`; }
+  function ownershipIdentity(id     ) { return `doflow:${HARNESS}:mcp-server:${id}`; }
 
-  function mcpOwnRows(ledger: any) {
-    return (ledger?.resources || []).filter((row: any) => row.harness === HARNESS).flatMap((row: any) => {
+  function mcpOwnRows(ledger     ) {
+    return (ledger?.resources || []).filter((row     ) => row.harness === HARNESS).flatMap((row     ) => {
       if (row.kind === 'mcp-server') {
         return [{ identity: row.identity, target: row.target, fingerprint: row.fingerprint ?? null, ownershipIdentity: row.ownershipIdentity, legacy: false }];
       }
@@ -196,13 +196,13 @@ function createKiroAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] } =
   }
 
   /** 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) }));
+  function mcpEntriesInput({ paths, mcp = [], mcpAdoptable = [], ledger, assets = [] }     ) {
+    const rendered = (servers     ) => servers.map((server     ) => ({ id: server.id, entry: buildServerEntry(server) }));
     return {
       file: paths.mcp, selected: rendered(mcp), adoptable: rendered(mcpAdoptable),
       ownRows: mcpOwnRows(ledger),
-      foreignRows: (ledger?.resources || []).filter((row: any) => row.kind === 'mcp-server' && row.harness !== HARNESS)
-        .map((row: any) => ({ harness: row.harness, identity: row.identity, target: row.target })),
+      foreignRows: (ledger?.resources || []).filter((row     ) => row.kind === 'mcp-server' && row.harness !== HARNESS)
+        .map((row     ) => ({ harness: row.harness, identity: row.identity, target: row.target })),
       identityFor: ownershipIdentity, assetId: pseudoAssetId(assets), renderer: MCP_RENDERER, label: 'Kiro MCP',
     };
   }
@@ -210,9 +210,9 @@ function createKiroAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] } =
   /** Kiro has no hooks or mcp asset of its own in core/registry/assets.json (mcp servers come from
    * core/registry/mcp.json, not an asset), so an MCP entry change piggybacks on an asset id
    * this harness actually receives — the same "pseudo-component" technique
-   * src/adapters/gemini/index.ts#hooksAssetId already uses for its own settings-only component. */
-  function pseudoAssetId(assets: any) {
-    return assets.find((asset: any) => asset.id === 'guidance.context-layer')?.id ?? assets[0]?.id;
+   * src/adapters/gemini/index.js#hooksAssetId already uses for its own settings-only component. */
+  function pseudoAssetId(assets     ) {
+    return assets.find((asset     ) => asset.id === 'guidance.context-layer')?.id ?? assets[0]?.id;
   }
 
   // ---- shared adapter contract ----
@@ -226,11 +226,11 @@ function createKiroAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] } =
    * `assets` array; per-file installed status for the hooks tree itself is reported through
    * `copyTree.statuses`/`copyTree.resources`, exactly like it is for skills and agents.
    */
-  function hooksSurface(paths: any) {
+  function hooksSurface(paths     ) {
     return { status: 'supported', target: paths.hooks };
   }
 
-  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 = [];
@@ -253,12 +253,12 @@ function createKiroAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] } =
         skills: { status: 'supported', target: found.paths.skills },
         agents: { status: 'supported', target: found.paths.agents },
         hooks: hooksSurface(found.paths),
-        mcp: { status: found.mcpSnapshot[found.paths.mcp].ok ? 'supported' : 'blocked', target: found.paths.mcp, selected: mcp.map((item: any) => item.id) },
+        mcp: { status: found.mcpSnapshot[found.paths.mcp].ok ? 'supported' : 'blocked', target: found.paths.mcp, selected: mcp.map((item     ) => item.id) },
       },
     };
   }
 
-  function apply({ changes = [], fsImpl = fs }: any) {
+  function apply({ changes = [], fsImpl = fs }     ) {
     writeMcpEntries(changes, { container: MCP_CONTAINER, fsImpl });
     applyCopyTreeAssets(changes, { fsImpl });
     // An update that no longer ships a copy-tree file carries its rows as removals inside the
@@ -266,12 +266,12 @@ function createKiroAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] } =
     removeCopyTreeAssets(changes, { fsImpl });
   }
 
-  function remove({ changes = [], fsImpl = fs }: any) {
+  function remove({ changes = [], fsImpl = fs }     ) {
     writeMcpEntries(changes, { container: MCP_CONTAINER, fsImpl });
     removeCopyTreeAssets(changes, { fsImpl });
   }
 
-  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 paths = nativePaths({ scope, scopeRoot });
     const resources = [];
     const conflicts = [];