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

package/src/adapters/{copy-tree.ts → copy-tree.js}

@@ -12,12 +12,12 @@ const fs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
 
-function sha256(buf: any): string {
+function sha256(buf     )         {
   return crypto.createHash('sha256').update(buf).digest('hex');
 }
 
-function walkRelFiles(dir: string, fsImpl: any): string[] {
-  const out: string[] = [];
+function walkRelFiles(dir        , fsImpl     )           {
+  const out           = [];
   for (const entry of fsImpl.readdirSync(dir, { withFileTypes: true })) {
     const abs = path.join(dir, entry.name);
     if (entry.isDirectory()) out.push(...walkRelFiles(abs, fsImpl).map((rel) => path.join(entry.name, rel)));
@@ -33,29 +33,29 @@ function walkRelFiles(dir: string, fsImpl: any): string[] {
  * branched on inside an adapter, so the shape stays visible next to the asset it applies to.
  * @type {Record<string, (sourceRel: string) => string>}
  */
-const LAYOUTS: Record<string, (sourceRel: string) => string> = {
+const LAYOUTS                                                = {
   /** `spec-analyst.md` -> `spec-analyst/agent.md` */
-  'dir-per-file:agent.md': (sourceRel: string) => {
+  'dir-per-file:agent.md': (sourceRel        ) => {
     const ext = path.extname(sourceRel);
     return path.join(sourceRel.slice(0, sourceRel.length - ext.length), `agent${ext || '.md'}`);
   },
   /** `RULE_01_SAFETY.md` -> `RULE_01_SAFETY.instructions.md` — GitHub's path-specific
    * instructions are discovered by their `.instructions.md` suffix. */
-  'instructions-md': (sourceRel: string) => {
+  'instructions-md': (sourceRel        ) => {
     const ext = path.extname(sourceRel);
     return `${sourceRel.slice(0, sourceRel.length - ext.length)}.instructions.md`;
   },
   /** `MODE_Orchestration.md` -> `doflow-orchestration.md` — Claude's /config picker lists
    * output styles by file name; the doflow- prefix keeps DoFlow's styles grouped and
    * non-colliding with anything a user authors by hand. */
-  'doflow-output-style': (sourceRel: string) => {
+  'doflow-output-style': (sourceRel        ) => {
     const ext = path.extname(sourceRel);
     const base = path.basename(sourceRel, ext).replace(/^MODE_/i, '').replace(/_/g, '-').toLowerCase();
     return `doflow-${base}${ext || '.md'}`;
   },
   /** `core-implementer.md` -> `core-implementer.json` — kiro-cli discovers custom agents as
    * `.kiro/agents/<name>.json` (2.27.1 `kiro-cli agent list` did not list `.md` agents). */
-  'kiro-agent-json': (sourceRel: string) => {
+  'kiro-agent-json': (sourceRel        ) => {
     const ext = path.extname(sourceRel);
     return `${sourceRel.slice(0, sourceRel.length - ext.length)}.json`;
   },
@@ -63,8 +63,8 @@ const LAYOUTS: Record<string, (sourceRel: string) => string> = {
 
 /** Resolve a declared layout name to its mapper. Unknown names fail loudly rather than silently
  * mirroring, because a typo would otherwise install to the wrong shape and look like it worked. */
-function resolveLayout(name: any): (sourceRel: string) => string {
-  if (!name) return (rel: string) => rel;
+function resolveLayout(name     )                                {
+  if (!name) return (rel        ) => rel;
   const layout = LAYOUTS[name];
   if (!layout) throw new Error(`Unknown copy-tree layout '${name}' (known: ${Object.keys(LAYOUTS).join(', ')})`);
   return layout;
@@ -79,39 +79,39 @@ function resolveLayout(name: any): (sourceRel: string) => string {
  * applyTree can re-derive the written bytes from the untouched source at any later retry.
  * @type {Record<string, (sourceRel: string, content: Buffer) => Buffer>}
  */
-const TRANSFORMS: Record<string, (sourceRel: string, content: any) => any> = {
+const TRANSFORMS                                                           = {
   /** Shared mode doc -> Claude output style with name/description/keep-coding-instructions */
   'claude-output-styles': renderClaudeOutputStyle,
   /** `<rule>.md` -> `<rule>.instructions.md` body under a Copilot applyTo header */
-  'copilot-rule-instructions': (sourceRel: string, content: any) => {
+  'copilot-rule-instructions': (sourceRel        , content     ) => {
     void sourceRel;
     return Buffer.from(`---\napplyTo: '**'\n---\n\n${stripFrontmatter(content.toString('utf8'))}`);
   },
   /** Shared agent spec frontmatter -> only the keys Gemini CLI's subagent schema accepts */
-  'gemini-agents': (sourceRel: string, content: any) => {
+  'gemini-agents': (sourceRel        , content     ) => {
     void sourceRel;
     return Buffer.from(filterGeminiAgentFrontmatter(content.toString('utf8')));
   },
   /** Shared agent spec frontmatter -> OpenCode's markdown-agent vocabulary */
-  'opencode-agents': (sourceRel: string, content: any) => {
+  'opencode-agents': (sourceRel        , content     ) => {
     void sourceRel;
     return Buffer.from(renderOpencodeAgent(content.toString('utf8')));
   },
   /** Shared agent spec -> kiro-cli custom agent JSON (name, description, prompt, tools, hooks) */
-  'kiro-agents': (sourceRel: string, content: any) => {
+  'kiro-agents': (sourceRel        , content     ) => {
     void sourceRel;
     return Buffer.from(renderKiroAgent(content.toString('utf8')));
   },
 };
 
-function resolveTransform(name: any): ((sourceRel: string, content: any) => any) | null {
+function resolveTransform(name     )                                                    {
   if (!name) return null;
   const transform = TRANSFORMS[name];
   if (!transform) throw new Error(`Unknown copy-tree transform '${name}' (known: ${Object.keys(TRANSFORMS).join(', ')})`);
   return transform;
 }
 
-function stripFrontmatter(text: string): string {
+function stripFrontmatter(text        )         {
   if (!text.startsWith('---')) return text;
   const end = text.indexOf('\n---', 3);
   if (end === -1) return text;
@@ -122,7 +122,7 @@ function stripFrontmatter(text: string): string {
  * built-in engineering instructions (these styles shape HOW DoFlow works, not WHETHER Claude
  * codes). The description is lifted from the document's first `**Purpose**` line so the /config
  * picker explains each style without opening it. */
-function renderClaudeOutputStyle(sourceRel: string, content: any): string {
+function renderClaudeOutputStyle(sourceRel        , content     )         {
   const text = Buffer.isBuffer(content) ? content.toString('utf8') : String(content);
   const base = path.basename(sourceRel).replace(/\.[^.]+$/, '').replace(/^MODE_/i, '').replace(/_/g, ' ');
   const purpose = text.match(/\*\*Purpose\*\*[:*]*\s*(.+)?/);
@@ -137,11 +137,11 @@ const GEMINI_AGENT_KEYS = new Set(['name', 'description', 'kind', 'tools', 'mcpS
 /** Keep only Gemini's documented top-level frontmatter keys, with their indented continuation
  * lines, in source order. The body after the closing `---` passes through byte for byte, and a
  * file without frontmatter is returned unchanged. */
-function filterGeminiAgentFrontmatter(text: string): string {
+function filterGeminiAgentFrontmatter(text        )         {
   const match = text.match(/^---\r?\n([\s\S]*?\r?\n)---(?=\r?\n|$)/);
   if (!match) return text;
   let keep = false;
-  const kept = match[1].split(/(?<=\n)/).filter((line: string) => {
+  const kept = match[1].split(/(?<=\n)/).filter((line        ) => {
     const key = line.match(/^([A-Za-z][A-Za-z0-9_-]*):/);
     if (key) keep = GEMINI_AGENT_KEYS.has(key[1]);
     return keep;
@@ -152,12 +152,12 @@ function filterGeminiAgentFrontmatter(text: string): string {
 /** The command a Kiro hook runs for one front-door script: the project copy when the git root
  * holds one, else the user-scope copy under $HOME. One builder, so the static `doflow` agent
  * (core/harnesses/kiro/agents/doflow.json) and every generated specialist share the exact string. */
-function kiroHookCommand(script: string): string {
+function kiroHookCommand(script        )         {
   return `bash "$(root=$(git rev-parse --show-toplevel 2>/dev/null) && [ -f "$root/.kiro/hooks/${script}" ] && printf '%s/.kiro/hooks/${script}' "$root" || printf '%s/.kiro/hooks/${script}' "$HOME")"`;
 }
 
 /** One kiro-cli agent hook entry. */
-function kiroHook({ name, trigger, matcher, script, timeout }: { name: string, trigger: string, matcher?: string, script: string, timeout: number }): any {
+function kiroHook({ name, trigger, matcher, script, timeout }                                                                                      )      {
   return {
     name, trigger, ...(matcher ? { matcher } : {}),
     action: { type: 'command', command: kiroHookCommand(script) }, timeout,
@@ -168,7 +168,7 @@ function kiroHook({ name, trigger, matcher, script, timeout }: { name: string, t
  * "*" matcher: Kiro documents "@<server>" (every tool of one server) and "*" but no all-MCP
  * matcher, and mcp-tool-guard.sh exits 0 immediately for any non-MCP tool name, so "*" costs one
  * fast no-op for built-in tools and still covers every MCP server. */
-function kiroPreToolUseHooks(): any[] {
+function kiroPreToolUseHooks()        {
   return [
     kiroHook({ name: 'doflow-pre-implementation-gate', trigger: 'preToolUse', matcher: 'write', script: 'pre-implement-gate.sh', timeout: 10 }),
     kiroHook({ name: 'doflow-pre-bash-guard', trigger: 'preToolUse', matcher: 'shell', script: 'pre-bash-guard.sh', timeout: 10 }),
@@ -178,8 +178,8 @@ function kiroPreToolUseHooks(): any[] {
 
 /** Map one core/shared agent-spec file onto a kiro-cli custom agent. Spec keys other than
  * name/description (model: inherit, effort) are dropped: Kiro inherits the session model. */
-function renderKiroAgent(text: string): string {
-  const fm: Record<string, string> = {};
+function renderKiroAgent(text        )         {
+  const fm                         = {};
   let body = text;
   if (text.startsWith('---')) {
     const end = text.indexOf('\n---', 3);
@@ -206,8 +206,8 @@ const OPENCODE_READONLY_AGENTS = new Set(['spec-analyst', 'system-architect', 'q
  * (description / mode / permission; model omitted because OpenCode has no 'inherit'). Unknown
  * spec keys (tools, effort) are dropped rather than passed through, so OpenCode never sees
  * vocabulary it does not define. Body below the frontmatter passes through untouched. */
-function renderOpencodeAgent(text: string): string {
-  const fm: Record<string, string> = {};
+function renderOpencodeAgent(text        )         {
+  const fm                         = {};
   let body = text;
   if (text.startsWith('---')) {
     const end = text.indexOf('\n---', 3);
@@ -233,7 +233,7 @@ function renderOpencodeAgent(text: string): string {
  * the destination tree beyond checking existence. `relPath` is destination-relative and doubles as
  * the ledger identity, so a layout change relocates the recorded resource too — planTree's
  * relocation handling then removes the old path rather than orphaning it. */
-function discoverTree({ sourceDir, destDir, fsImpl = fs, layout, transform }: any): { files: any[] } {
+function discoverTree({ sourceDir, destDir, fsImpl = fs, layout, transform }     )                   {
   if (!fsImpl.existsSync(sourceDir)) throw new Error(`copy-tree source is missing: ${sourceDir}`);
   const mapRel = typeof layout === 'function' ? layout : resolveLayout(layout);
   const mapContent = typeof transform === 'function' ? transform : resolveTransform(transform);
@@ -248,7 +248,7 @@ function discoverTree({ sourceDir, destDir, fsImpl = fs, layout, transform }: an
 }
 
 /** A file's identity on disk (device + inode), or null when the path does not resolve to one. */
-function fileId(file: string, fsImpl: any): string | null {
+function fileId(file        , fsImpl     )                {
   try {
     const stat = fsImpl.statSync(file, { bigint: true });
     // An fs stand-in that reports no inode identifies nothing, rather than every file as one.
@@ -265,9 +265,9 @@ function fileId(file: string, fsImpl: any): string | null {
  * a hard link answers the same way. Built on first use, one stat per path; a path that does not
  * exist matches nothing, and `target` never matches itself.
  */
-function sameFileIndex(paths: string[], fsImpl: any = fs): (target: string) => string | null {
-  let byId: Map<string, string> | undefined;
-  return (target: string) => {
+function sameFileIndex(paths          , fsImpl      = fs)                                    {
+  let byId                                 ;
+  return (target        ) => {
     if (byId === undefined) {
       byId = new Map();
       for (const candidate of paths) {
@@ -292,31 +292,31 @@ function sameFileIndex(paths: string[], fsImpl: any = fs): (target: string) => s
  * `siblingReplaced` lists the harnesses whose recorded bytes this plan replaces: the file matches
  * neither the source nor this harness's own record, only a sibling's (forced or not).
  */
-function planTree({ sourceDir, destDir, previousResources = [], operation = 'apply', fsImpl = fs, layout, transform, force = false, keepModified = false, siblingFingerprints = new Map() }: any): any {
-  const prevByPath = new Map<string, any>(previousResources.map((resource: any) => [resource.relPath, resource]));
-  const changes: any[] = [];
-  const conflicts: string[] = [];
-  const kept: any[] = [];
-  const siblingReplaced = new Set<string>();
+function planTree({ sourceDir, destDir, previousResources = [], operation = 'apply', fsImpl = fs, layout, transform, force = false, keepModified = false, siblingFingerprints = new Map() }     )      {
+  const prevByPath = new Map             (previousResources.map((resource     ) => [resource.relPath, resource]));
+  const changes        = [];
+  const conflicts           = [];
+  const kept        = [];
+  const siblingReplaced = new Set        ();
 
   // Fingerprints the CURRENT source would write, keyed by destination. Resolved lazily and only
   // when a recorded fingerprint has already failed to match, so the common removal path still
   // never reads the source tree. A missing source directory is not an error here — an asset can be
   // removed after its source moved — it simply leaves the recorded fingerprint as the only signal.
-  let sourceByDest: Map<string, string> | undefined;
-  const sourceFingerprint = (destAbs: string): string | undefined => {
+  let sourceByDest                                 ;
+  const sourceFingerprint = (destAbs        )                     => {
     if (sourceByDest === undefined) {
       sourceByDest = sourceDir && fsImpl.existsSync(sourceDir)
-        ? new Map<string, string>(discoverTree({ sourceDir, destDir, fsImpl, layout, transform }).files.map((file): [string, string] => [file.destAbs, file.fingerprint]))
+        ? new Map                (discoverTree({ sourceDir, destDir, fsImpl, layout, transform }).files.map((file)                   => [file.destAbs, file.fingerprint]))
         : new Map();
     }
     return sourceByDest.get(destAbs);
   };
 
   // Every destination the current source produces, set once the apply path has discovered them.
-  let producedSameFile: ((target: string) => string | null) | undefined;
+  let producedSameFile                                                 ;
 
-  const proposeRemoval = (prev: any, { relocated = false }: { relocated?: boolean } = {}) => {
+  const proposeRemoval = (prev     , { relocated = false }                          = {}) => {
     // prev's OWN recorded location, not the current destDir — an asset whose nativeDir changed
     // since prev was recorded must be removed from where it actually is, not from where it would
     // land today. Absent (pre-this-fix data, or a caller-constructed previousResources entry with
@@ -414,9 +414,9 @@ function planTree({ sourceDir, destDir, previousResources = [], operation = 'app
 
 /** Write every create/update change. Preserves the source file's mode (so a hook script's +x
  * bit survives the copy without a separate chmod pass) and mtime, matching this codebase's
- * general convention for a lifecycle-owned write (see src/adapters/claude/index.ts's
+ * general convention for a lifecycle-owned write (see src/adapters/claude/index.js's
  * applySettingsAsset for the same pattern applied to a transformed-content file). */
-function applyTree({ changes = [], fsImpl = fs, transform }: any): { applied: number } {
+function applyTree({ changes = [], fsImpl = fs, transform }     )                      {
   const mapContent = typeof transform === 'function' ? transform : resolveTransform(transform);
   let applied = 0;
   for (const change of changes) {
@@ -440,15 +440,15 @@ function applyTree({ changes = [], fsImpl = fs, transform }: any): { applied: nu
 }
 
 /** Why a removal the runtime prune planned may no longer run, or null when it still may: the
- * prune's plan-time proof (src/lifecycle/index.ts pruneRetiredRuntimeFiles) re-run right before the
+ * prune's plan-time proof (src/lifecycle/index.js pruneRetiredRuntimeFiles) re-run right before the
  * unlink, so a directory swapped for a symlink, or a file linked to a shipped one, after the plan was
  * made is not deleted through. `guard` is `{ root, source }`: the tree and the source it projects.
  * One walk of the source and one stat per shipped path per tree per call, cached in `cache`. */
-function pruneGuardRefusal(change: any, cache: Map<string, any>, fsImpl: any): string | null {
+function pruneGuardRefusal(change     , cache                  , fsImpl     )                {
   const { root, source } = change.pruneGuard;
   const key = `${root}\0${source}`;
   if (!cache.has(key)) {
-    const produced = fsImpl.existsSync(source) ? discoverTree({ sourceDir: source, destDir: root, fsImpl }).files.map((file: any) => file.destAbs) : [];
+    const produced = fsImpl.existsSync(source) ? discoverTree({ sourceDir: source, destDir: root, fsImpl }).files.map((file     ) => file.destAbs) : [];
     cache.set(key, { realRoot: fsImpl.realpathSync(root), sameFile: sameFileIndex(produced, fsImpl) });
   }
   const { realRoot, sameFile } = cache.get(key);
@@ -460,9 +460,9 @@ function pruneGuardRefusal(change: any, cache: Map<string, any>, fsImpl: any): s
 /** Delete every remove change, re-checking each file's fingerprint immediately before deletion —
  * refuses (throws) rather than silently deleting a file modified since planTree ran. A removal the
  * runtime prune planned (`pruneGuard`) also re-checks its containment and same-file proof there. */
-function removeTree({ changes = [], fsImpl = fs }: any): { removed: number } {
+function removeTree({ changes = [], fsImpl = fs }     )                      {
   let removed = 0;
-  const guards = new Map<string, any>();
+  const guards = new Map             ();
   for (const change of changes) {
     if (change.operation !== 'remove' || change.kept) continue;
     if (!fsImpl.existsSync(change.target)) continue;
@@ -486,7 +486,7 @@ const ANCHOR_DIRS = new Set(['.agents', '.claude', '.codex', '.copilot', '.doflo
  * which may hold user content elsewhere. The match is by basename, so a root with another name
  * (`~/.gemini/config`, `~/.pi/agent`, `~/.config/opencode`) is pruned once it is empty; no file is
  * ever lost, since rmdir refuses a folder that holds one. */
-function pruneEmptyAncestors(startDir: string, { fsImpl = fs }: { fsImpl?: any } = {}): void {
+function pruneEmptyAncestors(startDir        , { fsImpl = fs }                   = {})       {
   let current = startDir;
   for (;;) {
     const basename = path.basename(current);
@@ -500,11 +500,11 @@ function pruneEmptyAncestors(startDir: string, { fsImpl = fs }: { fsImpl?: any }
  * `plannedWrites` lists the destinations the run being verified wrote. An absent source file is
  * not reported in general, because a user may delete one, but an absent file this run wrote means
  * the run lost it (a case-only rename once deleted the file it had just written) and is a conflict. */
-function verifyTree({ sourceDir, destDir, fsImpl = fs, layout, transform, plannedWrites = [] }: any): { ok: boolean, resources: any[], conflicts: string[] } {
+function verifyTree({ sourceDir, destDir, fsImpl = fs, layout, transform, plannedWrites = [] }     )                                                         {
   const { files } = discoverTree({ sourceDir, destDir, fsImpl, layout, transform });
   const written = new Set(plannedWrites);
-  const resources: any[] = [];
-  const conflicts: string[] = [];
+  const resources        = [];
+  const conflicts           = [];
   for (const file of files) {
     if (!file.exists) {
       if (written.has(file.destAbs)) conflicts.push(`${file.relPath} was written by this run but is missing`);
@@ -520,14 +520,14 @@ function verifyTree({ sourceDir, destDir, fsImpl = fs, layout, transform, planne
 // ---- per-adapter copy-tree glue, shared so codex/claude/gemini don't each carry their own copy ----
 
 /** Filter a harness's asset list down to the ones this engine handles. */
-function copyTreeAssets(assets: any): any[] {
-  return (assets || []).filter((asset: any) => asset?.renderer === 'copy-tree');
+function copyTreeAssets(assets     )        {
+  return (assets || []).filter((asset     ) => asset?.renderer === 'copy-tree');
 }
 
 /** Recursively sort object keys before serializing, so two logically-equal objects with
  * differently-ordered keys (e.g. after a settings file is merged and re-merged) fingerprint
  * identically instead of spuriously registering as changed. */
-function stableSort(value: any): any {
+function stableSort(value     )      {
   if (Array.isArray(value)) return value.map(stableSort);
   if (!value || typeof value !== 'object') return value;
   return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stableSort(value[key])]));
@@ -535,22 +535,22 @@ function stableSort(value: any): any {
 
 /** Content fingerprint every adapter uses to track what it owns: sha256 of a string as-is, or of
  * a stably key-sorted JSON serialization of anything else. */
-function fingerprint(value: any): string {
+function fingerprint(value     )         {
   return sha256(typeof value === 'string' ? value : JSON.stringify(stableSort(value)));
 }
 
 /** Read and parse a native JSON file an adapter merges into. Distinguishes "absent" (safe to
  * create) from "present but unparseable" (a conflict to report, never silently overwritten) —
  * every adapter that merges into a native JSON settings/config file needs exactly this. */
-function readJson(file: string, { fsImpl = fs }: { fsImpl?: any } = {}): { exists: boolean, value: any, error: string | null } {
+function readJson(file        , { fsImpl = fs }                   = {})                                                        {
   if (!fsImpl.existsSync(file)) return { exists: false, value: {}, error: null };
   try { return { exists: true, value: JSON.parse(fsImpl.readFileSync(file, 'utf8')), error: null }; }
-  catch (error: any) { return { exists: true, value: null, error: `Invalid JSON in ${file}: ${error.message}` }; }
+  catch (error     ) { return { exists: true, value: null, error: `Invalid JSON in ${file}: ${error.message}` }; }
 }
 
 /** Resolve an asset's source directory against the repo root, refusing a path that escapes the
  * repository or does not exist. `harnessName` only shapes the thrown error message. */
-function sourceDirFor(asset: any, context: any = {}, fsImpl: any = fs, harnessName: string = 'Adapter'): string {
+function sourceDirFor(asset     , context      = {}, fsImpl      = fs, harnessName         = 'Adapter')         {
   if (!asset || typeof asset.source !== 'string') throw new Error(`${harnessName} asset requires a source path`);
   const repoRoot = context.repoRoot ? path.resolve(context.repoRoot) : process.cwd();
   const source = path.resolve(repoRoot, asset.source);
@@ -561,14 +561,14 @@ function sourceDirFor(asset: any, context: any = {}, fsImpl: any = fs, harnessNa
 }
 
 /** Resolve an asset's native destination directory under the harness's already-resolved config dir. */
-function copyTreeDestDir(configDir: string, asset: any): string {
+function copyTreeDestDir(configDir        , asset     )         {
   return path.join(configDir, asset.nativeDir || '');
 }
 
 /** Destination of a `../.doflow` shared-tree asset at the scope root (`<project>/.doflow`, or
  * `$HOME/.doflow` globally), for harnesses whose tree root sits more than one level under the scope
  * root. Returns null for any other nativeDir, so the caller falls back to `copyTreeDestDir`. */
-function sharedTreeDestDir(rootDir: string, nativeDir: any): string | null {
+function sharedTreeDestDir(rootDir        , nativeDir     )                {
   if (nativeDir !== '../.doflow' && !String(nativeDir || '').startsWith('../.doflow/')) return null;
   const sharedRoot = path.join(rootDir, '.doflow');
   const dest = path.join(rootDir, '.doflow', nativeDir.slice('../.doflow'.length));
@@ -590,13 +590,13 @@ const SHARED_TREE_ASSETS = new Set([
 /** For each shared-tree target, the fingerprints other harnesses recorded and which harness
  * recorded each, so an update accepts a runtime or guidance tree a sibling wrote (several harnesses
  * claim one `.doflow` file) while bytes no such row recorded are still refused as a hand edit. */
-function ledgerSiblingFingerprints(resources: any, harness: string): Map<string, Map<string, string>> {
-  const byTarget = new Map<string, Map<string, string>>();
+function ledgerSiblingFingerprints(resources     , harness        )                                   {
+  const byTarget = new Map                             ();
   for (const resource of resources || []) {
     if (resource.kind !== 'copy-tree-file' || resource.harness === harness || !SHARED_TREE_ASSETS.has(resource.assetId)) continue;
     if (typeof resource.target !== 'string' || typeof resource.fingerprint !== 'string') continue;
     if (!byTarget.has(resource.target)) byTarget.set(resource.target, new Map());
-    const byFingerprint = byTarget.get(resource.target)!;
+    const byFingerprint = byTarget.get(resource.target) ;
     if (!byFingerprint.has(resource.fingerprint)) byFingerprint.set(resource.fingerprint, resource.harness);
   }
   return byTarget;
@@ -604,17 +604,17 @@ function ledgerSiblingFingerprints(resources: any, harness: string): Map<string,
 
 /** The one-line plan notice for a plan whose copy-tree results replaced sibling-written files, or
  * an empty list when none did. */
-function siblingReplacedNotices(results: any[]): string[] {
+function siblingReplacedNotices(results       )           {
   const harnesses = [...new Set(results.flatMap((result) => result.siblingReplaced))].sort();
   if (!harnesses.length) return [];
   return [`replaced shared files written by ${harnesses.join(', ')}; reinstall ${harnesses.length > 1 ? 'those harnesses' : 'that harness'} to restore them`];
 }
 
 /** Narrow a harness's flat neutral-resource list to one asset's previously-owned copy-tree files. */
-function ledgerFileResources(resources: any, harness: string, assetId: string): any[] {
+function ledgerFileResources(resources     , harness        , assetId        )        {
   return (resources || [])
-    .filter((resource: any) => resource.harness === harness && resource.assetId === assetId && resource.kind === 'copy-tree-file')
-    .map((resource: any) => ({ relPath: resource.identity, fingerprint: resource.fingerprint, target: resource.target }));
+    .filter((resource     ) => resource.harness === harness && resource.assetId === assetId && resource.kind === 'copy-tree-file')
+    .map((resource     ) => ({ relPath: resource.identity, fingerprint: resource.fingerprint, target: resource.target }));
 }
 
 module.exports = { kiroHook, kiroHookCommand, kiroPreToolUseHooks, walkRelFiles, discoverTree, sameFileIndex, planTree, applyTree, removeTree, verifyTree, copyTreeAssets, copyTreeDestDir, sharedTreeDestDir, ledgerFileResources, ledgerSiblingFingerprints, siblingReplacedNotices, resolveLayout, LAYOUTS, resolveTransform, TRANSFORMS, fingerprint, pruneEmptyAncestors, readJson, sourceDirFor };

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

@@ -14,8 +14,8 @@
 // if a third harness with the same shape is ever added.
 const fs = require('node:fs');
 const path = require('node:path');
-const { verifyHookCommands } = require('../hook-commands.ts');
-const { mergeHooks } = require('../../helper/settings-merge.ts');
+const { verifyHookCommands } = require('../hook-commands.js');
+const { mergeHooks } = require('../../helper/settings-merge.js');
 
 const SUPPORTED_EVENTS = new Set([
   'SessionStart', 'SessionEnd', 'BeforeAgent', 'AfterAgent', 'BeforeModel', 'AfterModel',
@@ -27,7 +27,7 @@ const SUPPORTED_EVENTS = new Set([
 // Stop, SubagentStart/Stop, and ConfigChange have no correct Gemini equivalent and are
 // intentionally omitted rather than approximated onto BeforeAgent/AfterAgent (design.md §7/§8 —
 // no false parity).
-const CLAUDE_TO_GEMINI_EVENT: Record<string, string> = {
+const CLAUDE_TO_GEMINI_EVENT                         = {
   SessionStart: 'SessionStart',
   SessionEnd: 'SessionEnd',
   PreToolUse: 'BeforeTool',
@@ -35,10 +35,10 @@ const CLAUDE_TO_GEMINI_EVENT: Record<string, string> = {
   PreCompact: 'PreCompress',
 };
 
-function validationError(errors: string[], message: string): void { errors.push(message); }
+function validationError(errors          , message        )       { errors.push(message); }
 
-function validateHooksConfig(config: any): { ok: boolean, errors: string[], events: string[] } {
-  const errors: string[] = [];
+function validateHooksConfig(config     )                                                      {
+  const errors           = [];
   if (!config || typeof config !== 'object' || Array.isArray(config)) {
     return { ok: false, errors: ['Hook configuration must be an object'], events: [] };
   }
@@ -54,7 +54,7 @@ function validateHooksConfig(config: any): { ok: boolean, errors: string[], even
       validationError(errors, `Hook event '${event}' requires a non-empty array of matcher groups`);
       continue;
     }
-    groups.forEach((group: any, groupIndex: number) => {
+    groups.forEach((group     , groupIndex        ) => {
       if (!group || typeof group !== 'object' || Array.isArray(group)) {
         validationError(errors, `Hook event '${event}' group ${groupIndex} must be an object`);
         return;
@@ -66,7 +66,7 @@ function validateHooksConfig(config: any): { ok: boolean, errors: string[], even
         validationError(errors, `Hook event '${event}' group ${groupIndex} requires a non-empty hooks array`);
         return;
       }
-      group.hooks.forEach((handler: any, handlerIndex: number) => {
+      group.hooks.forEach((handler     , handlerIndex        ) => {
         const label = `Hook event '${event}' group ${groupIndex} handler ${handlerIndex}`;
         if (!handler || typeof handler !== 'object' || Array.isArray(handler)) {
           validationError(errors, `${label} must be an object`); return;
@@ -85,9 +85,9 @@ function validateHooksConfig(config: any): { ok: boolean, errors: string[], even
 }
 
 /** Maps Claude guardrail intent, never fabricating a Gemini equivalent for unavailable events. */
-function classifyClaudeGuardrails(claudeHooks: any = {}): { supported: any[], unsupported: any[] } {
-  const supported: any[] = [];
-  const unsupported: any[] = [];
+function classifyClaudeGuardrails(claudeHooks      = {})                                           {
+  const supported        = [];
+  const unsupported        = [];
   for (const [event, groups] of Object.entries(claudeHooks || {})) {
     const targetEvent = CLAUDE_TO_GEMINI_EVENT[event] || null;
     const item = { sourceEvent: event, targetEvent, groups: Array.isArray(groups) ? groups.length : 0 };
@@ -103,22 +103,22 @@ function classifyClaudeGuardrails(claudeHooks: any = {}): { supported: any[], un
  * exists but fails to parse is a hard error, not silently treated as empty (this path merges
  * into content DoFlow does not own — a malformed-file work-around here risks losing it).
  */
-function planGeminiHooks({ config, sourceFile, sourceHooksDir, settingsFile, destinationHooksDir: declaredHooksDir, trusted = false, fsImpl = fs }: any = {}): any {
+function planGeminiHooks({ config, sourceFile, sourceHooksDir, settingsFile, destinationHooksDir: declaredHooksDir, trusted = false, fsImpl = fs }      = {})      {
   let desired = config;
   try {
     if (!desired && sourceFile) desired = JSON.parse(fsImpl.readFileSync(sourceFile, 'utf8'));
-  } catch (error: any) {
+  } catch (error     ) {
     return { ok: false, status: 'malformed', changes: [], errors: [`Could not parse ${sourceFile}: ${error.message}`] };
   }
   if (!settingsFile) return { ok: false, status: 'invalid-request', changes: [], errors: ['settingsFile is required'] };
   const schema = validateHooksConfig(desired);
   const commands = verifyHookCommands(desired || {}, { scriptsDir: sourceHooksDir, trusted, fsImpl });
-  const errors = [...schema.errors, ...commands.checks.filter((check: any) => !check.ok).map((check: any) => `${check.event}: ${check.reason}${check.script ? ` (${check.script})` : ''}`)];
+  const errors = [...schema.errors, ...commands.checks.filter((check     ) => !check.ok).map((check     ) => `${check.event}: ${check.reason}${check.script ? ` (${check.script})` : ''}`)];
 
-  let existing: any = {};
+  let existing      = {};
   if (fsImpl.existsSync(settingsFile)) {
     try { existing = JSON.parse(fsImpl.readFileSync(settingsFile, 'utf8')); }
-    catch (error: any) { return { ok: false, status: 'malformed', changes: [], errors: [`Refusing to touch malformed ${settingsFile}: ${error.message}`] }; }
+    catch (error     ) { return { ok: false, status: 'malformed', changes: [], errors: [`Refusing to touch malformed ${settingsFile}: ${error.message}`] }; }
   }
   if (errors.length) return { ok: false, status: 'invalid-request', settingsFile, existing, changes: [], errors, commands };
 
@@ -131,18 +131,18 @@ function planGeminiHooks({ config, sourceFile, sourceHooksDir, settingsFile, des
   const destinationHooksDir = declaredHooksDir || path.join(path.dirname(settingsFile), 'hooks');
   // The scripts deployGeminiHooks copies beside settings.json, so a backup of this change holds them too.
   const shipped = sourceHooksDir && fsImpl.existsSync(sourceHooksDir)
-    ? fsImpl.readdirSync(sourceHooksDir).filter((name: string) => !name.endsWith('.json') && fsImpl.statSync(path.join(sourceHooksDir, name)).isFile())
+    ? fsImpl.readdirSync(sourceHooksDir).filter((name        ) => !name.endsWith('.json') && fsImpl.statSync(path.join(sourceHooksDir, name)).isFile())
     : [];
   const companionTargets = [...new Set([
-    ...commands.checks.map((check: any) => path.join(destinationHooksDir, check.script)),
-    ...shipped.map((name: string) => path.join(destinationHooksDir, name)),
+    ...commands.checks.map((check     ) => path.join(destinationHooksDir, check.script)),
+    ...shipped.map((name        ) => path.join(destinationHooksDir, name)),
   ])].sort();
   return { ok: true, status: changed ? 'change' : 'unchanged', settingsFile, existing, merged,
     changes: changed ? [{ type: fsImpl.existsSync(settingsFile) ? 'update' : 'create', file: settingsFile, key: 'hooks' }] : [],
     errors: [], commands, trust: commands.trust, scriptsDir: sourceHooksDir, destinationHooksDir, companionTargets };
 }
 
-function deployGeminiHooks(plan: any, { dryRun = false, fsImpl = fs }: { dryRun?: boolean, fsImpl?: any } = {}): any {
+function deployGeminiHooks(plan     , { dryRun = false, fsImpl = fs }                                     = {})      {
   if (!plan.ok) return { ...plan, applied: false };
   if (dryRun || plan.status === 'unchanged') return { ...plan, applied: false };
   fsImpl.mkdirSync(path.dirname(plan.settingsFile), { recursive: true });
@@ -154,7 +154,7 @@ function deployGeminiHooks(plan: any, { dryRun = false, fsImpl = fs }: { dryRun?
   } finally {
     if (fsImpl.existsSync(temporary)) fsImpl.unlinkSync(temporary);
   }
-  const deployed = new Set<string>();
+  const deployed = new Set        ();
   for (const check of plan.commands.checks) {
     const target = path.join(plan.destinationHooksDir, check.script);
     fsImpl.mkdirSync(path.dirname(target), { recursive: true });
@@ -182,18 +182,18 @@ function deployGeminiHooks(plan: any, { dryRun = false, fsImpl = fs }: { dryRun?
  * cross-check): if the key isn't present, there's nothing to do; otherwise propose removing only
  * that key, leaving every other key in the shared file untouched (FR-002).
  */
-function planRemoveGeminiHooks({ settingsFile, fsImpl = fs }: { settingsFile?: string, fsImpl?: any } = {}): any {
+function planRemoveGeminiHooks({ settingsFile, fsImpl = fs }                                          = {})      {
   if (!settingsFile) return { ok: false, status: 'invalid-request', changes: [], errors: ['settingsFile is required'] };
   if (!fsImpl.existsSync(settingsFile)) return { ok: true, status: 'unchanged', settingsFile, changes: [] };
   let existing;
   try { existing = JSON.parse(fsImpl.readFileSync(settingsFile, 'utf8')); }
-  catch (error: any) { return { ok: false, status: 'malformed', changes: [], errors: [`Could not parse ${settingsFile}: ${error.message}`] }; }
+  catch (error     ) { return { ok: false, status: 'malformed', changes: [], errors: [`Could not parse ${settingsFile}: ${error.message}`] }; }
   if (existing.hooks === undefined) return { ok: true, status: 'unchanged', settingsFile, changes: [] };
   const { hooks: _dropped, ...merged } = existing;
   return { ok: true, status: 'change', settingsFile, merged, changes: [{ type: 'update', file: settingsFile, key: 'hooks', operation: 'remove' }] };
 }
 
-function deployRemoveGeminiHooks(plan: any, { dryRun = false, fsImpl = fs }: { dryRun?: boolean, fsImpl?: any } = {}): any {
+function deployRemoveGeminiHooks(plan     , { dryRun = false, fsImpl = fs }                                     = {})      {
   if (!plan.ok || plan.status !== 'change' || dryRun) return { ...plan, applied: false };
   fsImpl.mkdirSync(path.dirname(plan.settingsFile), { recursive: true });
   const content = `${JSON.stringify(plan.merged, null, 2)}\n`;