@rlabs-inc/memory 0.5.2 → 0.5.8

package/src/core/manager.ts

@@ -4,34 +4,19 @@
 // Mirrors Curator pattern exactly
 // ============================================================================
 
-import { join } from 'path'
-import { homedir } from 'os'
-import { existsSync } from 'fs'
-import type { CurationResult } from '../types/memory.ts'
-import { logger } from '../utils/logger.ts'
-
-/**
- * Get the Claude CLI command path
- * Uses `which` for universal discovery across installation methods
- */
-function getClaudeCommand(): string {
-  // 1. Check for explicit override
-  const envCommand = process.env.CURATOR_COMMAND
-  if (envCommand) return envCommand
-
-  // 2. Use `which` to find claude in PATH (universal - works with native, homebrew, npm, etc.)
-  const result = Bun.spawnSync(['which', 'claude'])
-  if (result.exitCode === 0) {
-    return result.stdout.toString().trim()
-  }
-
-  // 3. Legacy fallback - hardcoded native install path
-  const claudeLocal = join(homedir(), '.claude', 'local', 'claude')
-  if (existsSync(claudeLocal)) return claudeLocal
-
-  // 4. Last resort
-  return 'claude'
-}
+import { join } from "path";
+import { homedir } from "os";
+import { existsSync } from "fs";
+import type { CurationResult } from "../types/memory.ts";
+import { logger } from "../utils/logger.ts";
+import {
+  getClaudeCommand,
+  getManagerPromptPath,
+  getManagerCwd,
+  getCentralStoragePath,
+  getStorageMode,
+  type StoragePaths,
+} from "../utils/paths.ts";
 
 /**
  * Manager configuration
@@ -42,80 +27,40 @@ export interface ManagerConfig {
    * When disabled, memories are stored but not organized/linked
    * Default: true
    */
-  enabled?: boolean
+  enabled?: boolean;
 
   /**
    * CLI command to use (for subprocess mode)
    * Default: auto-detected (~/.claude/local/claude or 'claude')
    */
-  cliCommand?: string
+  cliCommand?: string;
 
   /**
    * Maximum turns for the management agent
    * Set to undefined for unlimited turns
    * Default: undefined (unlimited)
    */
-  maxTurns?: number
+  maxTurns?: number;
 }
 
