4 files changed, 61 insertions, 130 deletions

diff --git a/src/main/claude/index.ts b/src/main/claude/index.ts
index 4d8909b..b8c9c07 100644
--- a/src/main/claude/index.ts
+++ b/src/main/claude/index.ts
@@ -6,16 +6,28 @@ import { getProject } from "../db/projects";
 import { updateSession } from "../db/sessions";
 import fs from "node:fs";
 import path from "node:path";
+import os from "node:os";
 
 // Track active queries by session ID
 const activeQueries = new Map<string, Query>();
 
+// Global storage in home directory
+const GLOBAL_CLAUDE_FLOW_DIR = path.join(os.homedir(), ".claude-flow");
+
 function ensureDir(dirPath: string): void {
   if (!fs.existsSync(dirPath)) {
     fs.mkdirSync(dirPath, { recursive: true });
   }
 }
 
+function getProjectDir(projectId: string): string {
+  return path.join(GLOBAL_CLAUDE_FLOW_DIR, "projects", projectId);
+}
+
+function getSessionDir(projectId: string, sessionId: string): string {
+  return path.join(getProjectDir(projectId), "sessions", sessionId);
+}
+
 export interface SendMessageOptions {
   session: Session;
   message: string;
@@ -30,8 +42,8 @@ export async function sendMessage({
   const project = getProject(session.project_id);
   if (!project) throw new Error("Project not found");
 
-  // Ensure session artifact directory exists
-  const sessionDir = path.join(project.path, getSessionArtifactDir(session.id));
+  // Ensure session artifact directory exists in global storage
+  const sessionDir = getSessionDir(session.project_id, session.id);
   ensureDir(sessionDir);
 
   const phaseConfig = getPhaseConfig(
@@ -100,22 +112,22 @@ export function advancePhase(session: Session): Phase | null {
 }
 
 /**
- * Get the artifact path for a session and phase
+ * Get the artifact path for a session and phase (in global storage)
  */
 export function getArtifactPath(session: Session): string {
   const filename = getArtifactFilename(session.phase as Phase);
-  return path.join(getSessionArtifactDir(session.id), filename);
+  return path.join(getSessionDir(session.project_id, session.id), filename);
 }
 
 /**
- * Read an artifact file for a session
+ * Read an artifact file for a session (from global storage)
  */
 export function readSessionArtifact(
-  projectPath: string,
+  projectId: string,
   sessionId: string,
   filename: string
 ): string | null {
-  const filePath = path.join(projectPath, getSessionArtifactDir(sessionId), filename);
+  const filePath = path.join(getSessionDir(projectId, sessionId), filename);
   if (fs.existsSync(filePath)) {
     return fs.readFileSync(filePath, "utf-8");
   }
@@ -123,15 +135,15 @@ export function readSessionArtifact(
 }
 
 /**
- * Write an artifact file for a session
+ * Write an artifact file for a session (to global storage)
  */
 export function writeSessionArtifact(
-  projectPath: string,
+  projectId: string,
   sessionId: string,
   filename: string,
   content: string
 ): void {
-  const dir = path.join(projectPath, getSessionArtifactDir(sessionId));
+  const dir = getSessionDir(projectId, sessionId);
   ensureDir(dir);
   fs.writeFileSync(path.join(dir, filename), content, "utf-8");
 }
@@ -156,37 +168,10 @@ export function writeClaudeMd(projectPath: string, content: string): void {
 }
 
 /**
- * Read an artifact file from the project's .claude-flow directory (legacy path)
- */
-export function readArtifact(
-  projectPath: string,
-  filename: string
-): string | null {
-  const filePath = path.join(projectPath, ".claude-flow", filename);
-  if (fs.existsSync(filePath)) {
-    return fs.readFileSync(filePath, "utf-8");
-  }
-  return null;
-}
-
-/**
- * Write an artifact file to the project's .claude-flow directory (legacy path)
- */
-export function writeArtifact(
-  projectPath: string,
-  filename: string,
-  content: string
-): void {
-  const dir = path.join(projectPath, ".claude-flow");
-  ensureDir(dir);
-  fs.writeFileSync(path.join(dir, filename), content, "utf-8");
-}
-
-/**
- * Clear session artifacts
+ * Clear session artifacts from global storage
  */
-export function clearSessionArtifacts(projectPath: string, sessionId: string): void {
-  const dir = path.join(projectPath, getSessionArtifactDir(sessionId));
+export function clearSessionArtifacts(projectId: string, sessionId: string): void {
+  const dir = getSessionDir(projectId, sessionId);
   if (fs.existsSync(dir)) {
     fs.rmSync(dir, { recursive: true, force: true });
   }
diff --git a/src/main/claude/phases.ts b/src/main/claude/phases.ts
index 6678c08..f1df719 100644
--- a/src/main/claude/phases.ts
+++ b/src/main/claude/phases.ts
@@ -10,9 +10,9 @@ export interface PhaseConfig {
   initialMessage: string;
 }
 
-// Get session-specific artifact path
+// Get session-specific artifact path (relative to ~/.claude-flow/)
 export function getSessionArtifactDir(sessionId: string): string {
-  return `.claude-flow/sessions/${sessionId}`;
+  return `sessions/${sessionId}`;
 }
 
 export function getArtifactPath(phase: Phase, sessionId: string): string {
@@ -30,7 +30,7 @@ export const phaseConfigs: Record<Phase, PhaseConfig> = {
     systemPrompt: `You are in RESEARCH mode. Your ONLY job is to understand the codebase.
 
 CRITICAL RULES:
-1. You MUST write ALL findings to \`.claude-flow/sessions/{sessionId}/research.md\` — this is your PRIMARY output
+1. You MUST write ALL findings to the session research.md — this is your PRIMARY output
 2. DO NOT just respond in chat. The document viewer shows research.md, so write there.
 3. DO NOT suggest moving to planning or implementation
 4. DO NOT ask "are you ready to implement?" or similar
@@ -38,16 +38,15 @@ CRITICAL RULES:
 6. The user controls phase transitions via UI buttons — never prompt them about it
 
 CONTEXT:
-- You are in a git worktree at \`.claude-flow/worktrees/{sessionId}/\`
-- Read CLAUDE.md in the project root for shared codebase overview
-- If CLAUDE.md doesn't exist, create it with your initial findings
+- Read CLAUDE.md in the project root (if it exists) for codebase overview
 - This file contains general architecture info shared across all sessions
+- If CLAUDE.md doesn't exist, create it with your initial findings
 
 WORKFLOW:
 1. Read CLAUDE.md (create at project root if missing)
 2. Ask what to research (if unclear)
 3. Read files thoroughly using Read, Glob, Grep
-4. Write findings to \`.claude-flow/sessions/{sessionId}/research.md\`
+4. Write findings to session research.md
 5. Update CLAUDE.md with any new general insights worth sharing
 
 FORMAT for research.md:
@@ -70,7 +69,7 @@ FORMAT for research.md:
 [Things that need clarification]
 \`\`\`
 
-Remember: Your output goes in \`.claude-flow/sessions/{sessionId}/research.md\`, not chat. Chat is for clarifying questions only.`,
+Remember: Your output goes in research.md, not chat. Chat is for clarifying questions only.`,
   },
 
   plan: {
@@ -81,7 +80,7 @@ Remember: Your output goes in \`.claude-flow/sessions/{sessionId}/research.md\`,
     systemPrompt: `You are in PLANNING mode. Your ONLY job is to create an implementation plan.
 
 CRITICAL RULES:
-1. You MUST write the plan to \`.claude-flow/sessions/{sessionId}/plan.md\` — this is your PRIMARY output
+1. You MUST write the plan to session plan.md — this is your PRIMARY output
 2. DO NOT just respond in chat. The document viewer shows plan.md, so write there.
 3. DO NOT implement anything — no code changes to source files
 4. DO NOT ask "should I start implementing?" or similar
@@ -89,14 +88,13 @@ CRITICAL RULES:
 6. Base your plan on the session research.md and CLAUDE.md
 
 CONTEXT:
-- You are in a git worktree at \`.claude-flow/worktrees/{sessionId}/\`
 - Read CLAUDE.md at project root for codebase overview
-- Read \`.claude-flow/sessions/{sessionId}/research.md\` for this specific task
+- Read the session research.md to understand the specific task
 
 WORKFLOW:
 1. Read CLAUDE.md for codebase overview
 2. Read the session research.md to understand the specific task
-3. Write a detailed plan to \`.claude-flow/sessions/{sessionId}/plan.md\`
+3. Write a detailed plan to session plan.md
 4. Include specific code snippets showing proposed changes
 5. Make the plan detailed enough that implementation is mechanical
 
@@ -134,47 +132,30 @@ FORMAT for plan.md:
 
 When the user adds annotations to plan.md and clicks Review, address each annotation and update the document.
 
-Remember: Your output goes in \`.claude-flow/sessions/{sessionId}/plan.md\`, not chat. Chat is for clarifying questions only.`,
+Remember: Your output goes in plan.md, not chat. Chat is for clarifying questions only.`,
   },
 
   implement: {
     permissionMode: "acceptEdits",
     tools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"],
     initialMessage:
-      "Starting implementation. I'll follow the plan exactly, commit as I go, and mark tasks complete.",
+      "Starting implementation. I'll follow the plan exactly and mark tasks complete as I go.",
     systemPrompt: `You are in IMPLEMENTATION mode. Execute the approved plan.
 
 CRITICAL RULES:
-1. Read \`.claude-flow/sessions/{sessionId}/plan.md\` and follow it exactly
+1. Read session plan.md and follow it exactly
 2. Mark tasks complete in plan.md as you finish them: - [ ] → - [x]
 3. DO NOT deviate from the plan without asking
 4. Run tests/typecheck if available
-5. Make git commits as you complete logical chunks of work
-6. Stop and ask if you encounter issues not covered by the plan
-
-CONTEXT:
-- You are in a git worktree at \`.claude-flow/worktrees/{sessionId}/\`
-- This is an isolated branch: \`claude-flow/{sessionId}\`
-- Your commits will not affect the main branch until merged
-- The user can review your work in this worktree before accepting
+5. Stop and ask if you encounter issues not covered by the plan
 
 WORKFLOW:
-1. Read \`.claude-flow/sessions/{sessionId}/plan.md\`
+1. Read session plan.md
 2. Execute each task in order
 3. Update plan.md to mark tasks complete
-4. Make git commits with clear messages as you finish chunks
-5. Continue until all tasks are done
-
-COMMIT GUIDELINES:
-- Commit after completing logical units of work
-- Use clear commit messages (e.g., "Add user authentication middleware")
-- Don't commit broken or incomplete code
-- Update CLAUDE.md at project root if you discover important architecture info
-
-When complete, summarize what was done and tell the user how to review:
-- The work is in worktree: \`.claude-flow/worktrees/{sessionId}/\`
-- Branch: \`claude-flow/{sessionId}\`
-- They can review, then merge or discard as needed`,
+4. Continue until all tasks are done
+
+When complete, summarize what was done and any follow-up tasks.`,
   },
 };
 
diff --git a/src/main/ipc/handlers.ts b/src/main/ipc/handlers.ts
index 2d5e3d3..d9beaf0 100644
--- a/src/main/ipc/handlers.ts
+++ b/src/main/ipc/handlers.ts
@@ -26,11 +26,8 @@ export function registerIpcHandlers(mainWindow: BrowserWindow): void {
   ipcMain.handle("sessions:delete", (_, id: string) => {
     const session = sessions.getSession(id);
     if (session) {
-      const project = projects.getProject(session.project_id);
-      if (project) {
-        // Clean up session artifacts
-        claude.clearSessionArtifacts(project.path, id);
-      }
+      // Clean up session artifacts from global storage
+      claude.clearSessionArtifacts(session.project_id, id);
     }
     sessions.deleteSession(id);
   });
@@ -103,22 +100,22 @@ export function registerIpcHandlers(mainWindow: BrowserWindow): void {
     }
   );
 
-  // Session Artifacts (new session-specific API)
+  // Session Artifacts (stored in ~/.claude-flow/)
   ipcMain.handle(
     "artifact:readSession",
-    (_, projectPath: string, sessionId: string, filename: string) => {
-      return claude.readSessionArtifact(projectPath, sessionId, filename);
+    (_, projectId: string, sessionId: string, filename: string) => {
+      return claude.readSessionArtifact(projectId, sessionId, filename);
     }
   );
 
   ipcMain.handle(
     "artifact:writeSession",
-    (_, projectPath: string, sessionId: string, filename: string, content: string) => {
-      claude.writeSessionArtifact(projectPath, sessionId, filename, content);
+    (_, projectId: string, sessionId: string, filename: string, content: string) => {
+      claude.writeSessionArtifact(projectId, sessionId, filename, content);
     }
   );
 
-  // CLAUDE.md
+  // CLAUDE.md (stored in project)
   ipcMain.handle("claudemd:read", (_, projectPath: string) => {
     return claude.readClaudeMd(projectPath);
   });
@@ -127,21 +124,6 @@ export function registerIpcHandlers(mainWindow: BrowserWindow): void {
     claude.writeClaudeMd(projectPath, content);
   });
 
-  // Legacy artifact API (for backward compatibility)
-  ipcMain.handle(
-    "artifact:read",
-    (_, projectPath: string, filename: string) => {
-      return claude.readArtifact(projectPath, filename);
-    }
-  );
-
-  ipcMain.handle(
-    "artifact:write",
-    (_, projectPath: string, filename: string, content: string) => {
-      claude.writeArtifact(projectPath, filename, content);
-    }
-  );
-
   // Dialogs
   ipcMain.handle("dialog:selectDirectory", async () => {
     const result = await dialog.showOpenDialog(mainWindow, {
diff --git a/src/main/preload.ts b/src/main/preload.ts
index 7c1d634..2c228dd 100644
--- a/src/main/preload.ts
+++ b/src/main/preload.ts
@@ -31,34 +31,23 @@ export interface ClaudeFlowAPI {
     mode: UserPermissionMode
   ) => Promise<void>;
 
-  // Session Artifacts (session-specific)
+  // Session Artifacts (stored in ~/.claude-flow/)
   readSessionArtifact: (
-    projectPath: string,
+    projectId: string,
     sessionId: string,
     filename: string
   ) => Promise<string | null>;
   writeSessionArtifact: (
-    projectPath: string,
+    projectId: string,
     sessionId: string,
     filename: string,
     content: string
   ) => Promise<void>;
 
-  // CLAUDE.md
+  // CLAUDE.md (stored in project)
   readClaudeMd: (projectPath: string) => Promise<string | null>;
   writeClaudeMd: (projectPath: string, content: string) => Promise<void>;
 
-  // Legacy Artifacts (backward compat)
-  readArtifact: (
-    projectPath: string,
-    filename: string
-  ) => Promise<string | null>;
-  writeArtifact: (
-    projectPath: string,
-    filename: string,
-    content: string
-  ) => Promise<void>;
-
   // Events
   onClaudeMessage: (
     callback: (sessionId: string, message: SDKMessage) => void
@@ -97,23 +86,17 @@ const api: ClaudeFlowAPI = {
   setPermissionMode: (sessionId, mode) =>
     ipcRenderer.invoke("workflow:setPermissionMode", sessionId, mode),
 
-  // Session Artifacts
-  readSessionArtifact: (projectPath, sessionId, filename) =>
-    ipcRenderer.invoke("artifact:readSession", projectPath, sessionId, filename),
-  writeSessionArtifact: (projectPath, sessionId, filename, content) =>
-    ipcRenderer.invoke("artifact:writeSession", projectPath, sessionId, filename, content),
+  // Session Artifacts (stored in ~/.claude-flow/)
+  readSessionArtifact: (projectId, sessionId, filename) =>
+    ipcRenderer.invoke("artifact:readSession", projectId, sessionId, filename),
+  writeSessionArtifact: (projectId, sessionId, filename, content) =>
+    ipcRenderer.invoke("artifact:writeSession", projectId, sessionId, filename, content),
 
-  // CLAUDE.md
+  // CLAUDE.md (stored in project)
   readClaudeMd: (projectPath) => ipcRenderer.invoke("claudemd:read", projectPath),
   writeClaudeMd: (projectPath, content) =>
     ipcRenderer.invoke("claudemd:write", projectPath, content),
 
-  // Legacy Artifacts
-  readArtifact: (projectPath, filename) =>
-    ipcRenderer.invoke("artifact:read", projectPath, filename),
-  writeArtifact: (projectPath, filename, content) =>
-    ipcRenderer.invoke("artifact:write", projectPath, filename, content),
-
   // Events
   onClaudeMessage: (callback) => {
     const handler = (