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

package/src/runtime/{worktree.ts → worktree.js}

@@ -52,69 +52,69 @@ const SANDBOX_SKILLS_DIR = path.join('.claude', 'skills');
 /** Source of truth for skill content, relative to the repo root. */
 const SOURCE_SKILLS_DIR = path.join('core', 'shared', 'skills');
 
-function sha256File(file: string): string {
+function sha256File(file        )         {
   return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
 }
 
-function git(args: string[], cwd: string, { allowFailure = false }: { allowFailure?: boolean } = {}): { ok: boolean; stdout: string; stderr?: string } {
+function git(args          , cwd        , { allowFailure = false }                             = {})                                                   {
   try {
     return {
       ok: true,
       stdout: execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }),
     };
-  } catch (err: any) {
+  } catch (err     ) {
     if (!allowFailure) throw err;
     return { ok: false, stdout: '', stderr: err.stderr ? String(err.stderr) : String(err.message) };
   }
 }
 
 class WorktreeManager {
-  repoRoot: string;
-  worktreesDir: string;
+  repoRoot        ;
+  worktreesDir        ;
 
   /**
    * @param {string} repoRoot repository whose worktrees are managed
    * @param {string} [worktreesDir] override the sandbox root; defaults to `<repo>/.doflow/worktrees`,
    *   which is gitignored so sandboxes never appear as untracked noise in the parent tree.
    */
-  constructor(repoRoot: string, worktreesDir?: string) {
+  constructor(repoRoot        , worktreesDir         ) {
     this.repoRoot = repoRoot;
     this.worktreesDir = worktreesDir || path.join(repoRoot, '.doflow', 'worktrees');
   }
 
-  static assertSafeId(taskId: any): void {
+  static assertSafeId(taskId     )       {
     if (!taskId || !SAFE_ID.test(taskId)) {
       throw new Error(`unsafe worktree id ${JSON.stringify(taskId)} — allowed: letters, digits, dot, dash, underscore`);
     }
   }
 
-  pathFor(taskId: string): string {
+  pathFor(taskId        )         {
     WorktreeManager.assertSafeId(taskId);
     return path.join(this.worktreesDir, taskId);
   }
 
-  branchFor(taskId: string): string {
+  branchFor(taskId        )         {
     WorktreeManager.assertSafeId(taskId);
     return `task/${taskId}`;
   }
 
   /** Whether git itself considers this path a registered worktree — the directory existing on disk
    * is not the same question, which is the bug fixed here. */
-  isRegistered(wtPath: string): boolean {
+  isRegistered(wtPath        )          {
     const res = git(['worktree', 'list', '--porcelain'], this.repoRoot, { allowFailure: true });
     if (!res.ok) return false;
     const resolved = path.resolve(wtPath);
     return res.stdout
       .split('\n')
-      .filter((l: string) => l.startsWith('worktree '))
-      .some((l: string) => path.resolve(l.slice('worktree '.length).trim()) === resolved);
+      .filter((l        ) => l.startsWith('worktree '))
+      .some((l        ) => path.resolve(l.slice('worktree '.length).trim()) === resolved);
   }
 
   /**
    * Create an isolated worktree, reusing it only when git agrees it is registered. Returns the
    * absolute path.
    */
-  create(taskId: string, baseRef: string = 'HEAD'): string {
+  create(taskId        , baseRef         = 'HEAD')         {
     const wtPath = this.pathFor(taskId);
     const branch = this.branchFor(taskId);
 
@@ -142,7 +142,7 @@ class WorktreeManager {
   }
 
   /** The resolved base SHA recorded at creation, or null when unavailable. */
-  baseOf(taskId: string): string | null {
+  baseOf(taskId        )                {
     const file = path.join(this.pathFor(taskId), BASE_FILE);
     return fs.existsSync(file) ? fs.readFileSync(file, 'utf8').trim() : null;
   }
@@ -172,7 +172,7 @@ class WorktreeManager {
    *
    * @returns {object} the manifest also written to `<worktree>/.doflow-skill-source.json`
    */
-  projectSkills(taskId: string, { harness = 'claude', cli = path.join('bin', 'doflow.js'), skillsRoot = SOURCE_SKILLS_DIR }: { harness?: string; cli?: string; skillsRoot?: string } = {}): any {
+  projectSkills(taskId        , { harness = 'claude', cli = path.join('bin', 'doflow.js'), skillsRoot = SOURCE_SKILLS_DIR }                                                          = {})      {
     const wtPath = this.pathFor(taskId);
     if (!fs.existsSync(wtPath)) {
       throw new Error(`no worktree at ${wtPath} — create it before projecting skills`);
@@ -182,25 +182,25 @@ class WorktreeManager {
       throw new Error(`no skill source at ${sourceRoot}`);
     }
 
-    let installOutput: string;
+    let installOutput        ;
     try {
       installOutput = execFileSync(
         process.execPath,
         [path.join(this.repoRoot, cli), 'install', wtPath, '--force', '-t', harness],
         { cwd: this.repoRoot, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] },
       );
-    } catch (err: any) {
+    } catch (err     ) {
       throw new Error(`projecting skills into ${wtPath} failed: ${err.stderr || err.message}`);
     }
 
     const names = fs
       .readdirSync(sourceRoot, { withFileTypes: true })
-      .filter((e: any) => e.isDirectory() && fs.existsSync(path.join(sourceRoot, e.name, 'SKILL.md')))
-      .map((e: any) => e.name)
+      .filter((e     ) => e.isDirectory() && fs.existsSync(path.join(sourceRoot, e.name, 'SKILL.md')))
+      .map((e     ) => e.name)
       .sort();
 
-    const skills: Record<string, any> = {};
-    const mismatches: string[] = [];
+    const skills                      = {};
+    const mismatches           = [];
     for (const name of names) {
       const rel = path.join(SANDBOX_SKILLS_DIR, name, 'SKILL.md');
       const dst = path.join(wtPath, rel);
@@ -237,7 +237,7 @@ class WorktreeManager {
   }
 
   /** The skill-source manifest a sandbox recorded, or null when it was never projected. */
-  skillSourceOf(taskId: string): any {
+  skillSourceOf(taskId        )      {
     const file = path.join(this.pathFor(taskId), SKILL_SOURCE_FILE);
     if (!fs.existsSync(file)) return null;
     try {
@@ -249,7 +249,7 @@ class WorktreeManager {
 
   /** Repo HEAD, or null outside a repository. Recorded for readability; the per-skill hashes are
    * the actual provenance, and they stay correct on a dirty tree where a commit id does not. */
-  headCommit(): string | null {
+  headCommit()                {
     const res = git(['rev-parse', 'HEAD'], this.repoRoot, { allowFailure: true });
     return res.ok ? res.stdout.trim() : null;
   }
@@ -259,13 +259,13 @@ class WorktreeManager {
    * skills. Split from `create()` because non-evaluation callers want a bare worktree and should
    * not pay for a projection they will not read.
    */
-  createSandbox(taskId: string, { baseRef = 'HEAD', ...opts }: { baseRef?: string; [key: string]: any } = {}): { path: string; manifest: any } {
+  createSandbox(taskId        , { baseRef = 'HEAD', ...opts }                                           = {})                                  {
     const wtPath = this.create(taskId, baseRef);
     return { path: wtPath, manifest: this.projectSkills(taskId, opts) };
   }
 
   /** Remove the worktree and its branch. Idempotent: removing something absent is success. */
-  remove(taskId: string): void {
+  remove(taskId        )       {
     const wtPath = this.pathFor(taskId);
     const branch = this.branchFor(taskId);
 
@@ -282,7 +282,7 @@ class WorktreeManager {
    * collapsing a failure into an empty diff, so a caller can tell "nothing changed" from
    * "could not tell", which the Python version could not.
    */
-  collectDiff(taskId: string, baseRef?: string): { diff: string | null; untracked: string[]; error: string | null | undefined } {
+  collectDiff(taskId        , baseRef         )                                                                                 {
     const wtPath = this.pathFor(taskId);
     if (!fs.existsSync(wtPath)) {
       return { diff: null, untracked: [], error: `no worktree at ${wtPath}` };
@@ -304,23 +304,23 @@ class WorktreeManager {
       // Harness bookkeeping is not task work: the base pointer and the skill-source manifest are
       // written by this module, not by the skill under test.
       untracked: untracked.ok
-        ? untracked.stdout.split('\n').filter((f: string) => f && f !== BASE_FILE && f !== SKILL_SOURCE_FILE)
+        ? untracked.stdout.split('\n').filter((f        ) => f && f !== BASE_FILE && f !== SKILL_SOURCE_FILE)
         : [],
       error: null,
     };
   }
 
   /** Every sandbox this manager knows about — used to clean up after an interrupted run. */
-  list(): string[] {
+  list()           {
     if (!fs.existsSync(this.worktreesDir)) return [];
     return fs
       .readdirSync(this.worktreesDir, { withFileTypes: true })
-      .filter((e: any) => e.isDirectory())
-      .map((e: any) => e.name);
+      .filter((e     ) => e.isDirectory())
+      .map((e     ) => e.name);
   }
 
   /** Run `fn(worktreePath)` in a fresh sandbox and always tear it down, even when `fn` throws. */
-  withWorktree(taskId: string, fn: (wtPath: string) => any, baseRef: string = 'HEAD'): any {
+  withWorktree(taskId        , fn                         , baseRef         = 'HEAD')      {
     const wtPath = this.create(taskId, baseRef);
     try {
       return fn(wtPath);

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

@@ -9,7 +9,7 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const crypto = require('node:crypto');
-const { manifestPath, readManifest } = require('../install/manifest.ts');
+const { manifestPath, readManifest } = require('../install/manifest.js');
 
 const STATE_VERSION = 1;
 // Ledger document version. v1 ledgers (no tombstones) remain readable forever; writers produce
@@ -18,32 +18,32 @@ const LEDGER_VERSION = 2;
 const LEDGER_FILE = 'ledger.json';
 const RECOVERY_DIR = 'recovery';
 
-function assertScope(scope: any): void {
+function assertScope(scope     )       {
   if (scope !== 'project' && scope !== 'global') throw new Error(`Invalid state scope: '${scope}'`);
 }
 
 /** Resolve DoFlow-owned state without deriving it from a harness directory. */
-function stateRoot({ scope, projectRoot = '.', homeDir = os.homedir() }: { scope: any, projectRoot?: string, homeDir?: string }): string {
+function stateRoot({ scope, projectRoot = '.', homeDir = os.homedir() }                                                        )         {
   assertScope(scope);
   return scope === 'project'
     ? path.join(path.resolve(projectRoot), '.doflow', 'state')
     : path.join(path.resolve(homeDir), '.doflow', 'state');
 }
 
-function ledgerPath(root: string): string { return path.join(root, LEDGER_FILE); }
-function recoveryRoot(root: string): string { return path.join(root, RECOVERY_DIR); }
+function ledgerPath(root        )         { return path.join(root, LEDGER_FILE); }
+function recoveryRoot(root        )         { return path.join(root, RECOVERY_DIR); }
 
-function stable(value: any): any {
+function stable(value     )      {
   if (Array.isArray(value)) return value.map(stable);
   if (!value || typeof value !== 'object') return value;
   return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stable(value[key])]));
 }
 
-function fingerprint(value: any): string {
+function fingerprint(value     )         {
   return crypto.createHash('sha256').update(JSON.stringify(stable(value))).digest('hex');
 }
 
-function atomicJsonWrite(file: string, value: any, { fsImpl = fs }: { fsImpl?: any } = {}): string {
+function atomicJsonWrite(file        , value     , { fsImpl = fs }                   = {})         {
   fsImpl.mkdirSync(path.dirname(file), { recursive: true });
   const tmp = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${Date.now()}.tmp`);
   try {
@@ -55,7 +55,7 @@ function atomicJsonWrite(file: string, value: any, { fsImpl = fs }: { fsImpl?: a
   return file;
 }
 
-function defaultLedger({ scope, scopeRoot }: { scope: any, scopeRoot: string }): any {
+function defaultLedger({ scope, scopeRoot }                                   )      {
   assertScope(scope);
   return {
     version: LEDGER_VERSION,
@@ -72,13 +72,13 @@ function defaultLedger({ scope, scopeRoot }: { scope: any, scopeRoot: string }):
 }
 
 /** Upgrade a v1 ledger in memory to the current shape without touching disk. Idempotent. */
-function upgradeLedger(ledger: any): any {
+function upgradeLedger(ledger     )      {
   if (!ledger || typeof ledger !== 'object') throw new Error('Invalid neutral ledger: expected object');
   if (ledger.version === LEDGER_VERSION) return ledger;
   return { ...ledger, version: LEDGER_VERSION, tombstones: Array.isArray(ledger.tombstones) ? ledger.tombstones : [] };
 }
 
-function validateLedger(value: any): any {
+function validateLedger(value     )      {
   if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('Invalid neutral ledger: expected object');
   if (![STATE_VERSION, LEDGER_VERSION].includes(value.version)) throw new Error(`Unsupported neutral ledger version: '${value.version}'`);
   if (value.version >= LEDGER_VERSION && value.tombstones !== undefined && !Array.isArray(value.tombstones)) {
@@ -91,30 +91,30 @@ function validateLedger(value: any): any {
   return value;
 }
 
-function readLedger(root: string, { fsImpl = fs }: { fsImpl?: any } = {}): any {
+function readLedger(root        , { fsImpl = fs }                   = {})      {
   const file = ledgerPath(root);
   if (!fsImpl.existsSync(file)) return null;
   try { return validateLedger(JSON.parse(fsImpl.readFileSync(file, 'utf8'))); }
-  catch (error: any) { throw new Error(`Cannot read neutral ledger '${file}': ${error.message}`); }
+  catch (error     ) { throw new Error(`Cannot read neutral ledger '${file}': ${error.message}`); }
 }
 
-function writeLedger(root: string, ledger: any, options: { fsImpl?: any } = {}): string {
+function writeLedger(root        , ledger     , options                   = {})         {
   return atomicJsonWrite(ledgerPath(root), validateLedger(ledger), options);
 }
 
-function recoveryId(now: Date = new Date()): string {
+function recoveryId(now       = new Date())         {
   return `recovery_${now.toISOString().replace(/[:.]/g, '-').replace(/Z$/, 'Z')}_${crypto.randomBytes(4).toString('hex')}`;
 }
 
-function assertSafeRecoveryId(id: any): void {
+function assertSafeRecoveryId(id     )       {
   if (typeof id !== 'string' || !/^recovery_[A-Za-z0-9_-]+$/.test(id)) throw new Error(`Invalid recovery id: '${id}'`);
 }
 
 /** Persist a journal record before native mutation; append-only records make interrupted runs observable. */
-function writeRecoveryRecord(root: string, record: any, { now = new Date(), fsImpl = fs }: { now?: Date, fsImpl?: any } = {}): { id: string, file: string, record: any } {
+function writeRecoveryRecord(root        , record     , { now = new Date(), fsImpl = fs }                               = {})                                            {
   const id = record?.id ?? recoveryId(now);
   assertSafeRecoveryId(id);
-  const value: any = {
+  const value      = {
     id,
     version: STATE_VERSION,
     status: record?.status ?? 'pending',
@@ -126,19 +126,19 @@ function writeRecoveryRecord(root: string, record: any, { now = new Date(), fsIm
   return { id, file: atomicJsonWrite(path.join(recoveryRoot(root), `${id}.json`), value, { fsImpl }), record: value };
 }
 
-function readRecoveryRecord(root: string, id: any, { fsImpl = fs }: { fsImpl?: any } = {}): any {
+function readRecoveryRecord(root        , id     , { fsImpl = fs }                   = {})      {
   assertSafeRecoveryId(id);
   const file = path.join(recoveryRoot(root), `${id}.json`);
   if (!fsImpl.existsSync(file)) return null;
   try { return JSON.parse(fsImpl.readFileSync(file, 'utf8')); }
-  catch (error: any) { throw new Error(`Cannot read recovery record '${file}': ${error.message}`); }
+  catch (error     ) { throw new Error(`Cannot read recovery record '${file}': ${error.message}`); }
 }
 
-function ownershipKey(record: any): string {
+function ownershipKey(record     )         {
   return [record.harness, record.scope, record.assetId, record.target, record.ownershipIdentity].join('\u0000');
 }
 
-function importLegacyResource(resource: any, scope: any): any {
+function importLegacyResource(resource     , scope     )      {
   if (!resource || typeof resource !== 'object') return null;
   if (typeof resource.target !== 'string' || typeof resource.kind !== 'string' || typeof resource.identity !== 'string') return null;
   return {
@@ -159,24 +159,24 @@ function importLegacyResource(resource: any, scope: any): any {
  * Read-compatible, conservative legacy import.  Only explicit `managed_resources` records are
  * converted to ownership claims; a legacy tool entry alone never authorizes adoption of files.
  */
-function migrateLegacyManifest({ root, scope, scopeRoot, claudeDir, now = new Date(), fsImpl = fs }: { root: string, scope: any, scopeRoot: string, claudeDir: string, now?: Date, fsImpl?: any }): any {
+function migrateLegacyManifest({ root, scope, scopeRoot, claudeDir, now = new Date(), fsImpl = fs }                                                                                              )      {
   assertScope(scope);
   const legacyFile = manifestPath(claudeDir);
   const current = readLedger(root, { fsImpl }) ?? defaultLedger({ scope, scopeRoot });
   if (current.scope !== scope || current.scopeRoot !== path.resolve(scopeRoot)) throw new Error('Neutral ledger scope does not match requested migration scope');
-  if (current.legacyImports.some((item: any) => item.path === legacyFile)) return { migrated: false, reason: 'already-imported', ledger: current, legacyFile };
+  if (current.legacyImports.some((item     ) => item.path === legacyFile)) return { migrated: false, reason: 'already-imported', ledger: current, legacyFile };
   if (!fsImpl.existsSync(legacyFile)) return { migrated: false, reason: 'legacy-missing', ledger: current, legacyFile };
 
   const legacy = readManifest(claudeDir);
   if (!legacy || legacy.operation === 'error') return { migrated: false, reason: 'legacy-invalid', ledger: current, legacyFile };
-  const resources = legacy.managedResources.map((resource: any) => importLegacyResource(resource, scope)).filter(Boolean);
+  const resources = legacy.managedResources.map((resource     ) => importLegacyResource(resource, scope)).filter(Boolean);
   const existing = new Set(current.resources.map(ownershipKey));
   for (const resource of resources) if (!existing.has(ownershipKey(resource))) current.resources.push(resource);
 
   // The legacy manifest's MCP selection was owned by Claude's config flow.  Do not infer an
   // equivalent selection for Codex or Gemini merely because they happened to share the old file.
   if (Array.isArray(legacy.mcpServers) && !Object.hasOwn(current.mcpSelections, 'claude')) current.mcpSelections.claude = [...legacy.mcpServers];
-  for (const [harness, status] of Object.entries(legacy.tools) as [string, any][]) {
+  for (const [harness, status] of Object.entries(legacy.tools)                   ) {
     if (status?.installed && !current.targets[harness]) current.targets[harness] = { installed: true, lastUpdated: status.last_updated ?? null, imported: true };
   }
   current.legacyImports.push({ path: legacyFile, importedAt: now.toISOString(), sourceFingerprint: fingerprint({ operation: legacy.operation, lastRun: legacy.lastRun, backupId: legacy.backupId, resources: legacy.managedResources }), lastBackupId: legacy.backupId });

package/src/state/{lockfile.ts → lockfile.js}

@@ -10,25 +10,25 @@
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
-const { atomicJsonWrite } = require('./index.ts');
+const { atomicJsonWrite } = require('./index.js');
 
 const LOCK_VERSION = 1;
 const LOCK_FILE = 'doflow.lock';
 
-function lockRoot({ scope, projectRoot = '.', homeDir = os.homedir() }: { scope: any, projectRoot?: string, homeDir?: string }): string {
+function lockRoot({ scope, projectRoot = '.', homeDir = os.homedir() }                                                        )         {
   if (scope !== 'project' && scope !== 'global') throw new Error(`Invalid lock scope: '${scope}'`);
   return scope === 'project' ? path.resolve(projectRoot) : path.resolve(homeDir);
 }
 
-function lockPath(options: any): string { return path.join(lockRoot(options), '.doflow', LOCK_FILE); }
+function lockPath(options     )         { return path.join(lockRoot(options), '.doflow', LOCK_FILE); }
 
-function stable(value: any): any {
-  if (Array.isArray(value)) return [...value].map(stable).sort((a: any, b: any) => JSON.stringify(a) < JSON.stringify(b) ? -1 : 1);
+function stable(value     )      {
+  if (Array.isArray(value)) return [...value].map(stable).sort((a     , b     ) => JSON.stringify(a) < JSON.stringify(b) ? -1 : 1);
   if (!value || typeof value !== 'object') return value;
   return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stable(value[key])]));
 }
 
-function defaultLock({ scope, scopeRoot }: { scope: any, scopeRoot: string }): any {
+function defaultLock({ scope, scopeRoot }                                   )      {
   if (scope !== 'project' && scope !== 'global') throw new Error(`Invalid lock scope: '${scope}'`);
   return {
     version: LOCK_VERSION,
@@ -42,7 +42,7 @@ function defaultLock({ scope, scopeRoot }: { scope: any, scopeRoot: string }): a
   };
 }
 
-function validateLock(value: any): any {
+function validateLock(value     )      {
   if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('Invalid doflow.lock: expected object');
   if (value.version !== LOCK_VERSION) throw new Error(`Unsupported doflow.lock version: '${value.version}'`);
   if (value.scope !== 'project' && value.scope !== 'global') throw new Error(`Invalid doflow.lock scope: '${value.scope}'`);
@@ -54,21 +54,21 @@ function validateLock(value: any): any {
     throw new Error('Invalid doflow.lock: mcpSelections must be an object');
   }
   for (const [harness, ids] of Object.entries(value.mcpSelections)) {
-    if (!Array.isArray(ids) || !ids.every((id: any) => typeof id === 'string')) {
+    if (!Array.isArray(ids) || !ids.every((id     ) => typeof id === 'string')) {
       throw new Error(`Invalid doflow.lock: mcpSelections.${harness} must be an array of server ids`);
     }
   }
   return value;
 }
 
-function readLock(options: any, { fsImpl = fs }: { fsImpl?: any } = {}): any {
+function readLock(options     , { fsImpl = fs }                   = {})      {
   const file = lockPath(options);
   if (!fsImpl.existsSync(file)) return null;
   try { return validateLock(JSON.parse(fsImpl.readFileSync(file, 'utf8'))); }
-  catch (error: any) { throw new Error(`Cannot read doflow.lock '${file}': ${error.message}`); }
+  catch (error     ) { throw new Error(`Cannot read doflow.lock '${file}': ${error.message}`); }
 }
 
-function writeLock(options: any, lock: any, { fsImpl = fs }: { fsImpl?: any } = {}): any {
+function writeLock(options     , lock     , { fsImpl = fs }                   = {})      {
   // Validate the caller's document first so a foreign version fails loudly here rather than
   // being silently normalized into something no future reader can distinguish.
   validateLock(lock);
@@ -77,23 +77,23 @@ function writeLock(options: any, lock: any, { fsImpl = fs }: { fsImpl?: any } =
 
 /** The lock's MCP rows for the harnesses it targets. A row naming a harness outside `targets` is
  * ignored by every reader; the next write drops it. */
-function pinnedSelections(lock: any): Record<string, any> {
-  const targets = new Set((lock?.targets ?? []).map((entry: any) => entry.harness));
+function pinnedSelections(lock     )                      {
+  const targets = new Set((lock?.targets ?? []).map((entry     ) => entry.harness));
   return Object.fromEntries(Object.entries(lock?.mcpSelections ?? {}).filter(([harness]) => targets.has(harness)));
 }
 
 /** Compare two lock documents. Arrays are keyed by identity (assets by id, targets by harness,
  * fallback to full JSON), mcpSelections by harness, where an absent row (`null`) and a recorded
  * empty selection (`[]`) differ. Returns {added, removed, changed} per section plus a clean flag. */
-function diffLocks(previousLock: any, nextLock: any): any {
+function diffLocks(previousLock     , nextLock     )      {
   // Compare in the order writeLock stores, so a document built in memory never differs from the
   // file it was written to.
   const previous = previousLock && stable(previousLock);
   const next = nextLock && stable(nextLock);
-  const key = (entry: any) => entry?.id ?? entry?.harness ?? JSON.stringify(entry);
-  const sectionDiff = (before: any, after: any) => {
-    const beforeKeys = new Map<string, any>((before || []).map((entry: any): [string, any] => [key(entry), entry]));
-    const afterKeys = new Map<string, any>((after || []).map((entry: any): [string, any] => [key(entry), entry]));
+  const key = (entry     ) => entry?.id ?? entry?.harness ?? JSON.stringify(entry);
+  const sectionDiff = (before     , after     ) => {
+    const beforeKeys = new Map             ((before || []).map((entry     )                => [key(entry), entry]));
+    const afterKeys = new Map             ((after || []).map((entry     )                => [key(entry), entry]));
     const added = [...afterKeys].filter(([k]) => !beforeKeys.has(k)).map(([, v]) => v);
     const removed = [...beforeKeys].filter(([k]) => !afterKeys.has(k)).map(([, v]) => v);
     const changed = [...afterKeys]
@@ -107,7 +107,7 @@ function diffLocks(previousLock: any, nextLock: any): any {
   const mcpChanged = [...harnesses]
     .filter((harness) => JSON.stringify(selectionsBefore[harness] ?? null) !== JSON.stringify(selectionsAfter[harness] ?? null))
     .map((harness) => ({ harness, before: selectionsBefore[harness] ?? null, after: selectionsAfter[harness] ?? null }));
-  const result: any = {
+  const result      = {
     targets: sectionDiff(previous?.targets, next?.targets),
     assets: sectionDiff(previous?.assets, next?.assets),
     mcpSelections: { changed: mcpChanged },
@@ -124,7 +124,7 @@ function diffLocks(previousLock: any, nextLock: any): any {
 }
 
 /** Delete the lock when nothing remains pinned. Returns true when a file actually went away. */
-function removeLock(options: any, { fsImpl = fs }: { fsImpl?: any } = {}): boolean {
+function removeLock(options     , { fsImpl = fs }                   = {})          {
   const file = lockPath(options);
   if (!fsImpl.existsSync(file)) return false;
   fsImpl.rmSync(file);