-/**
- * Storage paths for the management agent
- * These are resolved at runtime from the server's actual configuration
- */
-export interface StoragePaths {
-  /**
-   * Root path to project storage directory (NOT the memories subdirectory)
-   * e.g., ~/.local/share/memory/memory-ts/ (central)
-   * or /path/to/project/.memory/ (local)
-   */
-  projectPath: string
-
-  /**
-   * Root path to global storage directory (NOT the memories subdirectory)
-   * Always ~/.local/share/memory/global/
-   */
-  globalPath: string
-
-  /**
-   * Full path to project memories directory
-   * e.g., ~/.local/share/memory/memory-ts/memories/ (central)
-   * or /path/to/project/.memory/memories/ (local)
-   */
-  projectMemoriesPath: string
-
-  /**
-   * Full path to global memories directory
-   * Always ~/.local/share/memory/global/memories/
-   */
-  globalMemoriesPath: string
-
-  /**
-   * Full path to personal primer file
-   * Always ~/.local/share/memory/global/memories/personal-primer.md
-   */
-  personalPrimerPath: string
-
-  /**
-   * Storage mode for context
-   */
-  storageMode: 'central' | 'local'
-}
+// Re-export StoragePaths for backwards compatibility
+export type { StoragePaths } from "../utils/paths.ts";
 
 /**
  * Management result - what the agent did
  */
 export interface ManagementResult {
-  success: boolean
-  superseded: number
-  resolved: number
-  linked: number
-  filesRead: number
-  filesWritten: number
-  primerUpdated: boolean
-  actions: string[]  // Detailed action log lines
-  summary: string    // Brief summary for storage
-  fullReport: string // Complete management report (ACTIONS + SUMMARY sections)
-  error?: string
+  success: boolean;
+  superseded: number;
+  resolved: number;
+  linked: number;
+  filesRead: number;
+  filesWritten: number;
+  primerUpdated: boolean;
+  actions: string[]; // Detailed action log lines
+  summary: string; // Brief summary for storage
+  fullReport: string; // Complete management report (ACTIONS + SUMMARY sections)
+  error?: string;
 }
 
 /**
@@ -124,17 +69,17 @@ export interface ManagementResult {
  */
 export class Manager {
   private _config: {
-    enabled: boolean
-    cliCommand: string
-    maxTurns?: number  // undefined = unlimited
-  }
+    enabled: boolean;
+    cliCommand: string;
+    maxTurns?: number; // undefined = unlimited
+  };
 
   constructor(config: ManagerConfig = {}) {
     this._config = {
       enabled: config.enabled ?? true,
       cliCommand: config.cliCommand ?? getClaudeCommand(),
-      maxTurns: config.maxTurns,  // undefined = unlimited turns
-    }
+      maxTurns: config.maxTurns, // undefined = unlimited turns
+    };
   }
 
   /**
@@ -144,25 +89,34 @@ export class Manager {
   async buildManagementPrompt(): Promise<string | null> {
     const skillPaths = [
       // Development - relative to src/core
-      join(import.meta.dir, '../../skills/memory-management.md'),
+      join(import.meta.dir, "../../skills/memory-management.md"),
       // Installed via bun global
-      join(homedir(), '.bun/install/global/node_modules/@rlabs-inc/memory/skills/memory-management.md'),
+      join(
+        homedir(),
+        ".bun/install/global/node_modules/@rlabs-inc/memory/skills/memory-management.md",
+      ),
       // Installed via npm global
-      join(homedir(), '.npm/global/node_modules/@rlabs-inc/memory/skills/memory-management.md'),
+      join(
+        homedir(),
+        ".npm/global/node_modules/@rlabs-inc/memory/skills/memory-management.md",
+      ),
       // Local node_modules
-      join(process.cwd(), 'node_modules/@rlabs-inc/memory/skills/memory-management.md'),
-    ]
+      join(
+        process.cwd(),
+        "node_modules/@rlabs-inc/memory/skills/memory-management.md",
+      ),
+    ];
 
     for (const path of skillPaths) {
       try {
-        const content = await Bun.file(path).text()
-        if (content) return content
+        const content = await Bun.file(path).text();
+        if (content) return content;
       } catch {
-        continue
+        continue;
       }
     }
 
-    return null
+    return null;
   }
 
   /**
@@ -173,13 +127,14 @@ export class Manager {
     projectId: string,
     sessionNumber: number,
     result: CurationResult,
-    storagePaths?: StoragePaths
+    storagePaths?: StoragePaths,
   ): string {
-    const today = new Date().toISOString().split('T')[0]
+    const today = new Date().toISOString().split("T")[0];
 
     // Build storage paths section if provided
     // Includes both root paths (for permissions context) and memories paths (for file operations)
-    const pathsSection = storagePaths ? `
+    const pathsSection = storagePaths
+      ? `
 ## Storage Paths (ACTUAL - use these exact paths)
 
 **Storage Mode:** ${storagePaths.storageMode}
@@ -195,7 +150,8 @@ export class Manager {
 
 > ⚠️ These paths are resolved from the running server configuration. Use them exactly as provided.
 > Memories are stored as individual markdown files in the memories directories.
-` : ''
+`
+      : "";
 
     return `## Curation Data
 
@@ -204,183 +160,38 @@ export class Manager {
 **Date:** ${today}
 ${pathsSection}
 ### Session Summary
-${result.session_summary || 'No summary provided'}
+${result.session_summary || "No summary provided"}
 
 ### Project Snapshot
-${result.project_snapshot ? `
-- Current Phase: ${result.project_snapshot.current_phase || 'N/A'}
-- Recent Achievements: ${result.project_snapshot.recent_achievements?.join(', ') || 'None'}
-- Active Challenges: ${result.project_snapshot.active_challenges?.join(', ') || 'None'}
-- Next Steps: ${result.project_snapshot.next_steps?.join(', ') || 'None'}
-` : 'No snapshot provided'}
+${
+  result.project_snapshot
+    ? `
+- Current Phase: ${result.project_snapshot.current_phase || "N/A"}
+- Recent Achievements: ${result.project_snapshot.recent_achievements?.join(", ") || "None"}
+- Active Challenges: ${result.project_snapshot.active_challenges?.join(", ") || "None"}
+- Next Steps: ${result.project_snapshot.next_steps?.join(", ") || "None"}
+`
+    : "No snapshot provided"
+}
 
 ### New Memories (${result.memories.length})
-${result.memories.map((m, i) => `
+${result.memories
+  .map(
+    (m, i) => `
 #### Memory ${i + 1}
 - **Content:** ${m.content}
 - **Type:** ${m.context_type}
-- **Scope:** ${m.scope || 'project'}
-- **Domain:** ${m.domain || 'N/A'}
+- **Scope:** ${m.scope || "project"}
+- **Domain:** ${m.domain || "N/A"}
 - **Importance:** ${m.importance_weight}
-- **Tags:** ${m.semantic_tags?.join(', ') || 'None'}
-`).join('\n')}
+- **Tags:** ${m.semantic_tags?.join(", ") || "None"}
+`,
+  )
+  .join("\n")}
 
 ---
 
-Please process these memories according to your management procedure. Use the exact storage paths provided above to read and write memory files. Update, supersede, or link existing memories as needed. Update the personal primer if any personal memories warrant it.`
-  }
-
-  /**
-   * Parse management response from Claude
-   */
-  parseManagementResponse(responseJson: string): ManagementResult {
-    const emptyResult = (error?: string): ManagementResult => ({
-      success: !error,
-      superseded: 0,
-      resolved: 0,
-      linked: 0,
-      filesRead: 0,
-      filesWritten: 0,
-      primerUpdated: false,
-      actions: [],
-      summary: error ? '' : 'No actions taken',
-      fullReport: error ? `Error: ${error}` : '',
-      error,
-    })
-
-    try {
-      // First, parse the CLI JSON wrapper
-      const cliOutput = JSON.parse(responseJson)
-
-      // Claude Code now returns an array of events - find the result object
-      let resultObj: any
-      if (Array.isArray(cliOutput)) {
-        // New format: array of events, find the one with type="result"
-        resultObj = cliOutput.find((item: any) => item.type === 'result')
-        if (!resultObj) {
-          return emptyResult('No result found in response')
-        }
-      } else {
-        // Old format: single object (backwards compatibility)
-        resultObj = cliOutput
-      }
-
-      // Check for error response
-      if (resultObj.type === 'error' || resultObj.is_error === true) {
-        return emptyResult(resultObj.error || 'Unknown error')
-      }
-
-      // Extract the "result" field (AI's response text)
-      const resultText = typeof resultObj.result === 'string' ? resultObj.result : ''
-
-      // Extract the full report (everything from === MANAGEMENT ACTIONS === onwards)
-      const reportMatch = resultText.match(/(=== MANAGEMENT ACTIONS ===[\s\S]*)/)
-      const fullReport = reportMatch ? reportMatch[1].trim() : resultText
-
-      // Extract actions section
-      const actionsMatch = resultText.match(/=== MANAGEMENT ACTIONS ===([\s\S]*?)(?:=== SUMMARY ===|$)/)
-      const actions: string[] = []
-      if (actionsMatch) {
-        const actionsText = actionsMatch[1]
-        // Extract lines that look like actions (TYPE: description or TYPE OK/FAILED: path)
-        // Note: RECEIVED replaced CREATED - manager receives new memories from curator, doesn't create them
-        const actionLines = actionsText.split('\n')
-          .map((line: string) => line.trim())
-          .filter((line: string) => /^(READ|WRITE|RECEIVED|CREATED|UPDATED|SUPERSEDED|RESOLVED|LINKED|PRIMER|SKIPPED|NO_ACTION)/.test(line))
-        actions.push(...actionLines)
-      }
-
-      // Extract stats from result text
-      const supersededMatch = resultText.match(/memories_superseded[:\s]+(\d+)/i) || resultText.match(/superseded[:\s]+(\d+)/i)
-      const resolvedMatch = resultText.match(/memories_resolved[:\s]+(\d+)/i) || resultText.match(/resolved[:\s]+(\d+)/i)
-      const linkedMatch = resultText.match(/memories_linked[:\s]+(\d+)/i) || resultText.match(/linked[:\s]+(\d+)/i)
-      const filesReadMatch = resultText.match(/files_read[:\s]+(\d+)/i)
-      const filesWrittenMatch = resultText.match(/files_written[:\s]+(\d+)/i)
-      const primerUpdated = /primer_updated[:\s]+true/i.test(resultText) || /PRIMER\s+OK/i.test(resultText)
-
-      // Count file operations from actions if not in summary
-      const readActions = actions.filter((a: string) => a.startsWith('READ OK')).length
-      const writeActions = actions.filter((a: string) => a.startsWith('WRITE OK')).length
-
-      return {
-        success: true,
-        superseded: supersededMatch ? parseInt(supersededMatch[1]) : 0,
-        resolved: resolvedMatch ? parseInt(resolvedMatch[1]) : 0,
-        linked: linkedMatch ? parseInt(linkedMatch[1]) : 0,
-        filesRead: filesReadMatch ? parseInt(filesReadMatch[1]) : readActions,
-        filesWritten: filesWrittenMatch ? parseInt(filesWrittenMatch[1]) : writeActions,
-        primerUpdated,
-        actions,
-        summary: resultText.slice(0, 500),  // Brief summary for storage
-        fullReport,                          // Complete report for logging
-      }
-    } catch {
-      return emptyResult('Failed to parse response')
-    }
-  }
-
-  /**
-   * Build a temporary settings file with path-based permissions
-   *
-   * Claude CLI supports path restrictions via settings.json permissions, NOT via --allowedTools.
-   * Syntax: Read(//absolute/path/**) where // means absolute path
-   *
-   * This provides real security - the agent can ONLY access memory storage paths.
-   */
-  private async _buildSettingsFile(storagePaths?: StoragePaths): Promise<string> {
-    // Build allow list with path restrictions
-    const allowRules: string[] = []
-
-    // Global path - always central at ~/.local/share/memory/global
-    const globalPath = storagePaths?.globalPath
-      ?? join(homedir(), '.local', 'share', 'memory', 'global')
-
-    // Project path - depends on storage mode
-    const projectPath = storagePaths?.projectPath
-      ?? join(homedir(), '.local', 'share', 'memory')
-
-    // Glob and Grep - tool names only (no path syntax in Claude CLI for these)
-    allowRules.push('Glob')
-    allowRules.push('Grep')
-
-    // Helper to format path for Claude CLI permissions
-    // // means "absolute path from filesystem root"
-    // If path already starts with /, replace it with //
-    const formatPath = (p: string) => p.startsWith('/') ? '/' + p : '//' + p
-
-    // Read, Write, Edit - use path patterns with // for absolute paths
-    // Global path (always ~/.local/share/memory/global/)
-    allowRules.push(`Read(${formatPath(globalPath)}/**)`)
-    allowRules.push(`Write(${formatPath(globalPath)}/**)`)
-    allowRules.push(`Edit(${formatPath(globalPath)}/**)`)
-
-    // Project path (always different from global, even in central mode)
-    // Central: ~/.local/share/memory/{project_id}/
-    // Local: {project_path}/.memory/{project_id}/
-    allowRules.push(`Read(${formatPath(projectPath)}/**)`)
-    allowRules.push(`Write(${formatPath(projectPath)}/**)`)
-    allowRules.push(`Edit(${formatPath(projectPath)}/**)`)
-
-
-    const settings = {
-      permissions: {
-        allow: allowRules,
-        deny: [
-          // Explicitly deny sensitive paths for Read/Write/Edit
-          'Read(/etc/**)',
-          'Read(~/.ssh/**)',
-          'Read(~/.aws/**)',
-          'Read(~/.gnupg/**)',
-          'Read(.env)',
-          'Read(.env.*)',
-        ]
-      }
-    }
-
-    // Write to temp file
-    const tempPath = join(homedir(), '.local', 'share', 'memory', '.manager-settings.json')
-    await Bun.write(tempPath, JSON.stringify(settings, null, 2))
-    return tempPath
+Please process these memories according to your management procedure. Use the exact storage paths provided above to read and write memory files. Update, supersede, or link existing memories as needed. Update the personal primer if any personal memories warrant it.`;
   }
 
   /**
@@ -391,10 +202,10 @@ Please process these memories according to your management procedure. Use the ex
     projectId: string,
     sessionNumber: number,
     result: CurationResult,
-    storagePaths?: StoragePaths
+    storagePaths?: StoragePaths,
   ): Promise<ManagementResult> {
     // Skip if disabled via config or env var
-    if (!this._config.enabled || process.env.MEMORY_MANAGER_DISABLED === '1') {
+    if (!this._config.enabled || process.env.MEMORY_MANAGER_DISABLED === "1") {
       return {
         success: true,
         superseded: 0,
@@ -404,9 +215,9 @@ Please process these memories according to your management procedure. Use the ex
         filesWritten: 0,
         primerUpdated: false,
         actions: [],
-        summary: 'Management agent disabled',
-        fullReport: 'Management agent disabled via configuration',
-      }
+        summary: "Management agent disabled",
+        fullReport: "Management agent disabled via configuration",
+      };
     }
 
     // Skip if no memories
@@ -420,13 +231,13 @@ Please process these memories according to your management procedure. Use the ex
         filesWritten: 0,
         primerUpdated: false,
         actions: [],
-        summary: 'No memories to process',
-        fullReport: 'No memories to process - skipped',
-      }
+        summary: "No memories to process",
+        fullReport: "No memories to process - skipped",
+      };
     }
 
     // Load skill file
-    const systemPrompt = await this.buildManagementPrompt()
+    const systemPrompt = await this.buildManagementPrompt();
     if (!systemPrompt) {
       return {
         success: false,
@@ -437,44 +248,50 @@ Please process these memories according to your management procedure. Use the ex
         filesWritten: 0,
         primerUpdated: false,
         actions: [],
-        summary: '',
-        fullReport: 'Error: Management skill file not found',
-        error: 'Management skill not found',
-      }
+        summary: "",
+        fullReport: "Error: Management skill file not found",
+        error: "Management skill not found",
+      };
     }
 
-    const userMessage = this.buildUserMessage(projectId, sessionNumber, result, storagePaths)
+    const userMessage = this.buildUserMessage(
+      projectId,
+      sessionNumber,
+      result,
+      storagePaths,
+    );
 
     try {
       // Dynamic import to make Agent SDK optional
-      const { query } = await import('@anthropic-ai/claude-agent-sdk')
+      const { query } = await import("@anthropic-ai/claude-agent-sdk");
 
       // Build allowed directories for file access
-      const globalPath = storagePaths?.globalPath ?? join(homedir(), '.local', 'share', 'memory', 'global')
-      const projectPath = storagePaths?.projectPath ?? join(homedir(), '.local', 'share', 'memory')
+      const globalPath =
+        storagePaths?.globalPath ?? join(getCentralStoragePath(), "global");
+      const projectPath = storagePaths?.projectPath ?? getCentralStoragePath();
 
       // Use Agent SDK with file tools
       const q = query({
         prompt: userMessage,
         options: {
           systemPrompt,
-          permissionMode: 'bypassPermissions',
-          model: 'claude-opus-4-5-20251101',
+          permissionMode: "bypassPermissions",
+          model: "claude-opus-4-5-20251101",
           // Only allow file tools - no Bash, no web
-          allowedTools: ['Read', 'Write', 'Edit', 'Glob', 'Grep'],
+          allowedTools: ["Read", "Write", "Edit", "Glob", "Grep"],
           // Allow access to memory directories
           additionalDirectories: [globalPath, projectPath],
           // Limit turns if configured
           maxTurns: this._config.maxTurns,
         },
-      })
+      });
 
       // Iterate through the async generator to get the result
-      let resultText = ''
+      let resultText = "";
       for await (const msg of q) {
-        if (msg.type === 'result' && 'result' in msg) {
-          resultText = msg.result
-          break
+        if (msg.type === "result" && "result" in msg) {
+          resultText = msg.result;
+          break;
         }
       }
 
@@ -488,12 +305,12 @@ Please process these memories according to your management procedure. Use the ex
           filesWritten: 0,
           primerUpdated: false,
           actions: [],
-          summary: 'No result from management agent',
-          fullReport: 'Management agent completed but returned no result',
-        }
+          summary: "No result from management agent",
+          fullReport: "Management agent completed but returned no result",
+        };
       }
 
-      return this._parseSDKManagementResult(resultText)
+      return this._parseSDKManagementResult(resultText);
     } catch (error: any) {
       return {
         success: false,
@@ -504,126 +321,11 @@ Please process these memories according to your management procedure. Use the ex
         filesWritten: 0,
         primerUpdated: false,
         actions: [],
-        summary: '',
-        fullReport: `Error: Agent SDK failed: ${error.message}`,
+        summary: "",
+        fullReport: `Manager Claude - Error: Agent SDK failed: ${error.message}`,
         error: error.message,
-      }
-    }
-  }
-
-  /**
-   * Manage using CLI subprocess (for hooks - keeps working while we migrate)
-   * Similar to Curator.curateWithCLI
-   */
-  async manageWithCLI(
-    projectId: string,
-    sessionNumber: number,
-    result: CurationResult,
-    storagePaths?: StoragePaths
-  ): Promise<ManagementResult> {
-    // Skip if disabled via config or env var
-    if (!this._config.enabled || process.env.MEMORY_MANAGER_DISABLED === '1') {
-      return {
-        success: true,
-        superseded: 0,
-        resolved: 0,
-        linked: 0,
-        filesRead: 0,
-        filesWritten: 0,
-        primerUpdated: false,
-        actions: [],
-        summary: 'Management agent disabled',
-        fullReport: 'Management agent disabled via configuration',
-      }
-    }
-
-    // Skip if no memories
-    if (result.memories.length === 0) {
-      return {
-        success: true,
-        superseded: 0,
-        resolved: 0,
-        linked: 0,
-        filesRead: 0,
-        filesWritten: 0,
-        primerUpdated: false,
-        actions: [],
-        summary: 'No memories to process',
-        fullReport: 'No memories to process - skipped',
-      }
-    }
-
-    // Load skill file
-    const systemPrompt = await this.buildManagementPrompt()
-    if (!systemPrompt) {
-      return {
-        success: false,
-        superseded: 0,
-        resolved: 0,
-        linked: 0,
-        filesRead: 0,
-        filesWritten: 0,
-        primerUpdated: false,
-        actions: [],
-        summary: '',
-        fullReport: 'Error: Management skill file not found',
-        error: 'Management skill not found',
-      }
-    }
-
-    const userMessage = this.buildUserMessage(projectId, sessionNumber, result, storagePaths)
-
-    // Build settings file with path-based permissions
-    // This provides real security - the agent can ONLY access memory storage paths
-    const settingsPath = await this._buildSettingsFile(storagePaths)
-
-    // Build CLI command with settings file for path restrictions
-    const args = [
-      '-p', userMessage,
-      '--append-system-prompt', systemPrompt,
-      '--output-format', 'json',
-      '--settings', settingsPath,
-    ]
-
-    // Add max-turns only if configured (undefined = unlimited)
-    if (this._config.maxTurns !== undefined) {
-      args.push('--max-turns', String(this._config.maxTurns))
+      };
     }
-
-    // Execute CLI
-    const proc = Bun.spawn([this._config.cliCommand, ...args], {
-      env: {
-        ...process.env,
-        MEMORY_CURATOR_ACTIVE: '1',  // Prevent recursive hook triggering
-      },
-      stderr: 'pipe',
-    })
-
-    // Capture output
-    const [stdout, stderr] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-    ])
-    const exitCode = await proc.exited
-
-    if (exitCode !== 0) {
-      const errorMsg = stderr || `Exit code ${exitCode}`
-      return {
-        success: false,
-        superseded: 0,
-        resolved: 0,
-        linked: 0,
-        filesRead: 0,
-        filesWritten: 0,
-        primerUpdated: false,
-        actions: [],
-        summary: '',
-        fullReport: `Error: CLI failed with exit code ${exitCode}\n${stderr}`,
-        error: errorMsg,
-      }
-    }
-
-    return this.parseManagementResponse(stdout)
   }
 
   /**
@@ -632,31 +334,50 @@ Please process these memories according to your management procedure. Use the ex
    */
   private _parseSDKManagementResult(resultText: string): ManagementResult {
     // Extract actions section
-    const actionsMatch = resultText.match(/=== MANAGEMENT ACTIONS ===([\s\S]*?)(?:=== SUMMARY ===|$)/)
-    const actions: string[] = []
+    const actionsMatch = resultText.match(
+      /=== MANAGEMENT ACTIONS ===([\s\S]*?)(?:=== SUMMARY ===|$)/,
+    );
+    const actions: string[] = [];
     if (actionsMatch) {
-      const actionsText = actionsMatch[1]
-      const actionLines = actionsText.split('\n')
+      const actionsText = actionsMatch[1];
+      const actionLines = actionsText
+        .split("\n")
         .map((line: string) => line.trim())
-        .filter((line: string) => /^(READ|WRITE|RECEIVED|CREATED|UPDATED|SUPERSEDED|RESOLVED|LINKED|PRIMER|SKIPPED|NO_ACTION)/.test(line))
-      actions.push(...actionLines)
+        .filter((line: string) =>
+          /^(READ|WRITE|RECEIVED|CREATED|UPDATED|SUPERSEDED|RESOLVED|LINKED|PRIMER|SKIPPED|NO_ACTION)/.test(
+            line,
+          ),
+        );
+      actions.push(...actionLines);
     }
 
     // Extract the full report
-    const reportMatch = resultText.match(/(=== MANAGEMENT ACTIONS ===[\s\S]*)/)
-    const fullReport = reportMatch ? reportMatch[1].trim() : resultText
+    const reportMatch = resultText.match(/(=== MANAGEMENT ACTIONS ===[\s\S]*)/);
+    const fullReport = reportMatch ? reportMatch[1].trim() : resultText;
 
     // Extract stats from result text
-    const supersededMatch = resultText.match(/memories_superseded[:\s]+(\d+)/i) || resultText.match(/superseded[:\s]+(\d+)/i)
-    const resolvedMatch = resultText.match(/memories_resolved[:\s]+(\d+)/i) || resultText.match(/resolved[:\s]+(\d+)/i)
-    const linkedMatch = resultText.match(/memories_linked[:\s]+(\d+)/i) || resultText.match(/linked[:\s]+(\d+)/i)
-    const filesReadMatch = resultText.match(/files_read[:\s]+(\d+)/i)
-    const filesWrittenMatch = resultText.match(/files_written[:\s]+(\d+)/i)
-    const primerUpdated = /primer_updated[:\s]+true/i.test(resultText) || /PRIMER\s+OK/i.test(resultText)
+    const supersededMatch =
+      resultText.match(/memories_superseded[:\s]+(\d+)/i) ||
+      resultText.match(/superseded[:\s]+(\d+)/i);
+    const resolvedMatch =
+      resultText.match(/memories_resolved[:\s]+(\d+)/i) ||
+      resultText.match(/resolved[:\s]+(\d+)/i);
+    const linkedMatch =
+      resultText.match(/memories_linked[:\s]+(\d+)/i) ||
+      resultText.match(/linked[:\s]+(\d+)/i);
+    const filesReadMatch = resultText.match(/files_read[:\s]+(\d+)/i);
+    const filesWrittenMatch = resultText.match(/files_written[:\s]+(\d+)/i);
+    const primerUpdated =
+      /primer_updated[:\s]+true/i.test(resultText) ||
+      /PRIMER\s+OK/i.test(resultText);
 
     // Count file operations from actions if not in summary
-    const readActions = actions.filter((a: string) => a.startsWith('READ OK')).length
-    const writeActions = actions.filter((a: string) => a.startsWith('WRITE OK')).length
+    const readActions = actions.filter((a: string) =>
+      a.startsWith("READ OK"),
+    ).length;
+    const writeActions = actions.filter((a: string) =>
+      a.startsWith("WRITE OK"),
+    ).length;
 
     return {
       success: true,
@@ -664,12 +385,14 @@ Please process these memories according to your management procedure. Use the ex
       resolved: resolvedMatch ? parseInt(resolvedMatch[1]) : 0,
       linked: linkedMatch ? parseInt(linkedMatch[1]) : 0,
       filesRead: filesReadMatch ? parseInt(filesReadMatch[1]) : readActions,
-      filesWritten: filesWrittenMatch ? parseInt(filesWrittenMatch[1]) : writeActions,
+      filesWritten: filesWrittenMatch
+        ? parseInt(filesWrittenMatch[1])
+        : writeActions,
       primerUpdated,
       actions,
       summary: resultText.slice(0, 500),
       fullReport,
-    }
+    };
   }
 
   /**
@@ -681,10 +404,10 @@ Please process these memories according to your management procedure. Use the ex
     projectId: string,
     sessionNumber: number,
     result: CurationResult,
-    storagePaths?: StoragePaths
+    storagePaths?: StoragePaths,
   ): Promise<ManagementResult> {
     // Skip if disabled via config or env var
-    if (!this._config.enabled || process.env.MEMORY_MANAGER_DISABLED === '1') {
+    if (!this._config.enabled || process.env.MEMORY_MANAGER_DISABLED === "1") {
       return {
         success: true,
         superseded: 0,
@@ -694,9 +417,9 @@ Please process these memories according to your management procedure. Use the ex
         filesWritten: 0,
         primerUpdated: false,
         actions: [],
-        summary: 'Management agent disabled',
-        fullReport: 'Management agent disabled via configuration',
-      }
+        summary: "Manager Gemini - Management agent disabled",
+        fullReport: "Management agent disabled via configuration",
+      };
     }
 
     // Skip if no memories
@@ -710,13 +433,13 @@ Please process these memories according to your management procedure. Use the ex
         filesWritten: 0,
         primerUpdated: false,
         actions: [],
-        summary: 'No memories to process',
-        fullReport: 'No memories to process - skipped',
-      }
+        summary: "Manager Gemini - No memories to process",
+        fullReport: "No memories to process - skipped",
+      };
     }
 
     // Load skill file
-    const systemPrompt = await this.buildManagementPrompt()
+    const systemPrompt = await this.buildManagementPrompt();
     if (!systemPrompt) {
       return {
         success: false,
@@ -727,16 +450,28 @@ Please process these memories according to your management procedure. Use the ex
         filesWritten: 0,
         primerUpdated: false,
         actions: [],
-        summary: '',
-        fullReport: 'Error: Management skill file not found',
-        error: 'Management skill not found',
-      }
+        summary: "",
+        fullReport:
+          "Manager Gemini - Error: Management skill not file not found",
+        error: "Management skill not found",
+      };
     }
 
-    const userMessage = this.buildUserMessage(projectId, sessionNumber, result, storagePaths)
-
-    // Write system prompt to temp file
-    // Include Gemini's tool variables so the manager has access to file tools
+    const userMessage = this.buildUserMessage(
+      projectId,
+      sessionNumber,
+      result,
+      storagePaths,
+    );
+
+    // Resolve paths using centralized utilities
+    const managerCwd = getManagerCwd(storagePaths);
+    const projectPath =
+      storagePaths?.projectPath ?? join(getCentralStoragePath(), projectId);
+    const globalPath =
+      storagePaths?.globalPath ?? join(getCentralStoragePath(), "global");
+
+    // Write system prompt to temp file (tmpdir always exists)
     const geminiSystemPrompt = `${systemPrompt}
 
 ## Available Tools
@@ -746,65 +481,112 @@ You have access to the following tools to manage memory files:
 \${AvailableTools}
 
 Use these tools to read existing memories, write updates, and manage the memory filesystem.
-`
-    const tempPromptPath = join(homedir(), '.local', 'share', 'memory', '.gemini-manager-prompt.md')
+`;
+    const tempPromptPath = getManagerPromptPath();
+    await Bun.write(tempPromptPath, geminiSystemPrompt);
 
-    // Ensure directory exists
-    const tempDir = join(homedir(), '.local', 'share', 'memory')
-    if (!existsSync(tempDir)) {
-      const { mkdirSync } = await import('fs')
-      mkdirSync(tempDir, { recursive: true })
-    }
+    // Copy user's Gemini settings to managerCwd with hooks disabled
+    // This prevents the manager's session from triggering hooks recursively
+    const userSettingsPath = join(homedir(), ".gemini", "settings.json");
+    const managerSettingsDir = join(managerCwd, ".gemini");
+    const managerSettingsPath = join(managerSettingsDir, "settings.json");
 
-    await Bun.write(tempPromptPath, geminiSystemPrompt)
+    try {
+      // Disable memory hooks to prevent recursive curation
+      // Format: hooks.disabled array with hook command names
+      const settings = {
+        hooks: {
+          disabled: [
+            "inject-memories",
+            "load-session-primer",
+            "curate-memories",
+            "curate-memories",
+          ],
+        },
+      };
 
-    logger.debug(`Manager Gemini: Starting management for project ${projectId}`, 'manager')
-    logger.debug(`Manager Gemini: Processing ${result.memories.length} memories`, 'manager')
-    logger.debug(`Manager Gemini: Including directory: ${join(homedir(), '.local', 'share', 'memory')}`, 'manager')
+      // Ensure .gemini directory exists in managerCwd
+      if (!existsSync(managerSettingsDir)) {
+        const { mkdirSync } = await import("fs");
+        mkdirSync(managerSettingsDir, { recursive: true });
+      }
 
-    // Build CLI command (no --resume needed, manager operates on provided data)
-    // CRITICAL: Add --include-directories to allow Gemini to access memory storage
-    // Without this, Gemini is sandboxed to the project directory and can't read/write memories
-    const memoryStoragePath = join(homedir(), '.local', 'share', 'memory')
-    const args = [
-      '-p', userMessage,
-      '--output-format', 'json',
-      '--yolo',  // Auto-approve file operations
-      '--include-directories', memoryStoragePath,  // Allow access to memory storage
-    ]
+      await Bun.write(managerSettingsPath, JSON.stringify(settings, null, 2));
+      logger.debug(
+        `Manager Gemini: Created settings with hooks disabled at ${managerSettingsPath}`,
+        "manager",
+      );
+    } catch (err: any) {
+      logger.debug(
+        `Manager Gemini: Could not create settings file: ${err.message}`,
+        "manager",
+      );
+    }
 
-    logger.debug(`Manager Gemini: Spawning gemini CLI`, 'manager')
-    logger.debug(`Manager Gemini: Running from directory: ${memoryStoragePath}`, 'manager')
+    logger.debug(
+      `Manager Gemini - Starting management for project ${projectId}`,
+      "manager",
+    );
+    logger.debug(
+      `Manager Gemini - Processing ${result.memories.length} memories`,
+      "manager",
+    );
+    logger.debug(
+      `Manager Gemini - Storage mode: ${getStorageMode(storagePaths)}, cwd: ${managerCwd}`,
+      "manager",
+    );
+
+    // Build CLI command
+    // - cwd gives write access to that tree
+    // - --include-directories adds read access to other paths
+    const args = [
+      "-p",
+      userMessage,
+      "--output-format",
+      "json",
+      "--yolo", // Auto-approve file operations
+      "--include-directories",
+      projectPath,
+      "--include-directories",
+      globalPath,
+    ];
+
+    logger.debug(
+      `Manager Gemini: Spawning gemini CLI from ${managerCwd}`,
+      "manager",
+    );
 
     // Execute CLI with system prompt via environment variable
-    // CRITICAL: Run from memory storage directory so it becomes the primary workspace
-    // This allows both READ and WRITE operations (--include-directories only allows reads)
-    const proc = Bun.spawn(['gemini', ...args], {
-      cwd: memoryStoragePath,  // Run FROM memory directory to allow writes
+    // cwd determines write access, --include-directories adds read access
+    const proc = Bun.spawn(["gemini", ...args], {
+      cwd: managerCwd,
       env: {
         ...process.env,
-        MEMORY_CURATOR_ACTIVE: '1',  // Prevent recursive hook triggering
-        GEMINI_SYSTEM_MD: tempPromptPath,  // Inject our management prompt
+        MEMORY_CURATOR_ACTIVE: "1", // Prevent recursive hook triggering
+        GEMINI_SYSTEM_MD: tempPromptPath, // Inject our management prompt
       },
-      stdout: 'pipe',
-      stderr: 'pipe',
-    })
+      stdout: "pipe",
+      stderr: "pipe",
+    });
 
     // Capture output
     const [stdout, stderr] = await Promise.all([
       new Response(proc.stdout).text(),
       new Response(proc.stderr).text(),
-    ])
-    const exitCode = await proc.exited
+    ]);
+    const exitCode = await proc.exited;
 
