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

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));
@@ -578,25 +578,25 @@ function sharedTreeDestDir(rootDir: string, nativeDir: any): string | null {
   return dest;
 }
 
-/** The assets that project a tree several harnesses claim at one scope root: the runtime tree, and
- * the guidance tree. A harness whose
+/** The assets that project a tree several harnesses claim at one scope root: the runtime, guidance,
+ * and shared hooks trees. A harness whose
  * install predates its own rows for a shared tree (Pi gained guidance rows in v1.15.0) can only
  * recognise the bytes a sibling recorded. */
 const SHARED_TREE_ASSETS = new Set([
   'scripts.doflow', 'runtime.cli', 'runtime.lib', 'runtime.registry',
-  'guidance.context-layer', 'kiro.guidance-tree',
+  'guidance.context-layer', 'kiro.guidance-tree', 'hooks.shared',
 ]);
 
 /** 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
+ * recorded each, so an update accepts a runtime, guidance, or shared hooks 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 };