@sylphx/flow 3.18.0 → 3.19.0

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # @sylphx/flow
 
+## 3.19.0 (2026-02-07)
+
+Performance, stability, and test coverage overhaul
+
+**Performance:**
+- Replace blocking `execSync('which')` with async `exec()` + `Promise.all()`
+- Batch git operations (N shell spawns → 1 per operation)
+- Parallelize I/O across startup path (`Promise.all` for mkdir, unlink, fs.cp)
+- Skip heavy cleanup scans on startup when not needed (24h marker)
+
+**Bug fixes:**
+- Fix signal handler conflict causing storage accumulation (root cause: `process.exit(0)` preempted async cleanup)
+- Fix skip-worktree flag leak on crash (read from git index instead of in-memory state)
+- Fix secrets never cleared on session end
+- Fix constructor ordering bug (`gitStashManager` used before initialized)
+- Centralize all cleanup into CleanupHandler (signal, manual, crash recovery paths)
+
+**Storage lifecycle:**
+- Add orphaned project detection and cleanup
+- Add session history pruning (keep last 50)
+- Add periodic cleanup gating (at most once per 24h)
+
+**Tests:**
+- 30 → 81 tests (170% increase)
+- New test suites: cleanup-handler, git-stash-manager, session-cleanup, secrets-manager
+
+**Cleanup:**
+- Remove 432 lines of dead code across 26 files
+
+### ✨ Features
+
+- **flow:** performance, stability, and test coverage overhaul ([16c461f](https://github.com/SylphxAI/flow/commit/16c461f509d800d7456d933d3153078ded6d5669))
+
+### 🐛 Bug Fixes
+
+- **flow:** inject env vars into spawned process instead of writing files ([51f037e](https://github.com/SylphxAI/flow/commit/51f037e0a5fed8b24271528efa9cc16f0409bb2a))
+
+### 💅 Styles
+
+- **flow:** format package.json with biome (tabs → spaces) ([3206303](https://github.com/SylphxAI/flow/commit/320630301d8b85813f96b36e737b5d0b01b23793))
+
 ## 3.18.0 (2026-02-07)
 
 Enable agent teams by default for Claude Code

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/flow",
-	"version": "3.18.0",
+	"version": "3.19.0",
 	"description": "One CLI to rule them all. Unified orchestration layer for AI coding assistants. Auto-detection, auto-installation, auto-upgrade.",
 	"type": "module",
 	"bin": {

package/src/config/targets.ts

@@ -93,7 +93,7 @@ export const getDefaultTargetUnsafe = (): Target => {
  * Get targets that support MCP servers
  */
 export const getTargetsWithMCPSupport = (): readonly Target[] =>
-  getImplementedTargets().filter((target) => !!target.setupMCP);
+  getImplementedTargets().filter((target) => !!target.config.supportsMCP);
 
 /**
  * Get targets that support command execution (agent running)

package/src/core/__tests__/backup-restore.test.ts

@@ -47,7 +47,7 @@ describe('Backup → Attach → Restore Lifecycle', () => {
     (projectManager as any).flowDataDir = flowDataDir;
 
     backupManager = new BackupManager(projectManager);
-    attachManager = new AttachManager(projectManager);
+    attachManager = new AttachManager();
 
     // Get project hash
     projectHash = projectManager.getProjectHash(projectPath);

package/src/core/__tests__/cleanup-handler.test.ts

@@ -0,0 +1,292 @@
+/**
+ * Tests for CleanupHandler
+ * Covers: signal cleanup, crash recovery, orphaned project detection,
+ * periodic cleanup gating, and session history pruning coordination
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { CleanupHandler } from '../cleanup-handler.js';
+
+// --- Mock factories ---
+
+function createMockProjectManager(flowHome: string) {
+  return {
+    getFlowHomeDir: () => flowHome,
+    getProjectPaths: (hash: string) => ({
+      sessionFile: path.join(flowHome, 'sessions', `${hash}.json`),
+      backupsDir: path.join(flowHome, 'backups', hash),
+      secretsDir: path.join(flowHome, 'secrets', hash),
+      latestBackup: path.join(flowHome, 'backups', hash, 'latest'),
+    }),
+  };
+}
+
+function createMockSessionManager() {
+  return {
+    detectOrphanedSessions: vi.fn().mockResolvedValue(new Map()),
+    endSession: vi.fn().mockResolvedValue({ shouldRestore: false, session: null }),
+    recoverSession: vi.fn().mockResolvedValue(undefined),
+    getActiveSession: vi.fn().mockResolvedValue(null),
+    cleanupSessionHistory: vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+function createMockBackupManager() {
+  return {
+    restoreBackup: vi.fn().mockResolvedValue(undefined),
+    cleanupOldBackups: vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+function createMockGitStashManager() {
+  return {
+    popSettingsChanges: vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+function createMockSecretsManager() {
+  return {
+    clearSecrets: vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+describe('CleanupHandler', () => {
+  let tempDir: string;
+  let flowHome: string;
+  let handler: CleanupHandler;
+  let mockProjectManager: ReturnType<typeof createMockProjectManager>;
+  let mockSessionManager: ReturnType<typeof createMockSessionManager>;
+  let mockBackupManager: ReturnType<typeof createMockBackupManager>;
+  let mockGitStash: ReturnType<typeof createMockGitStashManager>;
+  let mockSecrets: ReturnType<typeof createMockSecretsManager>;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'flow-cleanup-test-'));
+    flowHome = path.join(tempDir, '.sylphx-flow');
+    fs.mkdirSync(path.join(flowHome, 'sessions'), { recursive: true });
+    fs.mkdirSync(path.join(flowHome, 'backups'), { recursive: true });
+    fs.mkdirSync(path.join(flowHome, 'secrets'), { recursive: true });
+
+    mockProjectManager = createMockProjectManager(flowHome);
+    mockSessionManager = createMockSessionManager();
+    mockBackupManager = createMockBackupManager();
+    mockGitStash = createMockGitStashManager();
+    mockSecrets = createMockSecretsManager();
+
+    handler = new CleanupHandler(
+      mockProjectManager as any,
+      mockSessionManager as any,
+      mockBackupManager as any,
+      mockGitStash as any,
+      mockSecrets as any
+    );
+  });
+
+  afterEach(() => {
+    if (tempDir && fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  // --- cleanup() ---
+
+  describe('cleanup()', () => {
+    it('should restore backup and clean up when last session ends', async () => {
+      const session = { sessionId: 'session-1', projectPath: '/tmp/project' };
+      mockSessionManager.endSession.mockResolvedValue({ shouldRestore: true, session });
+
+      await handler.cleanup('abc123');
+
+      expect(mockBackupManager.restoreBackup).toHaveBeenCalledWith('abc123', 'session-1');
+      expect(mockBackupManager.cleanupOldBackups).toHaveBeenCalledWith('abc123', 3);
+      expect(mockGitStash.popSettingsChanges).toHaveBeenCalledWith('/tmp/project');
+      expect(mockSecrets.clearSecrets).toHaveBeenCalledWith('abc123');
+    });
+
+    it('should not restore when other sessions still active', async () => {
+      mockSessionManager.endSession.mockResolvedValue({ shouldRestore: false, session: null });
+
+      await handler.cleanup('abc123');
+
+      expect(mockBackupManager.restoreBackup).not.toHaveBeenCalled();
+      expect(mockGitStash.popSettingsChanges).not.toHaveBeenCalled();
+      expect(mockSecrets.clearSecrets).not.toHaveBeenCalled();
+    });
+  });
+
+  // --- recoverOnStartup() ---
+
+  describe('recoverOnStartup()', () => {
+    it('should recover orphaned sessions', async () => {
+      const session = {
+        sessionId: 'session-crashed',
+        projectPath: '/tmp/crashed-project',
+        projectHash: 'hash1',
+      };
+      const orphaned = new Map([['hash1', session]]);
+      mockSessionManager.detectOrphanedSessions.mockResolvedValue(orphaned);
+
+      await handler.recoverOnStartup();
+
+      expect(mockBackupManager.restoreBackup).toHaveBeenCalledWith('hash1', 'session-crashed');
+      expect(mockSessionManager.recoverSession).toHaveBeenCalledWith('hash1', session);
+      expect(mockGitStash.popSettingsChanges).toHaveBeenCalledWith('/tmp/crashed-project');
+      expect(mockSecrets.clearSecrets).toHaveBeenCalledWith('hash1');
+      expect(mockBackupManager.cleanupOldBackups).toHaveBeenCalledWith('hash1', 3);
+    });
+
+    it('should handle multiple orphaned sessions independently', async () => {
+      const session1 = { sessionId: 's1', projectPath: '/p1' };
+      const session2 = { sessionId: 's2', projectPath: '/p2' };
+      const orphaned = new Map([
+        ['h1', session1],
+        ['h2', session2],
+      ]);
+      mockSessionManager.detectOrphanedSessions.mockResolvedValue(orphaned);
+
+      // Make first recovery fail
+      mockBackupManager.restoreBackup
+        .mockRejectedValueOnce(new Error('restore failed'))
+        .mockResolvedValueOnce(undefined);
+
+      await handler.recoverOnStartup();
+
+      // Second session should still be recovered despite first failure
+      expect(mockBackupManager.restoreBackup).toHaveBeenCalledTimes(2);
+      expect(mockSessionManager.recoverSession).toHaveBeenCalledWith('h2', session2);
+    });
+
+    it('should skip heavy cleanup when marker is fresh', async () => {
+      // Create fresh marker (< 24h old)
+      const markerPath = path.join(flowHome, '.last-cleanup');
+      fs.writeFileSync(markerPath, new Date().toISOString());
+
+      await handler.recoverOnStartup();
+
+      // Session history and orphaned project cleanup should NOT run
+      expect(mockSessionManager.cleanupSessionHistory).not.toHaveBeenCalled();
+    });
+
+    it('should run heavy cleanup when marker is stale', async () => {
+      // Create stale marker (> 24h old)
+      const markerPath = path.join(flowHome, '.last-cleanup');
+      fs.writeFileSync(markerPath, '2020-01-01T00:00:00.000Z');
+      // Set mtime to past
+      const pastTime = new Date('2020-01-01T00:00:00.000Z');
+      fs.utimesSync(markerPath, pastTime, pastTime);
+
+      await handler.recoverOnStartup();
+
+      expect(mockSessionManager.cleanupSessionHistory).toHaveBeenCalledWith(50);
+    });
+
+    it('should run heavy cleanup when marker does not exist', async () => {
+      // No marker file — first run
+      await handler.recoverOnStartup();
+
+      expect(mockSessionManager.cleanupSessionHistory).toHaveBeenCalledWith(50);
+    });
+
+    it('should update marker after heavy cleanup', async () => {
+      await handler.recoverOnStartup();
+
+      const markerPath = path.join(flowHome, '.last-cleanup');
+      expect(fs.existsSync(markerPath)).toBe(true);
+    });
+
+    it('should do nothing when no orphaned sessions and cleanup not needed', async () => {
+      // Fresh marker
+      const markerPath = path.join(flowHome, '.last-cleanup');
+      fs.writeFileSync(markerPath, new Date().toISOString());
+
+      await handler.recoverOnStartup();
+
+      expect(mockBackupManager.restoreBackup).not.toHaveBeenCalled();
+      expect(mockSessionManager.cleanupSessionHistory).not.toHaveBeenCalled();
+    });
+  });
+
+  // --- Orphaned project cleanup ---
+
+  describe('cleanupOrphanedProjects (via recoverOnStartup)', () => {
+    it('should clean up projects whose paths no longer exist', async () => {
+      // Create orphaned project data (backups dir exists, but project path is gone)
+      const orphanHash = 'deadbeef12345678';
+      const backupDir = path.join(flowHome, 'backups', orphanHash, 'session-1000');
+      fs.mkdirSync(backupDir, { recursive: true });
+
+      // Write manifest pointing to non-existent path
+      const manifest = {
+        sessionId: 'session-1000',
+        projectPath: '/nonexistent/project/path',
+        target: 'claude-code',
+      };
+      fs.writeFileSync(path.join(backupDir, 'manifest.json'), JSON.stringify(manifest));
+
+      // Create secrets
+      const secretsDir = path.join(flowHome, 'secrets', orphanHash);
+      fs.mkdirSync(secretsDir, { recursive: true });
+      fs.writeFileSync(path.join(secretsDir, 'mcp-env.json'), '{}');
+
+      await handler.recoverOnStartup();
+
+      // Orphaned data should be cleaned up
+      expect(fs.existsSync(path.join(flowHome, 'backups', orphanHash))).toBe(false);
+      expect(fs.existsSync(path.join(flowHome, 'secrets', orphanHash))).toBe(false);
+    });
+
+    it('should NOT clean up projects with active sessions', async () => {
+      const activeHash = 'active12345678';
+      const backupDir = path.join(flowHome, 'backups', activeHash, 'session-2000');
+      fs.mkdirSync(backupDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(backupDir, 'manifest.json'),
+        JSON.stringify({ projectPath: '/nonexistent', sessionId: 'session-2000' })
+      );
+
+      // Mock: this project has an active session
+      mockSessionManager.getActiveSession.mockImplementation(async (hash: string) => {
+        if (hash === activeHash) {
+          return { projectHash: activeHash };
+        }
+        return null;
+      });
+
+      await handler.recoverOnStartup();
+
+      // Should NOT be cleaned up (active session exists)
+      expect(fs.existsSync(path.join(flowHome, 'backups', activeHash))).toBe(true);
+    });
+
+    it('should clean up backup dirs with no manifest', async () => {
+      const orphanHash = 'nomanifest1234';
+      const backupDir = path.join(flowHome, 'backups', orphanHash);
+      fs.mkdirSync(backupDir, { recursive: true });
+      // No session subdirectories, no manifest
+
+      await handler.recoverOnStartup();
+
+      expect(fs.existsSync(backupDir)).toBe(false);
+    });
+
+    it('should NOT clean up projects whose paths still exist', async () => {
+      const validHash = 'validproject123';
+      const backupDir = path.join(flowHome, 'backups', validHash, 'session-3000');
+      fs.mkdirSync(backupDir, { recursive: true });
+
+      // Point manifest to a path that exists (the temp dir itself)
+      fs.writeFileSync(
+        path.join(backupDir, 'manifest.json'),
+        JSON.stringify({ projectPath: tempDir, sessionId: 'session-3000' })
+      );
+
+      await handler.recoverOnStartup();
+
+      // Should NOT be cleaned up (project path exists)
+      expect(fs.existsSync(path.join(flowHome, 'backups', validHash))).toBe(true);
+    });
+  });
+});

package/src/core/__tests__/git-stash-manager.test.ts

@@ -0,0 +1,246 @@
+/**
+ * Tests for GitStashManager
+ * Covers: batched git operations, crash-safe skip-worktree detection
+ */
+
+import { exec } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { GitStashManager } from '../git-stash-manager.js';
+
+const execAsync = promisify(exec);
+
+describe('GitStashManager', () => {
+  let tempDir: string;
+  let manager: GitStashManager;
+
+  beforeEach(async () => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'flow-git-test-'));
+    manager = new GitStashManager();
+
+    // Initialize git repo
+    await execAsync('git init', { cwd: tempDir });
+    await execAsync('git config user.email "test@test.com"', { cwd: tempDir });
+    await execAsync('git config user.name "Test"', { cwd: tempDir });
+  });
+
+  afterEach(() => {
+    if (tempDir && fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('isGitRepo()', () => {
+    it('should detect git repository', async () => {
+      expect(await manager.isGitRepo(tempDir)).toBe(true);
+    });
+
+    it('should return false for non-git directory', async () => {
+      const nonGitDir = fs.mkdtempSync(path.join(os.tmpdir(), 'flow-nongit-'));
+      try {
+        expect(await manager.isGitRepo(nonGitDir)).toBe(false);
+      } finally {
+        fs.rmSync(nonGitDir, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe('getTrackedSettingsFiles()', () => {
+    it('should return tracked .claude files', async () => {
+      // Create and track .claude files
+      const claudeDir = path.join(tempDir, '.claude');
+      fs.mkdirSync(claudeDir, { recursive: true });
+      fs.writeFileSync(path.join(claudeDir, 'settings.json'), '{}');
+
+      await execAsync('git add .claude/settings.json', { cwd: tempDir });
+      await execAsync('git commit -m "init"', { cwd: tempDir });
+
+      const files = await manager.getTrackedSettingsFiles(tempDir);
+      expect(files).toContain('.claude/settings.json');
+    });
+
+    it('should return empty for repos with no settings files', async () => {
+      // Create an initial commit with unrelated file
+      fs.writeFileSync(path.join(tempDir, 'README.md'), '# Test');
+      await execAsync('git add README.md', { cwd: tempDir });
+      await execAsync('git commit -m "init"', { cwd: tempDir });
+
+      const files = await manager.getTrackedSettingsFiles(tempDir);
+      expect(files).toEqual([]);
+    });
+
+    it('should handle both .claude and .opencode files', async () => {
+      // Create and track files in both directories
+      const claudeDir = path.join(tempDir, '.claude');
+      const opencodeDir = path.join(tempDir, '.opencode');
+      fs.mkdirSync(claudeDir, { recursive: true });
+      fs.mkdirSync(opencodeDir, { recursive: true });
+      fs.writeFileSync(path.join(claudeDir, 'settings.json'), '{}');
+      fs.writeFileSync(path.join(opencodeDir, 'config.json'), '{}');
+
+      await execAsync('git add .claude .opencode', { cwd: tempDir });
+      await execAsync('git commit -m "init"', { cwd: tempDir });
+
+      const files = await manager.getTrackedSettingsFiles(tempDir);
+      expect(files).toContain('.claude/settings.json');
+      expect(files).toContain('.opencode/config.json');
+    });
+  });
+
+  describe('stashSettingsChanges() — batched', () => {
+    it('should mark tracked files as skip-worktree in a single command', async () => {
+      // Create and track multiple .claude files
+      const claudeDir = path.join(tempDir, '.claude');
+      fs.mkdirSync(claudeDir, { recursive: true });
+      fs.writeFileSync(path.join(claudeDir, 'settings.json'), '{}');
+      fs.writeFileSync(path.join(claudeDir, 'config.json'), '{}');
+
+      await execAsync('git add .claude', { cwd: tempDir });
+      await execAsync('git commit -m "init"', { cwd: tempDir });
+
+      await manager.stashSettingsChanges(tempDir);
+
+      // Verify skip-worktree flags are set
+      const { stdout } = await execAsync('git ls-files -v .claude', { cwd: tempDir });
+      const lines = stdout.trim().split('\n');
+      const skippedFiles = lines.filter((l) => l.startsWith('S '));
+      expect(skippedFiles.length).toBe(2);
+    });
+
+    it('should do nothing in non-git directory', async () => {
+      const nonGitDir = fs.mkdtempSync(path.join(os.tmpdir(), 'flow-nongit-'));
+      try {
+        // Should not throw
+        await manager.stashSettingsChanges(nonGitDir); // should not throw
+      } finally {
+        fs.rmSync(nonGitDir, { recursive: true, force: true });
+      }
+    });
+
+    it('should do nothing when no tracked settings files exist', async () => {
+      fs.writeFileSync(path.join(tempDir, 'README.md'), '# Test');
+      await execAsync('git add README.md', { cwd: tempDir });
+      await execAsync('git commit -m "init"', { cwd: tempDir });
+
+      await manager.stashSettingsChanges(tempDir); // should not throw
+    });
+  });
+
+  describe('popSettingsChanges() — crash-safe', () => {
+    it('should detect and remove skip-worktree flags from git index', async () => {
+      // Setup: create tracked file and set skip-worktree
+      const claudeDir = path.join(tempDir, '.claude');
+      fs.mkdirSync(claudeDir, { recursive: true });
+      fs.writeFileSync(path.join(claudeDir, 'settings.json'), '{}');
+
+      await execAsync('git add .claude', { cwd: tempDir });
+      await execAsync('git commit -m "init"', { cwd: tempDir });
+      await execAsync('git update-index --skip-worktree .claude/settings.json', { cwd: tempDir });
+
+      // Verify flag is set
+      const { stdout: before } = await execAsync('git ls-files -v .claude', { cwd: tempDir });
+      expect(before.trim()).toMatch(/^S /);
+
+      // Pop should detect and remove the flag
+      await manager.popSettingsChanges(tempDir);
+
+      // Verify flag is removed
+      const { stdout: after } = await execAsync('git ls-files -v .claude', { cwd: tempDir });
+      expect(after.trim()).not.toMatch(/^S /);
+    });
+
+    it('should work without in-memory state (crash recovery scenario)', async () => {
+      // Setup: create tracked file and set skip-worktree via raw git command
+      // (simulating flags left by a crashed process — manager has no in-memory state)
+      const claudeDir = path.join(tempDir, '.claude');
+      fs.mkdirSync(claudeDir, { recursive: true });
+      fs.writeFileSync(path.join(claudeDir, 'settings.json'), '{}');
+
+      await execAsync('git add .claude', { cwd: tempDir });
+      await execAsync('git commit -m "init"', { cwd: tempDir });
+
+      // Set skip-worktree directly (not through our manager)
+      await execAsync('git update-index --skip-worktree .claude/settings.json', { cwd: tempDir });
+
+      // Create a FRESH manager instance (simulating restart after crash)
+      const freshManager = new GitStashManager();
+
+      // Should detect and remove the flag from git index
+      await freshManager.popSettingsChanges(tempDir);
+
+      const { stdout } = await execAsync('git ls-files -v .claude', { cwd: tempDir });
+      expect(stdout.trim()).not.toMatch(/^S /);
+    });
+
+    it('should handle multiple flagged files in a single batch', async () => {
+      const claudeDir = path.join(tempDir, '.claude');
+      fs.mkdirSync(claudeDir, { recursive: true });
+      fs.writeFileSync(path.join(claudeDir, 'settings.json'), '{}');
+      fs.writeFileSync(path.join(claudeDir, 'config.json'), '{}');
+
+      await execAsync('git add .claude', { cwd: tempDir });
+      await execAsync('git commit -m "init"', { cwd: tempDir });
+
+      // Set skip-worktree on both files
+      await execAsync('git update-index --skip-worktree .claude/settings.json .claude/config.json', { cwd: tempDir });
+
+      await manager.popSettingsChanges(tempDir);
+
+      // Both flags should be removed
+      const { stdout } = await execAsync('git ls-files -v .claude', { cwd: tempDir });
+      const skippedCount = stdout
+        .trim()
+        .split('\n')
+        .filter((l) => l.startsWith('S ')).length;
+      expect(skippedCount).toBe(0);
+    });
+
+    it('should do nothing when no skip-worktree flags exist', async () => {
+      fs.writeFileSync(path.join(tempDir, 'README.md'), '# Test');
+      await execAsync('git add README.md', { cwd: tempDir });
+      await execAsync('git commit -m "init"', { cwd: tempDir });
+
+      await manager.popSettingsChanges(tempDir); // should not throw
+    });
+
+    it('should do nothing in non-git directory', async () => {
+      const nonGitDir = fs.mkdtempSync(path.join(os.tmpdir(), 'flow-nongit-'));
+      try {
+        await manager.popSettingsChanges(nonGitDir); // should not throw
+      } finally {
+        fs.rmSync(nonGitDir, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe('Full stash/pop lifecycle', () => {
+    it('should stash and pop without leaving artifacts', async () => {
+      const claudeDir = path.join(tempDir, '.claude');
+      fs.mkdirSync(claudeDir, { recursive: true });
+      fs.writeFileSync(path.join(claudeDir, 'settings.json'), '{}');
+
+      await execAsync('git add .claude', { cwd: tempDir });
+      await execAsync('git commit -m "init"', { cwd: tempDir });
+
+      // Stash
+      await manager.stashSettingsChanges(tempDir);
+
+      // Modify the file (simulating Flow's changes)
+      fs.writeFileSync(path.join(claudeDir, 'settings.json'), '{"modified": true}');
+
+      // File should NOT show in git status (skip-worktree hides it)
+      const { stdout: status } = await execAsync('git status --porcelain', { cwd: tempDir });
+      expect(status.trim()).toBe('');
+
+      // Pop
+      await manager.popSettingsChanges(tempDir);
+
+      // File SHOULD now show in git status (flag removed)
+      const { stdout: statusAfter } = await execAsync('git status --porcelain', { cwd: tempDir });
+      expect(statusAfter.trim()).not.toBe('');
+    });
+  });
+});