-    logger.debug(`Manager Gemini: Exit code ${exitCode}`, 'manager')
+    logger.debug(`Manager Gemini - Exit code ${exitCode}`, "manager");
     if (stderr && stderr.trim()) {
-      logger.debug(`Manager Gemini stderr: ${stderr}`, 'manager')
+      logger.debug(`Manager Gemini - stderr: ${stderr}`, "manager");
     }
 
     if (exitCode !== 0) {
-      logger.debug(`Manager Gemini: Failed with exit code ${exitCode}`, 'manager')
-      const errorMsg = stderr || `Exit code ${exitCode}`
+      logger.debug(
+        `Manager Gemini - Failed with exit code ${exitCode}`,
+        "manager",
+      );
+      const errorMsg = stderr || `Exit code ${exitCode}`;
       return {
         success: false,
         superseded: 0,
@@ -814,22 +596,31 @@ Use these tools to read existing memories, write updates, and manage the memory
         filesWritten: 0,
         primerUpdated: false,
         actions: [],
-        summary: '',
-        fullReport: `Error: Gemini CLI failed with exit code ${exitCode}\n${stderr}`,
+        summary: "",
+        fullReport: `Manager Gemini - Error: Gemini CLI failed with exit code ${exitCode}\n${stderr}`,
         error: errorMsg,
-      }
+      };
     }
 
     // Parse Gemini JSON output
     // Note: Gemini CLI outputs log messages before AND after the JSON
     // We need to extract just the JSON object
