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

package/src/adapters/{mcp-entries.ts → mcp-entries.js}

@@ -14,7 +14,7 @@
 // the same reason a file DoFlow cannot read is described by a fixed reason, never parser output.
 const fs = require('node:fs');
 const path = require('node:path');
-const { fingerprint } = require('./copy-tree.ts');
+const { fingerprint } = require('./copy-tree.js');
 
 const REASONS = Object.freeze({
   json: 'invalid JSON',
@@ -22,29 +22,29 @@ const REASONS = Object.freeze({
   container: 'server container is not an object',
 });
 
-function isObject(value: any): boolean { return Boolean(value) && typeof value === 'object' && !Array.isArray(value); }
+function isObject(value     )          { return Boolean(value) && typeof value === 'object' && !Array.isArray(value); }
 
-function entryFingerprint(value: any): string { return fingerprint(value); }
+function entryFingerprint(value     )         { return fingerprint(value); }
 
-function fingerprintOrNull(value: any): string | null { return value === undefined ? null : entryFingerprint(value); }
+function fingerprintOrNull(value     )                { return value === undefined ? null : entryFingerprint(value); }
 
 /** Deep equality that ignores key order, so a reformatted entry still equals DoFlow's rendering. */
-function sameValue(a: any, b: any): boolean { return a !== undefined && b !== undefined && entryFingerprint(a) === entryFingerprint(b); }
+function sameValue(a     , b     )          { return a !== undefined && b !== undefined && entryFingerprint(a) === entryFingerprint(b); }
 
-function shortId(id: any): string { const text = String(id); return text.length > 40 ? `${text.slice(0, 37)}...` : text; }
+function shortId(id     )         { const text = String(id); return text.length > 40 ? `${text.slice(0, 37)}...` : text; }
 
-function shortPath(file: string): string { return file.length > 80 ? `...${file.slice(-77)}` : file; }
+function shortPath(file        )         { return file.length > 80 ? `...${file.slice(-77)}` : file; }
 
 const NOTICES = Object.freeze({
-  collision: (id: any, file: string) => `MCP: kept your own entry '${shortId(id)}' in ${path.basename(file)} and did not register DoFlow's; rename or remove yours to let DoFlow manage it.`,
-  released: (id: any, file: string) => `MCP: entry '${shortId(id)}' in ${path.basename(file)} was changed outside DoFlow; it is yours now and DoFlow no longer updates or removes it.`,
-  untouched: (file: string) => `MCP: left ${shortPath(file)} untouched because it cannot be edited safely; DoFlow no longer manages the entries in it.`,
+  collision: (id     , file        ) => `MCP: kept your own entry '${shortId(id)}' in ${path.basename(file)} and did not register DoFlow's; rename or remove yours to let DoFlow manage it.`,
+  released: (id     , file        ) => `MCP: entry '${shortId(id)}' in ${path.basename(file)} was changed outside DoFlow; it is yours now and DoFlow no longer updates or removes it.`,
+  untouched: (file        ) => `MCP: left ${shortPath(file)} untouched because it cannot be edited safely; DoFlow no longer manages the entries in it.`,
 });
 
-function refusal(label: string, file: string, reason: string): string { return `${label}: ${file}: ${reason}; DoFlow did not change the file`; }
+function refusal(label        , file        , reason        )         { return `${label}: ${file}: ${reason}; DoFlow did not change the file`; }
 
 /** Read one MCP file as a JSON object. `servers` is null when the file or its container is absent. */
-function readMcpFile(file: string, container: string, { fsImpl = fs }: { fsImpl?: any } = {}): any {
+function readMcpFile(file        , container        , { fsImpl = fs }                   = {})      {
   if (!fsImpl.existsSync(file)) return { ok: true, doc: null, servers: null };
   let doc;
   try { doc = JSON.parse(fsImpl.readFileSync(file, 'utf8')); } catch { return { ok: false, reason: REASONS.json }; }
@@ -55,52 +55,52 @@ function readMcpFile(file: string, container: string, { fsImpl = fs }: { fsImpl?
 }
 
 /** The `files` map plan and verify take: the scope's MCP file and every file an own row names. */
-function readMcpFiles({ file, ownRows = [], container, fsImpl = fs }: any): any {
-  const targets = new Set([file, ...ownRows.map((row: any) => row.target)]);
+function readMcpFiles({ file, ownRows = [], container, fsImpl = fs }     )      {
+  const targets = new Set([file, ...ownRows.map((row     ) => row.target)]);
   return Object.fromEntries([...targets].map((target) => {
     const read = readMcpFile(target, container, { fsImpl });
     return [target, read.ok ? { ok: true, servers: read.servers } : read];
   }));
 }
 
-function renderedById(selected: any[], adoptable: any[]): Map<string, any> {
-  const rendered = new Map<string, any>();
+function renderedById(selected       , adoptable       )                   {
+  const rendered = new Map             ();
   for (const { id, entry } of [...selected, ...adoptable]) if (!rendered.has(id)) rendered.set(id, entry);
   return rendered;
 }
 
 /** Shared by plan, verify and ownedMcpIds, so the three read one entry the same way. */
-function ownershipView({ file, files, selected = [], adoptable = [], ownRows = [], foreignRows = [] }: any): any {
+function ownershipView({ file, files, selected = [], adoptable = [], ownRows = [], foreignRows = [] }     )      {
   const rendered = renderedById(selected, adoptable);
-  const valueOf = (target: string, id: string) => (files[target]?.ok ? files[target].servers?.[id] : undefined);
-  const matches = (row: any, value: any) => {
+  const valueOf = (target        , id        ) => (files[target]?.ok ? files[target].servers?.[id] : undefined);
+  const matches = (row     , value     ) => {
     if (value === undefined) return false;
     const recorded = row.fingerprint ?? null;
     return recorded !== null ? entryFingerprint(value) === recorded : sameValue(value, rendered.get(row.identity));
   };
-  const rowsFor = (id: string) => ownRows.filter((row: any) => row.identity === id && row.target === file);
+  const rowsFor = (id        ) => ownRows.filter((row     ) => row.identity === id && row.target === file);
   // A legacy row is consumed alongside the current one, but never preferred over it.
-  const rowFor = (id: string) => { const rows = rowsFor(id); return rows.find((row: any) => !row.legacy) ?? rows[0] ?? null; };
+  const rowFor = (id        ) => { const rows = rowsFor(id); return rows.find((row     ) => !row.legacy) ?? rows[0] ?? null; };
   const adoptionOpen = ownRows.length === 0;
-  const adoptableIds = new Set(adoptable.map((server: any) => server.id));
-  const selectedIds = new Set(selected.map((server: any) => server.id));
+  const adoptableIds = new Set(adoptable.map((server     ) => server.id));
+  const selectedIds = new Set(selected.map((server     ) => server.id));
   /** An equal entry no own row claims is DoFlow's when another harness's row claims it, or when it
    * may be adopted. */
-  const claimable = (id: string, entry: any) => {
+  const claimable = (id        , entry     ) => {
     const value = valueOf(file, id);
-    return sameValue(value, entry) && (foreignRows.some((row: any) => row.identity === id && row.target === file)
+    return sameValue(value, entry) && (foreignRows.some((row     ) => row.identity === id && row.target === file)
       || (adoptionOpen && adoptableIds.has(id)));
   };
   /** Adoptable entries DoFlow takes out because nothing selects them any more. */
   const adoptedRemovals = () => (adoptionOpen && files[file]?.ok
-    ? adoptable.filter(({ id, entry }: any) => !selectedIds.has(id) && sameValue(valueOf(file, id), entry)) : []);
+    ? adoptable.filter(({ id, entry }     ) => !selectedIds.has(id) && sameValue(valueOf(file, id), entry)) : []);
   return { rendered, valueOf, matches, rowsFor, rowFor, claimable, adoptedRemovals };
 }
 
-function orderOf(selected: any[], adoptable: any[]): (a: any, b: any) => number {
+function orderOf(selected       , adoptable       )                             {
   const ids = [...renderedById(selected, adoptable).keys()];
-  const rank = (id: string) => { const index = ids.indexOf(id); return index < 0 ? ids.length : index; };
-  return (a: any, b: any) => (a.target < b.target ? -1 : a.target > b.target ? 1
+  const rank = (id        ) => { const index = ids.indexOf(id); return index < 0 ? ids.length : index; };
+  return (a     , b     ) => (a.target < b.target ? -1 : a.target > b.target ? 1
     : rank(a.identity) - rank(b.identity) || (a.identity < b.identity ? -1 : a.identity > b.identity ? 1 : 0));
 }
 
@@ -110,17 +110,17 @@ function orderOf(selected: any[], adoptable: any[]): (a: any, b: any) => number
  * `foreignRows` other harnesses' rows; `identityFor` composes the adapter's ownership identity.
  */
 function planMcpEntries({ file, files, selected = [], adoptable = [], ownRows = [], foreignRows = [], removing = false,
-  identityFor, assetId, renderer, label }: any): any {
+  identityFor, assetId, renderer, label }     )      {
   const view = ownershipView({ file, files, selected, adoptable, ownRows, foreignRows });
-  const changes: any[] = [];
-  const conflicts: string[] = [];
-  const notices: string[] = [];
-  const base = (fields: any) => ({ assetId, kind: 'mcp-server', sourceVersion: 'registry-v1', projection: { renderer }, ...fields });
-  const write = (operation: string, id: string, entry: any) => base({
+  const changes        = [];
+  const conflicts           = [];
+  const notices           = [];
+  const base = (fields     ) => ({ assetId, kind: 'mcp-server', sourceVersion: 'registry-v1', projection: { renderer }, ...fields });
+  const write = (operation        , id        , entry     ) => base({
     target: file, operation, identity: id, ownershipIdentity: identityFor(id),
     before: fingerprintOrNull(view.valueOf(file, id)), entry, fingerprint: entryFingerprint(entry), afterFingerprint: entryFingerprint(entry),
   });
-  const drop = (row: any, release: boolean) => base({
+  const drop = (row     , release         ) => base({
     target: row.target, operation: 'remove', identity: row.identity, ownershipIdentity: row.ownershipIdentity,
     before: fingerprintOrNull(view.valueOf(row.target, row.identity)), fingerprint: row.fingerprint ?? null,
     ...(release ? { release: true } : {}),
@@ -132,7 +132,7 @@ function planMcpEntries({ file, files, selected = [], adoptable = [], ownRows =
     else conflicts.push(refusal(label, target, files[target].reason));
   }
 
-  const consumed = new Set<any>();
+  const consumed = new Set     ();
   if (!removing && files[file]?.ok) {
     for (const { id, entry } of selected) {
       const rows = view.rowsFor(id);
@@ -184,7 +184,7 @@ function planMcpEntries({ file, files, selected = [], adoptable = [], ownRows =
 /** Apply one file's planned changes to the server map read now. Each change goes ahead only while
  * its entry still holds what plan saw, or already holds the change's end state, which makes two
  * harnesses' changes to one shared entry in one run idempotent. Release changes touch nothing. */
-function applyMcpEntries(servers: any, changes: any[]): any {
+function applyMcpEntries(servers     , changes       )      {
   const next = { ...(servers || {}) };
   for (const change of changes) {
     if (change.release) continue;
@@ -205,13 +205,13 @@ function applyMcpEntries(servers: any, changes: any[]): any {
  * whatever it holds now.
  */
 function verifyMcpEntries({ file, files, snapshot, selected = [], adoptable = [], ownRows = [], foreignRows = [], removing = false,
-  identityFor, assetId, renderer, label, harness, sourceVersion = 'unknown' }: any): any {
+  identityFor, assetId, renderer, label, harness, sourceVersion = 'unknown' }     )      {
   const now = ownershipView({ file, files, selected, adoptable, ownRows, foreignRows });
   const then = ownershipView({ file, files: snapshot, selected, adoptable, ownRows, foreignRows });
-  const statuses: any[] = [];
-  const resources: any[] = [];
-  const conflicts: string[] = [];
-  const report = (id: string, target: string, ownershipIdentity: any, status: string) => statuses.push({
+  const statuses        = [];
+  const resources        = [];
+  const conflicts           = [];
+  const report = (id        , target        , ownershipIdentity     , status        ) => statuses.push({
     harness, assetId, capability: 'mcp', identity: id, target, ownershipIdentity, status,
   });
 
@@ -219,7 +219,7 @@ function verifyMcpEntries({ file, files, snapshot, selected = [], adoptable = []
     for (const target of Object.keys(files).filter((item) => !files[item].ok).sort()) conflicts.push(refusal(label, target, files[target].reason));
   }
 
-  const consumed = new Set<any>();
+  const consumed = new Set     ();
   if (!removing) {
     for (const { id, entry } of selected) {
       for (const row of now.rowsFor(id)) consumed.add(row);
@@ -239,7 +239,7 @@ function verifyMcpEntries({ file, files, snapshot, selected = [], adoptable = []
     }
   }
 
-  const leftover = (value: any, matching: boolean, target: string) => {
+  const leftover = (value     , matching         , target        ) => {
     if (!files[target]?.ok) return 'not-managed';
     if (value === undefined) return 'absent';
     return matching ? 'retained' : 'not-managed';
@@ -261,29 +261,29 @@ function verifyMcpEntries({ file, files, snapshot, selected = [], adoptable = []
 /** The ids DoFlow owns in this harness's MCP file now, in rendering order: those an own row matches,
  * and, while the harness holds no row, adoptable entries equal to DoFlow's rendering. A file that
  * cannot be read contributes none. */
-function ownedMcpIds({ file, files, selected = [], adoptable = [], ownRows = [] }: any): string[] {
+function ownedMcpIds({ file, files, selected = [], adoptable = [], ownRows = [] }     )           {
   const view = ownershipView({ file, files, selected, adoptable, ownRows });
-  const owned = new Set<string>(ownRows.filter((row: any) => view.matches(row, view.valueOf(row.target, row.identity))).map((row: any) => row.identity));
+  const owned = new Set        (ownRows.filter((row     ) => view.matches(row, view.valueOf(row.target, row.identity))).map((row     ) => row.identity));
   if (!ownRows.length) {
     for (const { id, entry } of adoptable) if (sameValue(view.valueOf(file, id), entry)) owned.add(id);
   }
-  const order: string[] = [...view.rendered.keys()];
+  const order           = [...view.rendered.keys()];
   return [...order.filter((id) => owned.has(id)), ...[...owned].filter((id) => !order.includes(id)).sort()];
 }
 
-function isSymlink(file: string, fsImpl: any): boolean {
+function isSymlink(file        , fsImpl     )          {
   try { return fsImpl.lstatSync(file).isSymbolicLink(); } catch { return false; }
 }
 
 /** A symlinked MCP file is written through to the file it points at, so the link stays a link. */
-function writePath(file: string, fsImpl: any): string {
+function writePath(file        , fsImpl     )         {
   if (!isSymlink(file, fsImpl)) return file;
   try { return fsImpl.realpathSync(file); } catch { return path.resolve(path.dirname(file), fsImpl.readlinkSync(file)); }
 }
 
 /** Write a JSON document atomically, keeping the existing file's permission bits: an MCP file kept
  * private for its tokens stays so. Creates missing directories; never deletes a file. */
-function writeMcpJson(file: string, doc: any, { fsImpl = fs }: { fsImpl?: any } = {}): string {
+function writeMcpJson(file        , doc     , { fsImpl = fs }                   = {})         {
   const dest = writePath(file, fsImpl);
   fsImpl.mkdirSync(path.dirname(dest), { recursive: true });
   const mode = fsImpl.existsSync(dest) ? fsImpl.statSync(dest).mode & 0o7777 : null;
@@ -303,14 +303,14 @@ function writeMcpJson(file: string, doc: any, { fsImpl = fs }: { fsImpl?: any }
  * every file's next document computed before the first write. An emptied container is kept as `{}`
  * or its member deleted, as the harness expects. Returns the number of files written.
  */
-function writeMcpEntries(changes: any[], { container, keepEmptyContainer = false, fsImpl = fs }: { container?: any, keepEmptyContainer?: boolean, fsImpl?: any } = {}): number {
-  const byFile = new Map<string, any[]>();
+function writeMcpEntries(changes       , { container, keepEmptyContainer = false, fsImpl = fs }                                                                  = {})         {
+  const byFile = new Map               ();
   for (const change of changes) {
     if (change.kind !== 'mcp-server' || change.release) continue;
     if (!byFile.has(change.target)) byFile.set(change.target, []);
-    byFile.get(change.target)!.push(change);
+    byFile.get(change.target) .push(change);
   }
-  const writes: [string, any][] = [];
+  const writes                  = [];
   for (const [file, group] of byFile) {
     const read = readMcpFile(file, container, { fsImpl });
     if (!read.ok) throw new Error(`MCP: ${file} changed after planning; nothing was written, re-run the command`);

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

@@ -16,15 +16,15 @@
 // https://opencode.ai/docs/rules
 const fs = require('node:fs');
 const path = require('node:path');
-const { planTree, applyTree, removeTree, verifyTree, copyTreeAssets, copyTreeDestDir, sharedTreeDestDir, ledgerFileResources, ledgerSiblingFingerprints, siblingReplacedNotices, fingerprint, readJson, sourceDirFor, resolveTransform } = require('../copy-tree.ts');
-const { readMcpFiles, planMcpEntries, verifyMcpEntries, ownedMcpIds, writeMcpEntries } = require('../mcp-entries.ts');
+const { planTree, applyTree, removeTree, verifyTree, copyTreeAssets, copyTreeDestDir, sharedTreeDestDir, ledgerFileResources, ledgerSiblingFingerprints, siblingReplacedNotices, fingerprint, readJson, sourceDirFor, resolveTransform } = require('../copy-tree.js');
+const { readMcpFiles, planMcpEntries, verifyMcpEntries, ownedMcpIds, writeMcpEntries } = require('../mcp-entries.js');
 
 // Only the marker constants: marker-merge.js reads and writes files itself, which cannot be used
 // from plan(), whose contract is to compute changes without touching disk. The gemini adapter
 // solves this the same way, with a pure managedInstruction() over strings.
-const { MARKER_START, MARKER_END } = require('../../helper/marker-merge.ts');
-const { destructiveCommandGlobs } = require('../../helper/guardrails.ts');
-const { declaredHarnessPaths, resolveHarnessPaths } = require('../../helper/harness-paths.ts');
+const { MARKER_START, MARKER_END } = require('../../helper/marker-merge.js');
+const { destructiveCommandGlobs } = require('../../helper/guardrails.js');
+const { declaredHarnessPaths, resolveHarnessPaths } = require('../../helper/harness-paths.js');
 
 const HARNESS = 'opencode';
 /**
@@ -48,7 +48,7 @@ const MCP_RENDERER = 'opencode-mcp';
  * historical shape.
  */
 function createOpenCodeAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS] } = {}) {
-  function nativePaths({ scope, scopeRoot, homeDir }: any) {
+  function nativePaths({ scope, scopeRoot, homeDir }     ) {
     return resolveHarnessPaths(declaredPaths, { scope, scopeRoot, homeDir });
   }
 
@@ -57,20 +57,20 @@ function createOpenCodeAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
    * `opencode.json` are read from the repo root, but the skills tree is namespaced under
    * `.opencode/` per design.md's native-surfaces table. Global scope has no such split —
    * `~/.config/opencode` already IS the skills root. Declared as `treeRoot` in harnesses.json. */
-  function copyTreeConfigDir(paths: any) {
+  function copyTreeConfigDir(paths     ) {
     return paths.treeRoot;
   }
 
   /** Agents live under `.opencode/agents/` at project scope and `~/.config/opencode/agents/`
    * globally — a different root from the skills tree in both scopes, so they get their own
    * destination resolution rather than reusing copyTreeConfigDir. Declared as `agentsDirectory`. */
-  function agentsDestDir(paths: any) {
+  function agentsDestDir(paths     ) {
     return paths.agentsDirectory;
   }
 
   /** Discovery keeps opencode.json as plan read it (`mcpSnapshot`), which verify compares against,
    * and reports the servers DoFlow owns in its `mcp` object now (`mcpOwned`). */
-  function discover({ scope, scopeRoot, mcp = [], mcpAdoptable = [], ledger, context = {}, fsImpl = fs }: any) {
+  function discover({ scope, scopeRoot, mcp = [], mcpAdoptable = [], ledger, context = {}, fsImpl = fs }     ) {
     const paths = nativePaths({ scope, scopeRoot, homeDir: context.homeDir });
     const instruction = fsImpl.existsSync(paths.instruction) ? fsImpl.readFileSync(paths.instruction, 'utf8') : null;
     const entries = mcpEntriesInput({ paths, mcp, mcpAdoptable, ledger });
@@ -81,7 +81,7 @@ function createOpenCodeAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
     return { paths, instruction, config: readJson(paths.config, { fsImpl }), mcpSnapshot, mcpOwned: ownedMcpIds({ ...entries, files: mcpSnapshot }), mcpConfigured };
   }
 
-  function render({ content = '' }: any = {}) {
+  function render({ content = '' }      = {}) {
     return `${MARKER_START}\n${String(content).trimEnd()}\n${MARKER_END}\n`;
   }
 
@@ -90,17 +90,17 @@ function createOpenCodeAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
    * every config it discovers — replacing would silently drop a user's own entries. Skills are
    * deliberately absent here: they are a materialised directory now, discovered natively, not a
    * registered path. The `mcp` object is left to the entry changes. */
-  function mergeConfig(existing: any) {
+  function mergeConfig(existing     ) {
     const next = { ...(existing || {}) };
-    const union = (current: any, add: any) => [...new Set([...(Array.isArray(current) ? current : []), ...add])];
+    const union = (current     , add     ) => [...new Set([...(Array.isArray(current) ? current : []), ...add])];
     next.instructions = union(next.instructions, [INSTRUCTION_FILE]);
     return next;
   }
 
   /** Remove only what mergeConfig added, leaving every user key and every unrelated array entry. */
-  function unmergeConfig(existing: any) {
+  function unmergeConfig(existing     ) {
     const next = { ...(existing || {}) };
-    const without = (current: any, drop: any) => (Array.isArray(current) ? current.filter((v) => !drop.includes(v)) : []);
+    const without = (current     , drop     ) => (Array.isArray(current) ? current.filter((v) => !drop.includes(v)) : []);
     next.instructions = without(next.instructions, [INSTRUCTION_FILE]);
     if (!next.instructions.length) delete next.instructions;
     return next;
@@ -116,12 +116,12 @@ function createOpenCodeAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
    * comment-free glob we can re-derive) are touched; a user's own bash rules survive untouched.
    * Entries are namespaced by value, not by key, so ownership is decided by re-deriving the list
    * from the single authored source rather than by trusting whatever happens to be present. */
-  function guardrailBashRules(context: any) {
+  function guardrailBashRules(context     ) {
     const globs = destructiveCommandGlobs({ repoRoot: context.repoRoot });
-    return Object.fromEntries(globs.map((glob: any) => [glob, 'deny']));
+    return Object.fromEntries(globs.map((glob     ) => [glob, 'deny']));
   }
 
-  function mergeGuardrails(existing: any, context: any) {
+  function mergeGuardrails(existing     , context     ) {
     const next = { ...(existing || {}) };
     const bash = { ...guardrailBashRules(context), ...((next.permission?.bash ?? {})) };
     // Keep user rules, but make sure ours win for identical globs (they are the stricter value).
@@ -129,7 +129,7 @@ function createOpenCodeAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
     return next;
   }
 
-  function stripGuardrails(existing: any, context: any) {
+  function stripGuardrails(existing     , context     ) {
     if (!existing?.permission?.bash) return existing;
     const ours = new Set(Object.keys(guardrailBashRules(context)));
     const bash = Object.fromEntries(Object.entries(existing.permission.bash).filter(([glob]) => !ours.has(glob)));
@@ -141,7 +141,7 @@ function createOpenCodeAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
     return rest;
   }
 
-  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);
@@ -153,7 +153,7 @@ function createOpenCodeAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
 
   /** Strip DoFlow's span, leaving the rest of a shared AGENTS.md intact. Returns null when there is
    * nothing to do, so remove() can skip the write entirely. */
-  function strippedInstruction(existing: any) {
+  function strippedInstruction(existing     ) {
     if (typeof existing !== 'string') return null;
     const start = existing.indexOf(MARKER_START);
     const end = existing.indexOf(MARKER_END);
@@ -168,11 +168,11 @@ function createOpenCodeAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
   /** `agents.shared` projects onto OpenCode through its own renderer name (its frontmatter is
    * transformed into OpenCode's markdown-agent vocabulary) but materialises with exactly the same
    * engine and change records as every other copy-tree asset. */
-  function opencodeTreeAssets(assets: any) {
-    return [...copyTreeAssets(assets), ...(assets || []).filter((asset: any) => asset.renderer === 'opencode-agents')];
+  function opencodeTreeAssets(assets     ) {
+    return [...copyTreeAssets(assets), ...(assets || []).filter((asset     ) => asset.renderer === 'opencode-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, homeDir: context.homeDir });
     const treeConfigDir = copyTreeConfigDir(paths);
     const changes = [];
@@ -190,10 +190,10 @@ function createOpenCodeAdapter({ 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,
@@ -209,7 +209,7 @@ function createOpenCodeAdapter({ 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) {
@@ -224,13 +224,13 @@ function createOpenCodeAdapter({ 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, homeDir: context.homeDir });
     const treeConfigDir = copyTreeConfigDir(paths);
     const statuses = [];
@@ -240,7 +240,7 @@ function createOpenCodeAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
       const destDir = asset.renderer === 'opencode-agents' ? agentsDestDir(paths) : sharedTreeDestDir(paths.root, asset.nativeDir) ?? copyTreeDestDir(treeConfigDir, asset);
       const sourceDir = sourceDirFor(asset, context, fsImpl, 'OpenCode');
       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}`,
@@ -259,45 +259,45 @@ function createOpenCodeAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
   /** OpenCode's settings-merge change has no asset of its own in core/registry/assets.json (it's a
    * registration side-effect of the instructions/mcp assets, not a projected asset), so it piggybacks
    * on a real asset id already routed to this harness — the same "pseudo-component" technique
-   * src/adapters/gemini/index.ts#hooksAssetId and src/adapters/kiro/index.ts#pseudoAssetId use. The
+   * src/adapters/gemini/index.js#hooksAssetId and src/adapters/kiro/index.js#pseudoAssetId use. The
    * lifecycle layer validates every change's assetId against the harness's actual asset list, so an
    * invented id like the literal string 'opencode.config' is rejected as unknown. */
-  function pseudoAssetId(assets: any) {
-    return assets.find((asset: any) => asset.capability === 'instructions')?.id ?? assets[0]?.id;
+  function pseudoAssetId(assets     ) {
+    return assets.find((asset     ) => asset.capability === 'instructions')?.id ?? assets[0]?.id;
   }
 
   // ---- MCP entries (opencode.json `mcp`) ----
 
   /** OpenCode's own server shape: a local server whose command and arguments form one array. */
-  function buildServerEntry(server: any) {
+  function buildServerEntry(server     ) {
     return { type: 'local', command: [server.command, ...(server.args || [])], enabled: true };
   }
 
-  function ownershipIdentity(id: any) { return `doflow:${HARNESS}:mcp-server:${id}`; }
+  function ownershipIdentity(id     ) { return `doflow:${HARNESS}:mcp-server:${id}`; }
 
   /** Everything the shared entry-ownership rules (../mcp-entries.ts) need from this adapter. */
-  function mcpEntriesInput({ paths, mcp = [], mcpAdoptable = [], ledger, assets = [] }: any) {
-    const rendered = (servers: any) => servers.map((server: any) => ({ id: server.id, entry: buildServerEntry(server) }));
-    const rows = (ledger?.resources || []).filter((row: any) => row.kind === 'mcp-server');
+  function mcpEntriesInput({ paths, mcp = [], mcpAdoptable = [], ledger, assets = [] }     ) {
+    const rendered = (servers     ) => servers.map((server     ) => ({ id: server.id, entry: buildServerEntry(server) }));
+    const rows = (ledger?.resources || []).filter((row     ) => row.kind === 'mcp-server');
     return {
       file: paths.config, selected: rendered(mcp), adoptable: rendered(mcpAdoptable),
-      ownRows: rows.filter((row: any) => row.harness === HARNESS).map((row: any) => ({
+      ownRows: rows.filter((row     ) => row.harness === HARNESS).map((row     ) => ({
         identity: row.identity, target: row.target, fingerprint: row.fingerprint ?? null, ownershipIdentity: row.ownershipIdentity, legacy: false,
       })),
-      foreignRows: rows.filter((row: any) => row.harness !== HARNESS).map((row: any) => ({ harness: row.harness, identity: row.identity, target: row.target })),
+      foreignRows: rows.filter((row     ) => row.harness !== HARNESS).map((row     ) => ({ harness: row.harness, identity: row.identity, target: row.target })),
       identityFor: ownershipIdentity, assetId: pseudoAssetId(assets), renderer: MCP_RENDERER, label: 'OpenCode MCP',
     };
   }
 
   /** opencode.json cannot be edited safely while removing: its registration row is released with
    * the entry rows, so the removal completes and leaves the file as it is. */
-  function releasedConfigRow({ assets, paths, ledger }: any) {
-    const owned = (ledger?.resources || []).some((row: any) => row.harness === HARNESS && row.ownershipIdentity === `${HARNESS}:config:registration` && row.target === paths.config);
+  function releasedConfigRow({ assets, paths, ledger }     ) {
+    const owned = (ledger?.resources || []).some((row     ) => row.harness === HARNESS && row.ownershipIdentity === `${HARNESS}:config:registration` && row.target === paths.config);
     return owned ? [{ assetId: pseudoAssetId(assets), target: paths.config, operation: 'remove', release: true,
       ownershipIdentity: `${HARNESS}:config:registration`, harness: HARNESS, projection: { renderer: 'opencode-config' } }] : [];
   }
 
-  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, context, fsImpl });
     const changes = [];
     const conflicts = [];
@@ -306,7 +306,7 @@ function createOpenCodeAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
     // below, under a fixed reason that never quotes the file.
     const configReadable = found.mcpSnapshot[found.paths.config].ok;
 
-    const guidance = assets.find((asset: any) => asset.capability === 'instructions');
+    const guidance = assets.find((asset     ) => asset.capability === 'instructions');
     if (guidance) {
       const rendered = render({ content: fsImpl.readFileSync(path.resolve(context.repoRoot, guidance.source), 'utf8') });
       const outcome = removing
@@ -333,7 +333,7 @@ function createOpenCodeAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
           // Tagged 'remove' during a remove operation (rather than always 'update'/'create') so this
           // adapter's own apply()/remove() dispatch — which routes strictly on `operation` — writes
           // the unmerged file during removal instead of silently skipping it (the same fix
-          // src/adapters/copilot/index.ts's analogous mcp-merge change already carries).
+          // src/adapters/copilot/index.js's analogous mcp-merge change already carries).
           operation: removing ? 'remove' : (found.config.exists ? 'update' : 'create'), content: `${JSON.stringify(next, null, 2)}\n`,
           ownershipIdentity: `${HARNESS}:config:registration`, fingerprint: fingerprint(next),
           harness: HARNESS, projection: { renderer: 'opencode-config' } });
@@ -355,14 +355,14 @@ function createOpenCodeAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
     return { changes, conflicts, notices: [...copyTree.notices, ...mcpPlan.notices], paths: found.paths };
   }
 
-  function writeChange(change: any, fsImpl: any) {
+  function writeChange(change     , fsImpl     ) {
     fsImpl.mkdirSync(path.dirname(change.target), { recursive: true });
     fsImpl.writeFileSync(change.target, change.content, 'utf8');
   }
 
   // The config change is written first; the entry changes then go to a fresh read of the same file,
   // so they apply on top of it.
-  function apply({ changes = [], fsImpl = fs }: any) {
+  function apply({ changes = [], fsImpl = fs }     ) {
     let applied = 0;
     for (const change of changes) {
       if (change.operation === 'remove') continue;
@@ -378,7 +378,7 @@ function createOpenCodeAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
     return { applied };
   }
 
-  function remove({ changes = [], fsImpl = fs }: any) {
+  function remove({ changes = [], fsImpl = fs }     ) {
     let removed = 0;
     for (const change of changes) {
       if (change.operation !== 'remove') continue;
@@ -392,13 +392,13 @@ function createOpenCodeAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
     return { removed };
   }
 
-  function verify({ scope, scopeRoot, assets = [], mcp = [], mcpAdoptable = [], discovery, ledger, operation, context = {}, fsImpl = fs }: any) {
+  function verify({ scope, scopeRoot, assets = [], mcp = [], mcpAdoptable = [], discovery, ledger, operation, context = {}, fsImpl = fs }     ) {
     const found = discover({ scope, scopeRoot, mcp, mcpAdoptable, ledger, context, fsImpl });
     const removing = (operation ?? context.operation) === 'remove';
     const statuses = [];
     const resources = [];
     const conflicts = [];
-    const instructionsAssetId = assets.find((asset: any) => asset.capability === 'instructions')?.id ?? pseudoAssetId(assets);
+    const instructionsAssetId = assets.find((asset     ) => asset.capability === 'instructions')?.id ?? pseudoAssetId(assets);
 
     const hasSection = typeof found.instruction === 'string'
       && found.instruction.includes(MARKER_START) && found.instruction.includes(MARKER_END);
@@ -445,7 +445,7 @@ function createOpenCodeAdapter({ declaredPaths = declaredHarnessPaths()[HARNESS]
 
     const copyTree = verifyCopyTreeAssets({ assets, scope, scopeRoot, context, fsImpl });
     resources.push(...copyTree.resources);
-    statuses.push(...copyTree.statuses.map((status: any) => ({ harness: HARNESS, ...status })));
+    statuses.push(...copyTree.statuses.map((status     ) => ({ harness: HARNESS, ...status })));
     conflicts.push(...copyTree.conflicts);
 
     return { ok: conflicts.length === 0 && !statuses.some((s) => s.status === 'invalid' || s.status === 'conflict'), resources, statuses, conflicts };