claude-flow 3.47.0 → 3.48.0

package/v3/@claude-flow/cli/dist/src/mcp-tools/hooks-tools.js

@@ -1,3 +1,4 @@
+import { feedbackPatternsSchema, validateFeedbackPatterns } from '../memory/feedback-patterns.js';
 /**
  * Hooks MCP Tools
  * Provides intelligent hooks functionality via MCP protocol
@@ -410,8 +411,75 @@ async function getLoRAAdapter() {
     }
     return loraAdapter;
 }
-// In-memory trajectory tracking (persisted on end)
+// Cache pending trajectories; the existing memory store also persists checkpoints.
 const activeTrajectories = new Map();
+const dirtyTrajectories = new Set();
+const trajectoryOperations = new Map();
+/** Serialize read/modify/checkpoint operations for a trajectory in this process. */
+async function withTrajectoryOperation(id, operation) {
+    const previous = trajectoryOperations.get(id) ?? Promise.resolve();
+    let release;
+    const gate = new Promise(resolve => { release = resolve; });
+    const current = previous.then(() => gate);
+    trajectoryOperations.set(id, current);
+    await previous;
+    try {
+        return await operation();
+    }
+    finally {
+        release();
+        if (trajectoryOperations.get(id) === current)
+            trajectoryOperations.delete(id);
+    }
+}
+async function persistPendingTrajectory(trajectory) {
+    dirtyTrajectories.add(trajectory.id);
+    try {
+        const store = await getRealStoreFunction();
+        const result = await store?.({
+            key: `trajectory-pending-${trajectory.id}`, value: JSON.stringify(trajectory),
+            namespace: 'trajectories', tags: [trajectory.agent, 'pending', 'sona-trajectory'], upsert: true,
+        });
+        if (result?.success === true)
+            dirtyTrajectories.delete(trajectory.id);
+        return result?.success === true;
+    }
+    catch {
+        return false;
+    }
+}
+async function loadPendingTrajectory(id) {
+    try {
+        const { getEntry } = await import('../memory/memory-initializer.js');
+        // A completed record is authoritative even if pending-record cleanup failed
+        // or another process still has an old cache entry.
+        const completed = await getEntry({ key: `trajectory-${id}`, namespace: 'trajectories' });
+        if (completed.success && completed.found) {
+            activeTrajectories.delete(id);
+            dirtyTrajectories.delete(id);
+            return undefined;
+        }
+        // Failed checkpoints must not erase already-acknowledged live steps.
+        // Clean caches still reload so another process's later checkpoint is seen.
+        if (dirtyTrajectories.has(id) && activeTrajectories.has(id))
+            return activeTrajectories.get(id);
+        const pending = await getEntry({ key: `trajectory-pending-${id}`, namespace: 'trajectories' });
+        if (pending.success && pending.found) {
+            const value = JSON.parse(pending.entry?.content ?? 'null');
+            if (!value || value.id !== id || typeof value.task !== 'string' || typeof value.agent !== 'string'
+                || typeof value.startedAt !== 'string' || !Number.isFinite(Date.parse(value.startedAt))
+                || !Array.isArray(value.steps) || !value.steps.every((step) => step
+                && typeof step.action === 'string' && typeof step.result === 'string'
+                && typeof step.quality === 'number' && Number.isFinite(step.quality)
+                && typeof step.timestamp === 'string'))
+                return undefined;
+            activeTrajectories.set(id, value);
+            return value;
+        }
+    }
+    catch { /* store unavailable: retain same-process best-effort tracking */ }
+    return activeTrajectories.get(id);
+}
 const MEMORY_DIR = '.claude-flow/memory';
 const MEMORY_FILE = 'store.json';
 function getMemoryPath() {
@@ -897,13 +965,19 @@ export const hooksPostCommand = {
         properties: {
             command: { type: 'string', description: 'Executed command' },
             exitCode: { type: 'number', description: 'Command exit code' },
+            success: { type: 'boolean', description: 'Explicit execution outcome; false records a failure even without a nonzero exit code' },
+            ttl: { type: 'integer', minimum: 1, maximum: 2147483647, description: 'Command history lifetime in seconds (default: 30 days)' },
         },
         required: ['command'],
     },
     handler: async (params) => {
         const command = params.command;
         const exitCode = params.exitCode || 0;
-        const success = exitCode === 0;
+        const success = exitCode === 0 && params.success !== false;
+        const ttl = params.ttl ?? 30 * 24 * 60 * 60;
+        if (typeof ttl !== 'number' || !Number.isSafeInteger(ttl) || ttl < 1 || ttl > 2147483647) {
+            return { success: false, recorded: false, error: 'ttl must be a positive integer number of seconds (at most 2147483647)' };
+        }
         {
             const v = validateText(command, 'command');
             if (!v.valid)
@@ -916,21 +990,35 @@ export const hooksPostCommand = {
         let _storedIn = 'none';
         try {
             const bridge = await import('../memory/memory-bridge.js');
-            await bridge.bridgeStoreEntry({
+            const stored = await bridge.bridgeStoreEntry({
                 key: `cmd-${Date.now()}`,
                 value: JSON.stringify({ command, exitCode, success }),
                 namespace: 'commands',
                 tags: [success ? 'success' : 'error'],
+                ttl,
+                generateEmbeddingFlag: false,
             });
+            if (!stored?.success)
+                throw new Error(stored?.error || 'Native bridge did not store the command');
             _storedIn = 'agentdb';
         }
         catch {
             // AgentDB not available — store in JSON
             try {
                 const store = loadMemoryStore();
-                const key = `cmd-${Date.now()}`;
-                store.entries[key] = { key, value: JSON.stringify({ command, exitCode, success }), namespace: 'commands', createdAt: new Date().toISOString() };
-                const memDir = resolve(MEMORY_DIR);
+                const now = Date.now();
+                for (const [entryKey, entry] of Object.entries(store.entries)) {
+                    if (entry.namespace === 'commands' && entry.expiresAt && Date.parse(entry.expiresAt) <= now) {
+                        delete store.entries[entryKey];
+                    }
+                }
+                const key = `cmd-${now}`;
+                store.entries[key] = {
+                    key, value: JSON.stringify({ command, exitCode, success }), namespace: 'commands',
+                    storedAt: new Date(now).toISOString(), lastAccessed: new Date(now).toISOString(), accessCount: 0,
+                    expiresAt: new Date(now + ttl * 1000).toISOString(),
+                };
+                const memDir = dirname(getMemoryPath());
                 if (!existsSync(memDir))
                     mkdirSync(memDir, { recursive: true });
                 writeFileSync(getMemoryPath(), JSON.stringify(store, null, 2), 'utf-8');
@@ -1444,9 +1532,10 @@ export const hooksPostTask = {
         type: 'object',
         properties: {
             taskId: { type: 'string', description: 'Task identifier' },
+            patterns: feedbackPatternsSchema,
             success: { type: 'boolean', description: 'Whether task was successful' },
             agent: { type: 'string', description: 'Agent that completed the task' },
-            quality: { type: 'number', description: 'Quality score (0-1)' },
+            quality: { type: 'number', minimum: 0, maximum: 1, description: 'Quality score (0-1)' },
             task: { type: 'string', description: 'Task description text (used for learning keyword extraction)' },
             duration: { type: 'number', description: 'Observed task duration in milliseconds (used by pheromone-adaptive topology)' },
             latencyBudgetMs: { type: 'number', description: 'Latency budget used to normalize duration (default 60000ms)' },
@@ -1463,8 +1552,19 @@ export const hooksPostTask = {
         const taskId = params.taskId;
         const success = params.success !== false;
         const agent = params.agent;
-        const quality = params.quality || (success ? 0.85 : 0.3);
+        if (params.quality !== undefined && (typeof params.quality !== 'number'
+            || !Number.isFinite(params.quality) || params.quality < 0 || params.quality > 1)) {
+            return { success: false, error: 'quality must be a finite number between 0 and 1' };
+        }
+        const quality = params.quality === undefined ? (success ? 0.85 : 0.3) : params.quality;
         const startTime = Date.now();
+        let patterns;
+        try {
+            patterns = validateFeedbackPatterns(params.patterns);
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
         {
             const v = validateIdentifier(taskId, 'taskId');
             if (!v.valid)
@@ -1502,7 +1602,7 @@ export const hooksPostTask = {
                 quality,
                 agent,
                 duration: params.duration || undefined,
-                patterns: params.patterns || undefined,
+                patterns,
                 // ADR-147 P2: forward spawn-tree lineage so it lands in feedback + memory
                 parentAgentId,
                 depth,
@@ -2754,9 +2854,8 @@ export const hooksIntelligenceReset = {
                 // Directory read failed
             }
         }
-        // Clear in-memory trajectories
-        cleared.trajectories = activeTrajectories.size;
-        activeTrajectories.clear();
+        // Reset learned state without abandoning tasks still recording outcomes.
+        cleared.trajectories = 0;
         return {
             reset: true,
             cleared,
@@ -2815,27 +2914,15 @@ export const hooksTrajectoryStart = {
             getTrajectoryTree().openTrajectory({ sessionId, trajectoryId, task, agent });
         }
         catch { /* prototype path — never blocks trajectory recording */ }
-        // Persist pending trajectory to disk so it survives MCP restarts
-        const storeFn = await getRealStoreFunction();
-        if (storeFn) {
-            try {
-                await storeFn({
-                    key: `trajectory-pending-${trajectoryId}`,
-                    value: JSON.stringify(trajectory),
-                    namespace: 'trajectories',
-                    tags: [agent, 'pending', 'sona-trajectory'],
-                });
-            }
-            catch {
-                // Best-effort persistence — trajectory still lives in-memory
-            }
-        }
+        // Checkpoint before handing the id to another process.
+        const persisted = await persistPendingTrajectory(trajectory);
         return {
             trajectoryId,
             task,
             agent,
             started: startedAt,
             status: 'recording',
+            persisted,
             implementation: 'real-trajectory-tracking',
             activeCount: activeTrajectories.size,
         };
@@ -2850,17 +2937,21 @@ export const hooksTrajectoryStep = {
             trajectoryId: { type: 'string', description: 'Trajectory ID' },
             action: { type: 'string', description: 'Action taken' },
             result: { type: 'string', description: 'Action result' },
-            quality: { type: 'number', description: 'Quality score (0-1)' },
+            quality: { type: 'number', minimum: 0, maximum: 1, description: 'Quality score (0-1)' },
         },
         required: ['trajectoryId', 'action'],
     },
-    handler: async (params) => {
+    handler: async (params) => withTrajectoryOperation(params.trajectoryId, async () => {
         const trajectoryId = params.trajectoryId;
         // #14: scrub extended-thinking blocks so reasoning tokens don't contaminate
         // the learning signal (DISTILL embeds this text).
         const action = scrubReasoningBlocks(params.action);
         const result = scrubReasoningBlocks(params.result || 'success');
-        const quality = params.quality || 0.85;
+        if (params.quality !== undefined && (typeof params.quality !== 'number'
+            || !Number.isFinite(params.quality) || params.quality < 0 || params.quality > 1)) {
+            return { success: false, error: 'quality must be a finite number between 0 and 1' };
+        }
+        const quality = params.quality === undefined ? 0.85 : params.quality;
         const timestamp = new Date().toISOString();
         const stepId = `step-${Date.now()}`;
         {
@@ -2874,7 +2965,7 @@ export const hooksTrajectoryStep = {
                 return { success: false, error: v.error };
         }
         // Add step to real trajectory if it exists
-        const trajectory = activeTrajectories.get(trajectoryId);
+        const trajectory = await loadPendingTrajectory(trajectoryId);
         if (trajectory) {
             trajectory.steps.push({
                 action,
@@ -2883,6 +2974,7 @@ export const hooksTrajectoryStep = {
                 timestamp,
             });
         }
+        const persisted = trajectory ? await persistPendingTrajectory(trajectory) : false;
         // MAGE-style execution-state-tree mirror (prototype, non-fatal)
         try {
             const { getTrajectoryTree } = await import('../ruvector/trajectory-tree.js');
@@ -2914,11 +3006,12 @@ export const hooksTrajectoryStep = {
             result,
             quality,
             recorded: !!trajectory,
+            persisted,
             timestamp,
             totalSteps: trajectory?.steps.length || 0,
             implementation: trajectory ? 'real-step-recording' : 'trajectory-not-found',
         };
-    },
+    }),
 };
 export const hooksTrajectoryEnd = {
     name: 'hooks_intelligence_trajectory-end',
@@ -2932,7 +3025,7 @@ export const hooksTrajectoryEnd = {
         },
         required: ['trajectoryId'],
     },
-    handler: async (params) => {
+    handler: async (params) => withTrajectoryOperation(params.trajectoryId, async () => {
         const trajectoryId = params.trajectoryId;
         {
             const v = validateIdentifier(trajectoryId, 'trajectoryId');
@@ -2944,7 +3037,7 @@ export const hooksTrajectoryEnd = {
         const endedAt = new Date().toISOString();
         const startTime = Date.now();
         // Get and finalize real trajectory
-        const trajectory = activeTrajectories.get(trajectoryId);
+        const trajectory = await loadPendingTrajectory(trajectoryId);
         let persistResult = { success: false };
         if (trajectory) {
             trajectory.success = success;
@@ -2970,8 +3063,17 @@ export const hooksTrajectoryEnd = {
                     persistResult = { success: false, error: error instanceof Error ? error.message : String(error) };
                 }
             }
-            // Remove from active trajectories
-            activeTrajectories.delete(trajectoryId);
+            // Failed writes remain retryable. A completed row prevents stale pending
+            // data from being replayed even if cleanup itself fails.
+            if (persistResult.success) {
+                activeTrajectories.delete(trajectoryId);
+                dirtyTrajectories.delete(trajectoryId);
+                try {
+                    const { deleteEntry } = await import('../memory/memory-initializer.js');
+                    await deleteEntry({ key: `trajectory-pending-${trajectoryId}`, namespace: 'trajectories' });
+                }
+                catch { /* completed record is the replay guard */ }
+            }
         }
         // MAGE-style execution-state-tree mirror (prototype, non-fatal)
         try {
@@ -3187,7 +3289,7 @@ export const hooksTrajectoryEnd = {
                 ? `SONA learned pattern "${sonaResult.patternKey}" with ${(sonaResult.confidence * 100).toFixed(1)}% confidence`
                 : (persistResult.success ? 'Trajectory persisted for future learning' : (persistResult.error || 'Trajectory not found')),
         };
-    },
+    }),
 };
 // Pattern store/search hooks - REAL implementation using storeEntry
 export const hooksPatternStore = {

package/v3/@claude-flow/cli/dist/src/mcp-tools/memory-tools.js

@@ -9,7 +9,7 @@
  *
  * @module v3/cli/mcp-tools/memory-tools
  */
-import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import { join, resolve } from 'path';
 import { createHash } from 'crypto';
@@ -273,11 +273,11 @@ const MEMORY_STATS_MAX_PAGES = 200;
  * breakdown and embedding coverage computed from a prefix, and a listing
  * that reported `success: false` was read as an empty one.
  */
-async function collectAllEntries(listEntries) {
+async function collectAllEntries(listEntries, dbPath) {
     const entries = [];
     let total = 0;
     for (let page = 0; page < MEMORY_STATS_MAX_PAGES; page++) {
-        const result = await listEntries({ limit: MEMORY_STATS_PAGE, offset: entries.length });
+        const result = await listEntries({ limit: MEMORY_STATS_PAGE, offset: entries.length, dbPath });
         if (!result.success) {
             return { success: false, entries, total: result.total ?? total, error: result.error };
         }
@@ -300,10 +300,10 @@ function memoryStatsUnavailable(error) {
  * WAL frames, so it is allowed to fail without that meaning the store is
  * missing — which is exactly the conflation #3311 reports.
  */
-async function readMemoryStatusLabels() {
+async function readMemoryStatusLabels(dbPath) {
     try {
         const { checkMemoryInitialization } = await getMemoryFunctions();
-        const status = await checkMemoryInitialization();
+        const status = await checkMemoryInitialization(dbPath);
         return { version: status.version, features: status.features };
     }
     catch {
@@ -315,37 +315,43 @@ async function readMemoryStatusLabels() {
  * #1606: Wrapped in try/catch to prevent process-level crashes that kill
  * the stdio MCP transport on Windows/Codex.
  */
-async function ensureInitialized() {
+async function ensureInitialized(dbPath) {
     try {
         const { initializeMemoryDatabase, checkMemoryInitialization, storeEntry } = await getMemoryFunctions();
         // Check if already initialized
-        const status = await checkMemoryInitialization();
+        const status = await checkMemoryInitialization(dbPath);
         if (!status.initialized) {
-            await initializeMemoryDatabase({ force: false, verbose: false });
+            await initializeMemoryDatabase({ force: false, verbose: false, dbPath });
         }
         // Migrate legacy JSON data if exists (from old .claude-flow/memory/ location)
+        // A custom import target must not consume the one-time migration marker
+        // for the project's normal memory store.
         if (hasLegacyStore()) {
-            const legacyStore = loadLegacyStore();
-            if (legacyStore && Object.keys(legacyStore.entries).length > 0) {
-                console.error('[MCP Memory] Migrating legacy JSON store to sql.js...');
-                let migrated = 0;
-                for (const [key, entry] of Object.entries(legacyStore.entries)) {
-                    try {
-                        const value = typeof entry.value === 'string' ? entry.value : JSON.stringify(entry.value);
-                        await storeEntry({
-                            key,
-                            value,
-                            namespace: 'default',
-                            generateEmbeddingFlag: true,
-                        });
-                        migrated++;
-                    }
-                    catch (e) {
-                        console.error(`[MCP Memory] Failed to migrate key "${key}":`, e);
+            const { resolveDbPath } = await import('../memory/memory-initializer.js');
+            if (!dbPath || dbPath === resolveDbPath()) {
+                const legacyStore = loadLegacyStore();
+                if (legacyStore && Object.keys(legacyStore.entries).length > 0) {
+                    console.error('[MCP Memory] Migrating legacy JSON store to sql.js...');
+                    let migrated = 0;
+                    for (const [key, entry] of Object.entries(legacyStore.entries)) {
+                        try {
+                            const value = typeof entry.value === 'string' ? entry.value : JSON.stringify(entry.value);
+                            await storeEntry({
+                                key,
+                                value,
+                                namespace: 'default',
+                                generateEmbeddingFlag: true,
+                                dbPath,
+                            });
+                            migrated++;
+                        }
+                        catch (e) {
+                            console.error(`[MCP Memory] Failed to migrate key "${key}":`, e);
+                        }
                     }
+                    console.error(`[MCP Memory] Migrated ${migrated}/${Object.keys(legacyStore.entries).length} entries`);
+                    markMigrationComplete();
                 }
-                console.error(`[MCP Memory] Migrated ${migrated}/${Object.keys(legacyStore.entries).length} entries`);
-                markMigrationComplete();
             }
         }
     }
@@ -792,10 +798,18 @@ export const memoryTools = [
         category: 'memory',
         inputSchema: {
             type: 'object',
-            properties: {},
+            properties: {
+                dbPath: { type: 'string', description: 'Database file to inspect; omitted uses the MCP store default' },
+            },
         },
-        handler: async () => {
-            await ensureInitialized();
+        handler: async (input) => {
+            if (input.dbPath !== undefined && (typeof input.dbPath !== 'string' || !input.dbPath.trim())) {
+                return memoryStatsUnavailable('dbPath must be a non-empty string');
+            }
+            const dbPath = typeof input.dbPath === 'string' ? resolve(input.dbPath) : undefined;
+            // An explicit read must not initialize or migrate the unrelated default store.
+            if (!dbPath)
+                await ensureInitialized();
             const { listEntries } = await getMemoryFunctions();
             // #3311: the store's own listing decides whether memory is there.
             // `checkMemoryInitialization` opens a whole-image sql.js snapshot of
@@ -806,7 +820,7 @@ export const memoryTools = [
             // but it no longer gets to overrule a working store.
             let listing;
             try {
-                listing = await collectAllEntries(listEntries);
+                listing = await collectAllEntries(listEntries, dbPath);
             }
             catch (error) {
                 return memoryStatsUnavailable(error instanceof Error ? error.message : 'Unknown error');
@@ -822,16 +836,49 @@ export const memoryTools = [
             // from the breakdown while still being counted in the total.
             const namespaces = Object.create(null);
             let withEmbeddings = 0;
+            let oldest = Infinity;
+            let newest = -Infinity;
             for (const entry of listing.entries) {
                 namespaces[entry.namespace] = (namespaces[entry.namespace] || 0) + 1;
                 if (entry.hasEmbedding)
                     withEmbeddings++;
+                // AgentDB returns INTEGER epoch milliseconds; legacy sql.js rows
+                // may expose ISO strings or numeric strings from SQLite TEXT affinity.
+                const rawCreated = entry.createdAt;
+                const millis = typeof rawCreated === 'number'
+                    ? rawCreated
+                    : typeof rawCreated === 'string' && /^-?\d+$/.test(rawCreated)
+                        ? Number(rawCreated)
+                        : Date.parse(rawCreated ?? '');
+                const created = new Date(millis).getTime();
+                if (Number.isFinite(created)) {
+                    oldest = Math.min(oldest, created);
+                    newest = Math.max(newest, created);
+                }
             }
             const counted = listing.entries.length;
-            const status = await readMemoryStatusLabels();
+            const status = await readMemoryStatusLabels(dbPath);
+            let totalSize = null;
+            if (dbPath) {
+                try {
+                    let bytes = statSync(dbPath).size;
+                    try {
+                        bytes += statSync(dbPath + '-wal').size;
+                    }
+                    catch (error) {
+                        if (error.code !== 'ENOENT')
+                            throw error;
+                    }
+                    totalSize = `${bytes} B`;
+                }
+                catch { /* unavailable file metadata is unknown, not zero */ }
+            }
             return {
                 initialized: true,
                 totalEntries: listing.total,
+                ...(dbPath ? { location: dbPath, totalSize } : {}),
+                oldestEntry: counted >= listing.total && Number.isFinite(oldest) ? new Date(oldest).toISOString() : null,
+                newestEntry: counted >= listing.total && Number.isFinite(newest) ? new Date(newest).toISOString() : null,
                 entriesCounted: counted,
                 // The breakdown below covers `entriesCounted` rows, which is every
                 // row unless the listing was truncated; say so rather than letting
@@ -1484,11 +1531,15 @@ export const memoryTools = [
                 inputPath: { type: 'string', description: 'Path to the JSON export file' },
                 merge: { type: 'boolean', description: 'Merge into existing entries (upsert) vs. fail on conflict (default true)' },
                 namespace: { type: 'string', description: 'Override the namespace for all imported entries' },
+                dbPath: { type: 'string', description: 'Database file to import into (defaults to the MCP memory store)' },
             },
             required: ['inputPath'],
         },
         handler: async (input) => {
-            await ensureInitialized();
+            const dbPath = typeof input.dbPath === 'string' && input.dbPath.trim()
+                ? resolve(input.dbPath)
+                : undefined;
+            await ensureInitialized(dbPath);
             const { storeEntry } = await getMemoryFunctions();
             const t0 = Date.now();
             const inputPath = String(input.inputPath ?? '');
@@ -1517,8 +1568,11 @@ export const memoryTools = [
                 }
                 const value = typeof e.value === 'string' ? e.value : JSON.stringify(e.value ?? null);
                 try {
-                    await storeEntry({ key: e.key, value, namespace: nsOverride ?? e.namespace ?? 'default', upsert: input.merge !== false });
-                    imported++;
+                    const result = await storeEntry({ key: e.key, value, namespace: nsOverride ?? e.namespace ?? 'default', upsert: input.merge !== false, dbPath });
+                    if (result.success)
+                        imported++;
+                    else
+                        skipped++;
                 }
                 catch {
                     skipped++;

package/v3/@claude-flow/cli/dist/src/mcp-tools/policy-enforcer.d.ts

@@ -62,6 +62,12 @@ export interface McpPolicy {
     harnessId?: string;
     defaultDeny?: boolean;
     auditLog?: boolean;
+    /** Explicit destination; takes precedence over the environment and project default. */
+    auditLogPath?: string;
+    /** Maximum bytes per audit segment. Default 10 MiB; oversized records fail closed. */
+    auditLogMaxBytes?: number;
+    /** Rotated segments retained in addition to the active log. Default 5, maximum 100. */
+    auditLogMaxFiles?: number;
     requireApprovalForDangerous?: boolean;
     toolTimeoutMs?: number;
     /**
@@ -103,10 +109,11 @@ export interface AuditLogEntry {
     toolName: string;
     allowed: boolean;
     reason?: string;
+    projectPath?: string;
 }
 /** Test-only: redirect the audit log to a temp file instead of the default path. */
 export declare function setAuditLogPathForTesting(p: string | null): void;
-export declare function getAuditLogPath(): string;
+export declare function getAuditLogPath(options?: Pick<McpPolicy, 'auditLogPath'>): string;
 /**
  * Appends one JSONL audit record. Returns `true` if `policy.auditLog` is not
  * set (nothing was required) or the write succeeded; `false` only when