-    logger.debug(`Manager Gemini: Parsing response (${stdout.length} chars)`, 'manager')
+    logger.debug(
+      `Manager Gemini - Parsing response (${stdout.length} chars)`,
+      "manager",
+    );
     try {
       // Find the JSON object - it starts with { and we need to find the matching }
-      const jsonStart = stdout.indexOf('{')
+      const jsonStart = stdout.indexOf("{");
       if (jsonStart === -1) {
-        logger.debug('Manager Gemini: No JSON object found in output', 'manager')
-        logger.debug(`Manager Gemini: Raw stdout: ${stdout.slice(0, 500)}`, 'manager')
+        logger.debug(
+          "Manager Gemini - No JSON object found in output",
+          "manager",
+        );
+        // logger.debug(
+        //   `Manager Gemini - Raw stdout: ${stdout.slice(0, 500)}`,
+        //   "manager",
+        // );
         return {
           success: false,
           superseded: 0,
@@ -839,25 +630,29 @@ Use these tools to read existing memories, write updates, and manage the memory
           filesWritten: 0,
           primerUpdated: false,
           actions: [],
-          summary: 'No JSON in Gemini response',
-          fullReport: 'Manager failed: No JSON object in Gemini CLI output',
-        }
+          summary: "Manager Gemini - No JSON in Gemini response",
+          fullReport:
+            "Manager Gemini - Failed: No JSON object in Gemini CLI output",
+        };
       }
 
       // Find the matching closing brace by counting braces
