@claude-flow/cli 3.54.1 → 3.56.0

package/dist/src/parser.d.ts

@@ -94,6 +94,9 @@ export declare class CommandParser {
      * commit message.)
      */
     private getScopedBooleanFlags;
+    /** Resolve declared types from broad to narrow without borrowing string
+     * declarations from unrelated registered commands. */
+    private getFlagScope;
     private getBooleanFlags;
     private applyDefaults;
     validateFlags(flags: ParsedFlags, command?: Command): string[];

package/dist/src/parser.js

@@ -135,14 +135,27 @@ export class CommandParser {
         // with `daemon` left as a positional.
         let resolvedCmd;
         let resolvedSub;
+        const resolvedCommands = [];
         let sawFirstPositional = false;
-        for (const arg of args) {
-            if (arg.startsWith('-'))
+        for (let index = 0; index < args.length; index++) {
+            const arg = args[index];
+            if (arg === '--')
+                break;
+            if (arg.startsWith('-')) {
+                // Pass 2 recognizes only contiguous subcommands after the root.
+                if (sawFirstPositional)
+                    break;
+                // Skip consumed values as well as flags: a global option value is not
+                // the command slot, even when it happens to name another command.
+                const scope = this.getFlagScope(resolvedCommands);
+                index = this.parseFlag(args, index, scope.aliases, scope.booleanFlags, scope.stringFlags).nextIndex - 1;
                 continue;
+            }
             if (!sawFirstPositional) {
                 sawFirstPositional = true;
                 if (this.commands.has(arg)) {
                     resolvedCmd = this.commands.get(arg);
+                    resolvedCommands.push(resolvedCmd);
                     continue;
                 }
                 // Lazy command: we know its name but not its subcommands. Stop the
@@ -153,14 +166,21 @@ export class CommandParser {
                 // Unknown first positional — not a command. Stop walking.
                 break;
             }
-            if (resolvedCmd && !resolvedSub && resolvedCmd.subcommands) {
-                resolvedSub = resolvedCmd.subcommands.find(sc => sc.name === arg || sc.aliases?.includes(arg));
+            // Match the same supported command depth as Pass 2, with each option
+            // declaration taking precedence over its parent scope.
+            const parent = resolvedCommands[resolvedCommands.length - 1];
+            if (resolvedCommands.length < 4 && parent?.subcommands) {
+                const child = parent.subcommands.find(sc => sc.name === arg || sc.aliases?.includes(arg));
+                if (child) {
+                    resolvedCommands.push(child);
+                    resolvedSub ??= child;
+                    continue;
+                }
             }
+            // A positional that is not the next subcommand ends the command path.
+            break;
         }
-        // Pass 2: Build aliases scoped to the resolved subcommand
-        // Subcommand-specific aliases take priority over global ones
-        const aliases = this.buildScopedAliases(resolvedSub || resolvedCmd);
-        const booleanFlags = this.getScopedBooleanFlags(resolvedSub || resolvedCmd);
+        const { aliases, booleanFlags, stringFlags } = this.getFlagScope(resolvedCommands);
         let i = 0;
         let parsingFlags = true;
         while (i < args.length) {
@@ -173,7 +193,7 @@ export class CommandParser {
             }
             // Handle flags
             if (parsingFlags && arg.startsWith('-')) {
-                const parseResult = this.parseFlag(args, i, aliases, booleanFlags);
+                const parseResult = this.parseFlag(args, i, aliases, booleanFlags, stringFlags);
                 // Apply to result flags
                 Object.assign(result.flags, parseResult.flags);
                 i = parseResult.nextIndex;
@@ -231,7 +251,7 @@ export class CommandParser {
         this.applyDefaults(result.flags, resolvedCmd, resolvedSub);
         return result;
     }
-    parseFlag(args, index, aliases, booleanFlags) {
+    parseFlag(args, index, aliases, booleanFlags, stringFlags) {
         const flags = { _: [] };
         const arg = args[index];
         let nextIndex = index + 1;
@@ -242,7 +262,8 @@ export class CommandParser {
                 // --flag=value
                 const key = arg.slice(2, equalIndex);
                 const value = arg.slice(equalIndex + 1);
-                flags[this.normalizeKey(key)] = this.parseValue(value);
+                const normalizedKey = this.normalizeKey(key);
+                flags[normalizedKey] = stringFlags.has(normalizedKey) ? value : this.parseValue(value);
             }
             else if (arg.startsWith('--no-')) {
                 // --no-flag (boolean negation)
@@ -266,7 +287,7 @@ export class CommandParser {
                     }
                 }
                 else if (nextIndex < args.length && this.isFlagValue(args[nextIndex])) {
-                    flags[normalizedKey] = this.parseValue(args[nextIndex]);
+                    flags[normalizedKey] = stringFlags.has(normalizedKey) ? args[nextIndex] : this.parseValue(args[nextIndex]);
                     nextIndex++;
                 }
                 else {
@@ -293,7 +314,7 @@ export class CommandParser {
                     }
                 }
                 else if (nextIndex < args.length && this.isFlagValue(args[nextIndex])) {
-                    flags[normalizedKey] = this.parseValue(args[nextIndex]);
+                    flags[normalizedKey] = stringFlags.has(normalizedKey) ? args[nextIndex] : this.parseValue(args[nextIndex]);
                     nextIndex++;
                 }
                 else {
@@ -439,6 +460,36 @@ export class CommandParser {
         }
         return flags;
     }
+    /** Resolve declared types from broad to narrow without borrowing string
+     * declarations from unrelated registered commands. */
+    getFlagScope(commands) {
+        const aliases = this.buildScopedAliases(commands[commands.length - 1]);
+        const booleanFlags = this.getScopedBooleanFlags(commands[commands.length - 1]);
+        const stringFlags = new Set((this.options.stringFlags ?? []).map(flag => this.normalizeKey(flag)));
+        for (const command of commands) {
+            for (const option of command.options ?? []) {
+                if (option.short)
+                    aliases[option.short] = option.name;
+            }
+        }
+        const layers = [this.globalOptions, ...commands.map(command => command.options ?? [])];
+        for (const options of layers) {
+            for (const option of options) {
+                const key = this.normalizeKey(option.name);
+                if (option.type === 'string')
+                    stringFlags.add(key);
+                else if (option.type)
+                    stringFlags.delete(key);
+                if (option.type === 'boolean')
+                    booleanFlags.add(key);
+                else if (option.type)
+                    booleanFlags.delete(key);
+            }
+        }
+        for (const flag of stringFlags)
+            booleanFlags.delete(flag);
+        return { aliases, booleanFlags, stringFlags };
+    }
     getBooleanFlags() {
         const flags = new Set();
         for (const opt of this.globalOptions) {
@@ -517,6 +568,13 @@ export class CommandParser {
             if (opt.required && (flags[key] === undefined || flags[key] === '')) {
                 errors.push(`Required option missing: --${opt.name}`);
             }
+            // A value-taking option given with nothing after it (`--task`, `--key` at the end, or
+            // followed by another flag) is parsed as boolean `true`. Commands then treat `true` as
+            // the value: `hooks route --task` crashed with "task.trim is not a function" and
+            // `memory retrieve --key` looked up the key "true". Report it instead.
+            if ((opt.type === 'string' || opt.type === 'number') && flags[key] === true) {
+                errors.push(`Option --${opt.name} needs a value`);
+            }
             // Check choices
             if (opt.choices && flags[key] !== undefined) {
                 const value = String(flags[key]);

package/dist/src/plugins/store/discovery.d.ts

@@ -32,6 +32,12 @@ export interface PluginDiscoveryResult {
     source?: string;
     fromCache?: boolean;
     error?: string;
+    /**
+     * True when the signed registry could not be fetched or verified and the CLI fell back to
+     * its built-in plugin list. That list is safe to use (fixed, first-party npm names), but it
+     * is NOT the verified registry, and callers must say so rather than report a discovery.
+     */
+    demo?: boolean;
 }
 /**
  * Plugin Discovery Service

package/dist/src/plugins/store/discovery.js

@@ -3,7 +3,6 @@
  * Discovers plugin registries via IPNS and fetches from IPFS
  * Parallel implementation to pattern store for plugins
  */
-import * as crypto from 'crypto';
 import { resolveIPNS, fetchFromIPFS, verifyEd25519Signature } from '../../transfer/ipfs/client.js';
 /**
  * Fetch real npm download stats for a package
@@ -115,7 +114,9 @@ export class PluginDiscoveryService {
                 success: true,
                 registry: cached.registry,
                 fromCache: true,
-                source: registry.name,
+                // A cached fallback is still the fallback: never relabel it as the real registry.
+                source: cached.demo ? `${registry.name} (demo)` : registry.name,
+                ...(cached.demo ? { demo: true } : {}),
             };
         }
         try {
@@ -223,13 +224,16 @@ export class PluginDiscoveryService {
         this.cache.set(registry.ipnsName, {
             registry: demoRegistry,
             timestamp: Date.now(),
+            demo: true,
         });
         return {
             success: true,
             registry: demoRegistry,
-            cid: `bafybeiplugin${crypto.randomBytes(16).toString('hex')}`,
+            // No CID: the built-in list was not fetched from IPFS. (This used to be a random
+            // `bafybeiplugin…` string, printed as "Registry CID" as if it were a real address.)
             source: `${registry.name} (demo)`,
             fromCache: false,
+            demo: true,
         };
     }
     /**

package/dist/src/production/retry.js

@@ -116,7 +116,7 @@ export async function withRetry(fn, config = {}, strategy = 'exponential') {
             };
         }
         catch (error) {
-            lastError = error;
+            lastError = error instanceof Error ? error : new Error(String(error));
             // Check if we should retry
             if (!shouldRetryError(lastError, attempt, finalConfig)) {
                 return {

package/dist/src/ruvector/neural-router.js

@@ -288,8 +288,13 @@ async function resolveBackend(cfg) {
                     return r;
                 return {
                     route: (e) => {
-                        const result = r.route(e);
-                        return { ...result, predictedQuality: cal.transform(result.predictedQuality) };
+                        // Calibration can move a candidate across the quality bar. Select
+                        // from the calibrated predictions, not the raw router's old pick.
+                        const all = r.predictAll(e).map(c => ({ ...c, predictedQuality: cal.transform(c.predictedQuality) }));
+                        const clearing = all.filter(c => c.predictedQuality >= cfg.qualityBar)
+                            .sort((a, b) => a.costPerMTok - b.costPerMTok);
+                        const pick = clearing[0] ?? [...all].sort((a, b) => b.predictedQuality - a.predictedQuality)[0];
+                        return { ...pick, metBar: pick.predictedQuality >= cfg.qualityBar };
                     },
                     predictAll: (e) => r.predictAll(e).map(c => ({ ...c, predictedQuality: cal.transform(c.predictedQuality) })),
                 };

package/dist/src/services/bounded-worker-pool.js

@@ -20,6 +20,9 @@ export async function runBoundedPool(tasks, options) {
     const controller = new AbortController();
     const onAbort = () => controller.abort(options.signal?.reason ?? new Error('cancelled'));
     options.signal?.addEventListener('abort', onAbort, { once: true });
+    // Abort events are not replayed for signals cancelled before registration.
+    if (options.signal?.aborted)
+        onAbort();
     const timer = options.timeoutMs && options.timeoutMs > 0
         ? setTimeout(() => controller.abort(new Error('worker-pool-timeout')), options.timeoutMs)
         : undefined;

package/dist/src/services/claim-service.js

@@ -16,6 +16,7 @@ import { EventEmitter } from 'events';
 import * as fs from 'fs';
 import * as path from 'path';
 import { execFileSync } from 'child_process';
+import { readClaimsStore } from './claims-store.js';
 // ============================================================================
 // Default Configuration
 // ============================================================================
@@ -57,28 +58,29 @@ export class ClaimService extends EventEmitter {
         // Load existing claims
         await this.loadClaims();
     }
-    async loadClaims() {
-        const claimsFile = path.join(this.storagePath, 'claims.json');
-        if (fs.existsSync(claimsFile)) {
-            try {
-                const data = JSON.parse(fs.readFileSync(claimsFile, 'utf-8'));
-                for (const claim of data.claims || []) {
-                    claim.claimedAt = new Date(claim.claimedAt);
-                    claim.statusChangedAt = new Date(claim.statusChangedAt);
-                    if (claim.expiresAt)
-                        claim.expiresAt = new Date(claim.expiresAt);
-                    this.claims.set(claim.issueId, claim);
-                }
-            }
-            catch {
-                // Start fresh if file is corrupted
-            }
+    loadClaims() {
+        const data = readClaimsStore(path.join(this.storagePath, 'claims.json'));
+        const claims = new Map();
+        const stealable = new Map();
+        for (const claim of Object.values(data.claims)) {
+            claim.claimedAt = new Date(claim.claimedAt);
+            claim.statusChangedAt = new Date(claim.statusChangedAt);
+            if (claim.expiresAt)
+                claim.expiresAt = new Date(claim.expiresAt);
+            claims.set(claim.issueId, claim);
+        }
+        for (const [id, info] of Object.entries(data.stealable)) {
+            stealable.set(id, { ...info, stealableAt: new Date(info.stealableAt) });
         }
+        this.claims = claims;
+        this.stealableInfo = stealable;
     }
     async saveClaims() {
         const claimsFile = path.join(this.storagePath, 'claims.json');
         const data = {
-            claims: Array.from(this.claims.values()),
+            ...readClaimsStore(claimsFile),
+            claims: Object.fromEntries(this.claims),
+            stealable: Object.fromEntries(this.stealableInfo),
             savedAt: new Date().toISOString(),
         };
         fs.writeFileSync(claimsFile, JSON.stringify(data, null, 2));
@@ -87,6 +89,7 @@ export class ClaimService extends EventEmitter {
     // Core Claiming
     // ==========================================================================
     async claim(issueId, claimant) {
+        this.loadClaims();
         // Check if already claimed
         const existing = this.claims.get(issueId);
         if (existing && existing.status !== 'stealable') {
@@ -116,6 +119,7 @@ export class ClaimService extends EventEmitter {
         return { success: true, claim };
     }
     async release(issueId, claimant) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim) {
             throw new Error(`Issue ${issueId} is not claimed`);
@@ -137,6 +141,7 @@ export class ClaimService extends EventEmitter {
     // Handoffs
     // ==========================================================================
     async requestHandoff(issueId, from, to, reason) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim) {
             throw new Error(`Issue ${issueId} is not claimed`);
@@ -158,6 +163,7 @@ export class ClaimService extends EventEmitter {
         });
     }
     async acceptHandoff(issueId, claimant) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim || claim.status !== 'handoff-pending') {
             throw new Error(`No pending handoff for issue ${issueId}`);
@@ -181,6 +187,7 @@ export class ClaimService extends EventEmitter {
         });
     }
     async rejectHandoff(issueId, claimant, reason) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim || claim.status !== 'handoff-pending') {
             throw new Error(`No pending handoff for issue ${issueId}`);
@@ -205,6 +212,7 @@ export class ClaimService extends EventEmitter {
     // Status Updates
     // ==========================================================================
     async updateStatus(issueId, status, note) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim) {
             throw new Error(`Issue ${issueId} is not claimed`);
@@ -227,6 +235,7 @@ export class ClaimService extends EventEmitter {
         });
     }
     async updateProgress(issueId, progress) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim) {
             throw new Error(`Issue ${issueId} is not claimed`);
@@ -235,6 +244,7 @@ export class ClaimService extends EventEmitter {
         await this.saveClaims();
     }
     async requestReview(issueId, reviewers) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim) {
             throw new Error(`Issue ${issueId} is not claimed`);
@@ -254,6 +264,7 @@ export class ClaimService extends EventEmitter {
     // Work Stealing
     // ==========================================================================
     async markStealable(issueId, info) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim) {
             throw new Error(`Issue ${issueId} is not claimed`);
@@ -273,6 +284,7 @@ export class ClaimService extends EventEmitter {
         });
     }
     async steal(issueId, stealer) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim) {
             return { success: false, error: `Issue ${issueId} is not claimed` };
@@ -309,6 +321,7 @@ export class ClaimService extends EventEmitter {
         return { success: true, claim, previousOwner, context: info };
     }
     async getStealable(agentType) {
+        this.loadClaims();
         const stealable = [];
         for (const claim of this.claims.values()) {
             if (claim.status !== 'stealable')
@@ -323,6 +336,7 @@ export class ClaimService extends EventEmitter {
         return stealable;
     }
     async contestSteal(issueId, originalClaimant, reason) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim) {
             throw new Error(`Issue ${issueId} is not claimed`);
@@ -340,6 +354,7 @@ export class ClaimService extends EventEmitter {
     // Load Balancing
     // ==========================================================================
     async getAgentLoad(agentId) {
+        this.loadClaims();
         const claims = [];
         let blockedCount = 0;
         for (const claim of this.claims.values()) {
@@ -362,6 +377,7 @@ export class ClaimService extends EventEmitter {
         };
     }
     async rebalance(swarmId) {
+        this.loadClaims();
         const result = { moved: [], suggested: [] };
         // Get all agent loads
         const agentLoads = new Map();
@@ -410,6 +426,7 @@ export class ClaimService extends EventEmitter {
     // Queries
     // ==========================================================================
     async getClaimedBy(claimant) {
+        this.loadClaims();
         return Array.from(this.claims.values()).filter(c => this.isSameClaimant(c.claimant, claimant));
     }
     async getAvailableIssues(_filters) {
@@ -418,18 +435,22 @@ export class ClaimService extends EventEmitter {
         return [];
     }
     async getIssueStatus(issueId) {
+        this.loadClaims();
         return this.claims.get(issueId) || null;
     }
     async getAllClaims() {
+        this.loadClaims();
         return Array.from(this.claims.values());
     }
     async getByStatus(status) {
+        this.loadClaims();
         return Array.from(this.claims.values()).filter(c => c.status === status);
     }
     // ==========================================================================
     // Auto-Management
     // ==========================================================================
     async expireStale(maxAgeMinutes) {
+        this.loadClaims();
         const threshold = maxAgeMinutes ?? this.config.staleThresholdMinutes;
         const now = Date.now();
         const expired = [];
@@ -445,7 +466,7 @@ export class ClaimService extends EventEmitter {
                     progress: claim.progress,
                     context: `Stale: No activity for ${Math.round(age)} minutes`,
                 });
-                expired.push(claim);
+                expired.push(this.claims.get(claim.issueId));
             }
         }
         return expired;

package/dist/src/services/claims-store.d.ts

@@ -0,0 +1,3 @@
+/** Read legacy CLI arrays and MCP dictionaries; never replace unreadable state. */
+export declare function readClaimsStore(file: string): Record<string, unknown>;
+//# sourceMappingURL=claims-store.d.ts.map

package/dist/src/services/claims-store.js

@@ -0,0 +1,40 @@
+/** Shared on-disk shape for the CLI claim service and public MCP claim tools. */
+import { readFileSync } from 'node:fs';
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/** Read legacy CLI arrays and MCP dictionaries; never replace unreadable state. */
+export function readClaimsStore(file) {
+    let text;
+    try {
+        text = readFileSync(file, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { claims: {}, stealable: {}, contests: {} };
+        throw error;
+    }
+    const data = JSON.parse(text);
+    if (!record(data) || (!Array.isArray(data.claims) && !record(data.claims))) {
+        throw new Error('Invalid claims store: expected a claims array or object');
+    }
+    const entries = Array.isArray(data.claims)
+        ? data.claims.map((claim) => [record(claim) ? claim.issueId : undefined, claim])
+        : Object.entries(data.claims);
+    const claims = Object.create(null);
+    for (const [id, claim] of entries) {
+        if (typeof id !== 'string' || !id || !record(claim) || claim.issueId !== id ||
+            !record(claim.claimant) || typeof claim.status !== 'string' ||
+            typeof claim.claimedAt !== 'string' || typeof claim.statusChangedAt !== 'string' ||
+            Object.hasOwn(claims, id)) {
+            throw new Error('Invalid claims store: malformed or duplicate claim');
+        }
+        claims[id] = claim;
+    }
+    for (const key of ['stealable', 'contests']) {
+        if (data[key] !== undefined && !record(data[key]))
+            throw new Error(`Invalid claims store: ${key} must be an object`);
+    }
+    return { ...data, claims, stealable: data.stealable ?? {}, contests: data.contests ?? {} };
+}
+//# sourceMappingURL=claims-store.js.map

package/dist/src/services/config-file-manager.d.ts

@@ -3,6 +3,7 @@
  * Shared JSON config file persistence with atomic writes and Zod validation
  */
 export declare class ConfigFileManager {
+    private configCwd;
     private configPath;
     private config;
     /** Find config file in search paths starting from cwd */
@@ -27,6 +28,8 @@ export declare class ConfigFileManager {
     getConfigPath(): string | null;
     /** Get default config */
     getDefaults(): Record<string, unknown>;
+    /** Cached values and file paths belong to one resolved project directory. */
+    private selectProject;
     /** Atomic write: write to .tmp then rename */
     private writeAtomic;
 }

package/dist/src/services/config-file-manager.js

@@ -54,6 +54,7 @@ const DEFAULT_CONFIG = {
     },
 };
 export class ConfigFileManager {
+    configCwd = null;
     configPath = null;
     config = null;
     /** Find config file in search paths starting from cwd */
@@ -73,6 +74,7 @@ export class ConfigFileManager {
     }
     /** Load config from file, returns null if not found */
     load(cwd) {
+        this.selectProject(cwd);
         this.configPath = this.findConfig(cwd);
         if (!this.configPath) {
             this.config = null;
@@ -101,10 +103,11 @@ export class ConfigFileManager {
     }
     /** Get the current config, loading if needed */
     getConfig(cwd) {
+        this.selectProject(cwd);
         if (this.config === null) {
             this.load(cwd);
         }
-        return this.config ?? { ...DEFAULT_CONFIG };
+        return this.config ?? structuredClone(DEFAULT_CONFIG);
     }
     /** Get a nested config value by dot-separated key */
     get(cwd, key) {
@@ -117,6 +120,7 @@ export class ConfigFileManager {
         if (key.split('.').some(part => part === '__proto__' || part === 'constructor' || part === 'prototype')) {
             throw new Error(`Unsafe configuration key: ${key}`);
         }
+        this.selectProject(cwd);
         // A targeted update must not persist unrelated defaults (notably the
         // default memory path, which would relocate an existing memory store).
         const config = this.config ?? this.load(cwd) ?? {};
@@ -137,17 +141,20 @@ export class ConfigFileManager {
         if (fs.existsSync(targetPath) && !force) {
             throw new Error(`Config file already exists: ${targetPath}. Use --force to overwrite.`);
         }
-        const config = { ...DEFAULT_CONFIG, ...overrides };
+        const config = { ...structuredClone(DEFAULT_CONFIG), ...overrides };
         this.writeAtomic(targetPath, config);
+        this.selectProject(cwd);
         this.config = config;
         this.configPath = targetPath;
         return targetPath;
     }
     /** Reset config to defaults */
     reset(cwd) {
-        const targetPath = this.configPath ?? path.resolve(cwd, CONFIG_FILENAMES[0]);
-        this.writeAtomic(targetPath, DEFAULT_CONFIG);
-        this.config = { ...DEFAULT_CONFIG };
+        this.selectProject(cwd);
+        const targetPath = this.findConfig(cwd) ?? path.resolve(cwd, CONFIG_FILENAMES[0]);
+        const config = structuredClone(DEFAULT_CONFIG);
+        this.writeAtomic(targetPath, config);
+        this.config = config;
         this.configPath = targetPath;
         return targetPath;
     }
@@ -174,7 +181,8 @@ export class ConfigFileManager {
         if (typeof imported !== 'object' || imported === null || Array.isArray(imported)) {
             throw new Error('Import file must contain a JSON object');
         }
-        const targetPath = this.configPath ?? path.resolve(cwd, CONFIG_FILENAMES[0]);
+        this.selectProject(cwd);
+        const targetPath = this.findConfig(cwd) ?? path.resolve(cwd, CONFIG_FILENAMES[0]);
         this.writeAtomic(targetPath, imported);
         this.config = imported;
         this.configPath = targetPath;
@@ -185,7 +193,16 @@ export class ConfigFileManager {
     }
     /** Get default config */
     getDefaults() {
-        return { ...DEFAULT_CONFIG };
+        return structuredClone(DEFAULT_CONFIG);
+    }
+    /** Cached values and file paths belong to one resolved project directory. */
+    selectProject(cwd) {
+        const resolved = path.resolve(cwd);
+        if (this.configCwd !== resolved) {
+            this.configCwd = resolved;
+            this.config = null;
+            this.configPath = null;
+        }
     }
     /** Atomic write: write to .tmp then rename */
     writeAtomic(filePath, data) {

package/dist/src/services/distill-tuning.js

@@ -43,6 +43,7 @@ import * as crypto from 'crypto';
 import { runDistillation } from './memory-distillation.js';
 import { distillTrajectoryContent } from '../memory/structured-distill.js';
 import { cosineSim } from '../memory/hybrid-retrieval.js';
+import { loadBetterSqlite3 } from '../memory/shared-sqlite.js';
 // ── Grid defaults (requirement 1) ───────────────────────────────────────
 export const DEFAULT_GRID_BATCH_SIZE = [100, 200, 500];
 export const DEFAULT_GRID_DEDUP_DISTANCE = [0.05, 0.1, 0.15, 0.2, 0.3];
@@ -71,7 +72,22 @@ export async function tuneDistillation(options) {
     if (!dbPath || !fs.existsSync(dbPath)) {
         throw new Error(`tuneDistillation: source db not found at ${dbPath}`);
     }
-    const Database = await loadBetterSqlite3();
+    // #3883 — resolve the SAME better-sqlite3 copy AgentDB resolves (shared-sqlite.ts),
+    // not a separately-imported copy. Verified: every `new Database(...)` call in this
+    // module (readCopy below, and tmpCopy inside evaluateCandidate) opens a temp file
+    // copy made via fs.copyFileSync — `dbPath`/`sourceDbPath` themselves are NEVER
+    // opened with a DB connection anywhere in this module (see module header
+    // "Isolation" section). So the #3693 identity hazard (two better-sqlite3 copies
+    // fighting over one live file's -wal/-shm sidecars) does not apply to today's
+    // call sites here — AgentDB never holds a live handle on a temp copy. This swap
+    // is for consistency with the shared loader's contract, not an active fix.
+    let Database;
+    try {
+        Database = await loadBetterSqlite3();
+    }
+    catch {
+        Database = null;
+    }
     if (!Database) {
         throw new Error('tuneDistillation: better-sqlite3 unavailable — cannot run the tuning harness');
     }
@@ -498,13 +514,4 @@ function safeUnlink(p) {
         }
     }
 }
-async function loadBetterSqlite3() {
-    try {
-        const mod = 'better-sqlite3';
-        return (await import(mod)).default;
-    }
-    catch {
-        return null;
-    }
-}
 //# sourceMappingURL=distill-tuning.js.map