-      let braceCount = 0
-      let jsonEnd = -1
+      let braceCount = 0;
+      let jsonEnd = -1;
       for (let i = jsonStart; i < stdout.length; i++) {
-        if (stdout[i] === '{') braceCount++
-        if (stdout[i] === '}') braceCount--
+        if (stdout[i] === "{") braceCount++;
+        if (stdout[i] === "}") braceCount--;
         if (braceCount === 0) {
-          jsonEnd = i + 1
-          break
+          jsonEnd = i + 1;
+          break;
         }
       }
 
       if (jsonEnd === -1) {
-        logger.debug('Manager Gemini: Could not find matching closing brace', 'manager')
+        logger.debug(
+          "Manager Gemini - Could not find matching closing brace",
+          "manager",
+        );
         return {
           success: false,
           superseded: 0,
@@ -867,21 +662,25 @@ Use these tools to read existing memories, write updates, and manage the memory
           filesWritten: 0,
           primerUpdated: false,
           actions: [],
-          summary: 'Incomplete JSON in Gemini response',
-          fullReport: 'Manager failed: Could not find complete JSON object',
-        }
+          summary: "Manager Gemini - Incomplete JSON in Gemini response",
+          fullReport:
+            "Manager Gemini - Failed: Could not find complete JSON object",
+        };
       }
 
-      const jsonStr = stdout.slice(jsonStart, jsonEnd)
-      logger.debug(`Manager Gemini: Extracted JSON (${jsonStr.length} chars)`, 'manager')
+      const jsonStr = stdout.slice(jsonStart, jsonEnd);
+      logger.debug(
+        `Manager Gemini - Extracted JSON (${jsonStr.length} chars)`,
+        "manager",
+      );
 
-      const geminiOutput = JSON.parse(jsonStr)
+      const geminiOutput = JSON.parse(jsonStr);
 
       // Gemini returns { response: "...", stats: {...} }
-      const aiResponse = geminiOutput.response || ''
+      const aiResponse = geminiOutput.response || "";
 
       if (!aiResponse) {
-        logger.debug('Manager Gemini: No response field in output', 'manager')
+        logger.debug("Manager Gemini - No response field in output", "manager");
         return {
           success: true,
           superseded: 0,
@@ -891,20 +690,29 @@ Use these tools to read existing memories, write updates, and manage the memory
           filesWritten: 0,
           primerUpdated: false,
           actions: [],
-          summary: 'No response from Gemini',
-          fullReport: 'Management completed but no response returned',
-        }
+          summary: "Managetr Gemini - No response from Gemini",
+          fullReport: "Management completed but no response returned",
+        };
       }
 
-      logger.debug(`Manager Gemini: Got response (${aiResponse.length} chars)`, 'manager')
+      logger.debug(
+        `Manager Gemini - Got response (${aiResponse.length} chars)`,
+        "manager",
+      );
 
       // Parse using our existing SDK parser (same format expected)
-      const result = this._parseSDKManagementResult(aiResponse)
-      logger.debug(`Manager Gemini: Parsed result - superseded: ${result.superseded}, resolved: ${result.resolved}, linked: ${result.linked}`, 'manager')
-      return result
+      const result = this._parseSDKManagementResult(aiResponse);
+      logger.debug(
+        `Manager Gemini - Parsed result - superseded: ${result.superseded}, resolved: ${result.resolved}, linked: ${result.linked}`,
+        "manager",
+      );
+      return result;
     } catch (error: any) {
-      logger.debug(`Manager Gemini: Parse error: ${error.message}`, 'manager')
-      logger.debug(`Manager Gemini: Raw stdout (first 500 chars): ${stdout.slice(0, 500)}`, 'manager')
+      logger.debug(`Manager Gemini - Parse error: ${error.message}`, "manager");
+      logger.debug(
+        `Manager Gemini - Raw stdout (first 500 chars): ${stdout.slice(0, 500)}`,
+        "manager",
+      );
       return {
         success: false,
         superseded: 0,
@@ -914,10 +722,10 @@ Use these tools to read existing memories, write updates, and manage the memory
         filesWritten: 0,
         primerUpdated: false,
         actions: [],
-        summary: '',
-        fullReport: `Error: Failed to parse Gemini response: ${error.message}`,
+        summary: "",
+        fullReport: `Manager Gemini - Error: Failed to parse Gemini response: ${error.message}`,
         error: error.message,
-      }
+      };
     }
   }
 }
@@ -926,5 +734,5 @@ Use these tools to read existing memories, write updates, and manage the memory
  * Create a new manager
  */
 export function createManager(config?: ManagerConfig): Manager {
-  return new Manager(config)
+  return new Manager(config);
 }