feat: assistant workspace V2 — indexing, retrieval, security hardening & workspace switching

Assistant Workspace V2:
- Markdown indexing engine (incremental manifest + chunks JSONL)
- Keyword retrieval with CJK bigram support and hotset boosting
- Directory taxonomy inference and evolution suggestions
- Workspace config management (.assistant/config.json)
- Organize API: capture, classify, move, archive, suggest-evolution

Workspace switching:
- Inspect API (GET /api/workspace/inspect) for pre-switch validation
- Two-phase switching with confirmation dialogs (5 workspace statuses)
- Atomic save: init/reset runs before setSetting(), rollback on failure
- Auto-navigate to new/reused session after switch
- Mismatch banner in ChatView (only for former assistant sessions)
- Debounced path validation with visual indicators

Security hardening:
- Completion fence (onboarding-complete/checkin-complete) only processes
  when session.workingDirectory === assistant_workspace_path (frontend)
  AND session.working_directory === workspacePath (backend double-check)
- assertContained() in workspace-organizer: rejects absolute paths, ~/,
  ../ traversal, and symlink escapes for captureNote/moveFile
- organize API validates all path params at entry (validateRelativePath)
- captureDefault sanitized to relative path on onboarding write
- R_OK + W_OK validation on GET settings, session creation, and PUT

Bug fixes:
- hookTriggeredSessionId now read before auto-trigger; allows retry if
  session has no messages (previous trigger failed silently)
- workspace-switched event listener matches oldPath (not just != newPath)
  so normal project chats never show the mismatch banner
- Daily check-in card hidden when onboarding not complete
- Refresh docs now calls generateRootDocs() + generateDirectoryDocs()
- Banner "Open" button reuses latest session (checkin mode) instead of
  always creating new onboarding session

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: 7418

docs/handover/assistant-workspace.md

@@ -1,6 +1,6 @@
 {
   "name": "codepilot",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "private": true,
   "author": {
     "name": "op7418",

package-lock.json

@@ -8,6 +8,7 @@
  * 2. Input focus fallback: hookTriggeredSessionId prevents repeat
  * 3. Daily check-in: needsDailyCheckIn respects onboarding state
  * 4. Workspace prompt scoping: only assistant project sessions get prompts
+ * 5. V2: Daily memory write/load, v1→v2 migration, budget-aware prompt assembly
  */
 
 import { describe, it, beforeEach, afterEach } from 'node:test';
@@ -29,6 +30,11 @@ const {
   loadWorkspaceFiles,
   assembleWorkspacePrompt,
   generateDirectoryDocs,
+  ensureDailyDir,
+  writeDailyMemory,
+  loadDailyMemories,
+  migrateStateV1ToV2,
+  generateRootDocs,
 } = require('../../lib/assistant-workspace') as typeof import('../../lib/assistant-workspace');
 
 const { createSession, getLatestSessionByWorkingDirectory, closeDb } = require('../../lib/db') as typeof import('../../lib/db');
@@ -53,7 +59,7 @@ describe('Assistant Workspace', () => {
       const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
       assert.equal(state.onboardingComplete, false);
       assert.equal(state.lastCheckInDate, null);
-      assert.equal(state.schemaVersion, 1);
+      assert.equal(state.schemaVersion, 2);
     });
 
     it('should create all 4 template files', () => {
@@ -63,6 +69,12 @@ describe('Assistant Workspace', () => {
       assert.ok(fs.existsSync(path.join(workDir, 'user.md')));
       assert.ok(fs.existsSync(path.join(workDir, 'memory.md')));
     });
+
+    it('should create V2 directories (memory/daily, Inbox)', () => {
+      initializeWorkspace(workDir);
+      assert.ok(fs.existsSync(path.join(workDir, 'memory', 'daily')));
+      assert.ok(fs.existsSync(path.join(workDir, 'Inbox')));
+    });
   });
 
   describe('onboarding auto-trigger detection', () => {
@@ -111,26 +123,24 @@ describe('Assistant Workspace', () => {
 
   describe('daily check-in respects onboarding state', () => {
     it('should not trigger check-in if onboarding not complete', () => {
-      const state = { onboardingComplete: false, lastCheckInDate: null, schemaVersion: 1 };
+      const state = { onboardingComplete: false, lastCheckInDate: null, schemaVersion: 2 };
       assert.equal(needsDailyCheckIn(state), false);
     });
 
     it('should trigger check-in if onboarding done and no check-in today', () => {
-      const state = { onboardingComplete: true, lastCheckInDate: '2020-01-01', schemaVersion: 1 };
+      const state = { onboardingComplete: true, lastCheckInDate: '2020-01-01', schemaVersion: 2 };
       assert.equal(needsDailyCheckIn(state), true);
     });
 
     it('should not trigger check-in if already done today', () => {
       const today = new Date().toISOString().slice(0, 10);
-      const state = { onboardingComplete: true, lastCheckInDate: today, schemaVersion: 1 };
+      const state = { onboardingComplete: true, lastCheckInDate: today, schemaVersion: 2 };
       assert.equal(needsDailyCheckIn(state), false);
     });
 
     it('onboarding day should skip daily check-in (lastCheckInDate set)', () => {
-      // Simulates what happens after onboarding completes:
-      // onboardingComplete=true, lastCheckInDate=today
       const today = new Date().toISOString().slice(0, 10);
-      const state = { onboardingComplete: true, lastCheckInDate: today, schemaVersion: 1 };
+      const state = { onboardingComplete: true, lastCheckInDate: today, schemaVersion: 2 };
       assert.equal(needsDailyCheckIn(state), false);
     });
   });
@@ -201,6 +211,298 @@ describe('Assistant Workspace', () => {
       assert.ok(pathContent.includes('Path Index'));
     });
   });
+
+  // ===== V2 Tests =====
+
+  describe('daily memory write and load', () => {
+    it('should write and read daily memory', () => {
+      initializeWorkspace(workDir);
+      const today = '2024-03-06';
+      const content = '# Work Log\nDid some coding.';
+
+      writeDailyMemory(workDir, today, content);
+
+      const dailyPath = path.join(workDir, 'memory', 'daily', `${today}.md`);
+      assert.ok(fs.existsSync(dailyPath), 'Daily memory file should exist');
+
+      const read = fs.readFileSync(dailyPath, 'utf-8');
+      assert.equal(read, content);
+    });
+
+    it('should load most recent daily memories', () => {
+      initializeWorkspace(workDir);
+      writeDailyMemory(workDir, '2024-03-04', 'Day 1');
+      writeDailyMemory(workDir, '2024-03-05', 'Day 2');
+      writeDailyMemory(workDir, '2024-03-06', 'Day 3');
+
+      const memories = loadDailyMemories(workDir, 2);
+      assert.equal(memories.length, 2);
+      assert.equal(memories[0].date, '2024-03-06');
+      assert.equal(memories[1].date, '2024-03-05');
+    });
+
+    it('should return empty array for no daily memories', () => {
+      initializeWorkspace(workDir);
+      const memories = loadDailyMemories(workDir, 2);
+      assert.equal(memories.length, 0);
+    });
+  });
+
+  describe('v1 to v2 migration', () => {
+    it('should migrate v1 state to v2', () => {
+      // Create a v1-style workspace
+      const stateDir = path.join(workDir, '.assistant');
+      fs.mkdirSync(stateDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(stateDir, 'state.json'),
+        JSON.stringify({ onboardingComplete: true, lastCheckInDate: '2024-01-01', schemaVersion: 1 }),
+        'utf-8'
+      );
+
+      migrateStateV1ToV2(workDir);
+
+      const state = loadState(workDir);
+      assert.equal(state.schemaVersion, 2);
+      assert.ok(fs.existsSync(path.join(workDir, 'memory', 'daily')));
+      assert.ok(fs.existsSync(path.join(workDir, 'Inbox')));
+    });
+
+    it('should not re-migrate v2 state', () => {
+      initializeWorkspace(workDir);
+      const state = loadState(workDir);
+      assert.equal(state.schemaVersion, 2);
+
+      // Should not throw or change anything
+      migrateStateV1ToV2(workDir);
+      const reloaded = loadState(workDir);
+      assert.equal(reloaded.schemaVersion, 2);
+    });
+  });
+
+  describe('budget-aware prompt assembly', () => {
+    it('should include daily memories in prompt', () => {
+      initializeWorkspace(workDir);
+      fs.writeFileSync(path.join(workDir, 'soul.md'), '# Soul\nI am helpful.', 'utf-8');
+      writeDailyMemory(workDir, '2024-03-06', '# Today\nDid coding.');
+
+      const files = loadWorkspaceFiles(workDir);
+      const prompt = assembleWorkspacePrompt(files);
+
+      assert.ok(prompt.includes('<assistant-workspace>'));
+      assert.ok(prompt.includes('I am helpful'));
+      assert.ok(prompt.includes('Did coding'));
+    });
+
+    it('should include retrieval results in prompt', () => {
+      initializeWorkspace(workDir);
+      fs.writeFileSync(path.join(workDir, 'soul.md'), '# Soul\nI am helpful.', 'utf-8');
+
+      const files = loadWorkspaceFiles(workDir);
+      const results = [
+        { path: 'notes/test.md', heading: 'Test', snippet: 'Some test content', score: 15, source: 'title' as const },
+      ];
+      const prompt = assembleWorkspacePrompt(files, results);
+
+      assert.ok(prompt.includes('retrieval-result'));
+      assert.ok(prompt.includes('Some test content'));
+    });
+
+    it('should respect total prompt limit', () => {
+      initializeWorkspace(workDir);
+      // Write large content to test truncation
+      const largeContent = '# Soul\n' + 'x'.repeat(50000);
+      fs.writeFileSync(path.join(workDir, 'soul.md'), largeContent, 'utf-8');
+
+      const files = loadWorkspaceFiles(workDir);
+      const prompt = assembleWorkspacePrompt(files);
+
+      assert.ok(prompt.length <= 45000, 'Prompt should not exceed budget (with some overhead)');
+    });
+  });
+
+  describe('root docs generation', () => {
+    it('should generate README.ai.md and PATH.ai.md at root', () => {
+      initializeWorkspace(workDir);
+      // Create some subdirs
+      fs.mkdirSync(path.join(workDir, 'notes'));
+      fs.mkdirSync(path.join(workDir, 'projects'));
+
+      const generated = generateRootDocs(workDir);
+      assert.ok(generated.length >= 2);
+      assert.ok(fs.existsSync(path.join(workDir, 'README.ai.md')));
+      assert.ok(fs.existsSync(path.join(workDir, 'PATH.ai.md')));
+    });
+
+    it('should include root docs in loaded files', () => {
+      initializeWorkspace(workDir);
+      fs.mkdirSync(path.join(workDir, 'notes'));
+      generateRootDocs(workDir);
+
+      const files = loadWorkspaceFiles(workDir);
+      assert.ok(files.rootReadme, 'Should have rootReadme');
+      assert.ok(files.rootPath, 'Should have rootPath');
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests for review fixes
+// ---------------------------------------------------------------------------
+
+describe('parseQuery CJK support', () => {
+  const { parseQuery } = require('../../lib/workspace-retrieval') as typeof import('../../lib/workspace-retrieval');
+
+  it('should tokenize Chinese text into bigrams and unigrams', () => {
+    const tokens = parseQuery('项目排期');
+    // Should contain individual chars and bigrams
+    assert.ok(tokens.includes('项'), 'should include unigram 项');
+    assert.ok(tokens.includes('目'), 'should include unigram 目');
+    assert.ok(tokens.includes('项目'), 'should include bigram 项目');
+    assert.ok(tokens.includes('排期'), 'should include bigram 排期');
+  });
+
+  it('should handle mixed Chinese and English', () => {
+    const tokens = parseQuery('下周project排期');
+    assert.ok(tokens.includes('下周'), 'should include CJK bigram');
+    assert.ok(tokens.includes('project'), 'should include English word');
+    assert.ok(tokens.includes('排期'), 'should include CJK bigram');
+  });
+
+  it('should still filter English stop words', () => {
+    const tokens = parseQuery('the project is good');
+    assert.ok(!tokens.includes('the'));
+    assert.ok(!tokens.includes('is'));
+    assert.ok(tokens.includes('project'));
+    assert.ok(tokens.includes('good'));
+  });
+});
+
+describe('incremental indexWorkspace', () => {
+  const { indexWorkspace, loadManifest } = require('../../lib/workspace-indexer') as typeof import('../../lib/workspace-indexer');
+  let wsDir: string;
+
+  beforeEach(() => {
+    wsDir = fs.mkdtempSync(path.join(os.tmpdir(), 'idx-test-'));
+    fs.writeFileSync(path.join(wsDir, 'note1.md'), '# Note 1\nHello', 'utf-8');
+    fs.writeFileSync(path.join(wsDir, 'note2.md'), '# Note 2\nWorld', 'utf-8');
+  });
+
+  afterEach(() => {
+    fs.rmSync(wsDir, { recursive: true, force: true });
+  });
+
+  it('should skip unchanged files on second run', () => {
+    const first = indexWorkspace(wsDir);
+    assert.equal(first.fileCount, 2);
+
+    // Second run: nothing changed, should reuse existing
+    const second = indexWorkspace(wsDir);
+    assert.equal(second.fileCount, 2);
+
+    // Manifest should be identical
+    const manifest = loadManifest(wsDir);
+    assert.equal(manifest.length, 2);
+  });
+
+  it('should re-index only modified files', () => {
+    indexWorkspace(wsDir);
+    const manifestBefore = loadManifest(wsDir);
+    const note1Before = manifestBefore.find(m => m.path === 'note1.md')!;
+
+    // Modify note1 (ensure mtime changes)
+    const futureTime = Date.now() + 1000;
+    fs.writeFileSync(path.join(wsDir, 'note1.md'), '# Note 1 Updated\nChanged content', 'utf-8');
+    fs.utimesSync(path.join(wsDir, 'note1.md'), new Date(futureTime), new Date(futureTime));
+
+    indexWorkspace(wsDir);
+    const manifestAfter = loadManifest(wsDir);
+
+    const note1After = manifestAfter.find(m => m.path === 'note1.md')!;
+    const note2After = manifestAfter.find(m => m.path === 'note2.md')!;
+    const note2Before = manifestBefore.find(m => m.path === 'note2.md')!;
+
+    // note1 should have changed hash
+    assert.notEqual(note1After.hash, note1Before.hash);
+    // note2 should be unchanged
+    assert.equal(note2After.hash, note2Before.hash);
+  });
+
+  it('force mode should re-index all files', () => {
+    indexWorkspace(wsDir);
+    const result = indexWorkspace(wsDir, { force: true });
+    assert.equal(result.fileCount, 2);
+  });
+});
+
+describe('memory.md promotion dedup', () => {
+  const { promoteDailyToLongTerm } = require('../../lib/workspace-organizer') as typeof import('../../lib/workspace-organizer');
+  let wsDir: string;
+
+  beforeEach(() => {
+    wsDir = fs.mkdtempSync(path.join(os.tmpdir(), 'promo-test-'));
+    fs.mkdirSync(path.join(wsDir, 'memory', 'daily'), { recursive: true });
+    fs.writeFileSync(path.join(wsDir, 'memory.md'), '# Memory\n', 'utf-8');
+  });
+
+  afterEach(() => {
+    fs.rmSync(wsDir, { recursive: true, force: true });
+  });
+
+  it('should promote content on first call', () => {
+    const dailyContent = '## Work Log\nDid stuff\n\n## Candidate Long-Term Memory\nUser prefers dark mode and uses Vim keybindings daily.\n';
+    fs.writeFileSync(path.join(wsDir, 'memory', 'daily', '2026-02-20.md'), dailyContent, 'utf-8');
+
+    const result = promoteDailyToLongTerm(wsDir, '2026-02-20');
+    assert.equal(result, true);
+
+    const memory = fs.readFileSync(path.join(wsDir, 'memory.md'), 'utf-8');
+    assert.ok(memory.includes('Promoted from 2026-02-20'));
+  });
+
+  it('should NOT promote same date twice (idempotent)', () => {
+    const dailyContent = '## Candidate Long-Term Memory\nUser prefers dark mode and uses Vim keybindings daily.\n';
+    fs.writeFileSync(path.join(wsDir, 'memory', 'daily', '2026-02-20.md'), dailyContent, 'utf-8');
+
+    promoteDailyToLongTerm(wsDir, '2026-02-20');
+    const memoryAfterFirst = fs.readFileSync(path.join(wsDir, 'memory.md'), 'utf-8');
+
+    // Second call should return false
+    const result = promoteDailyToLongTerm(wsDir, '2026-02-20');
+    assert.equal(result, false);
+
+    const memoryAfterSecond = fs.readFileSync(path.join(wsDir, 'memory.md'), 'utf-8');
+    assert.equal(memoryAfterFirst, memoryAfterSecond, 'memory.md should not change on second call');
+  });
+});
+
+describe('hotset boosts search results', () => {
+  const { indexWorkspace } = require('../../lib/workspace-indexer') as typeof import('../../lib/workspace-indexer');
+  const { searchWorkspace, updateHotset } = require('../../lib/workspace-retrieval') as typeof import('../../lib/workspace-retrieval');
+  let wsDir: string;
+
+  beforeEach(() => {
+    wsDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hotset-test-'));
+    // Two notes with similar relevance to "design"
+    fs.writeFileSync(path.join(wsDir, 'alpha.md'), '# Design Notes\nSome design thoughts', 'utf-8');
+    fs.writeFileSync(path.join(wsDir, 'beta.md'), '# Design Patterns\nSome design patterns', 'utf-8');
+    indexWorkspace(wsDir, { force: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(wsDir, { recursive: true, force: true });
+  });
+
+  it('should boost frequently accessed files in search ranking', () => {
+    // Access beta many times to build frequency
+    for (let i = 0; i < 10; i++) {
+      updateHotset(wsDir, ['beta.md']);
+    }
+
+    const results = searchWorkspace(wsDir, 'design');
+    assert.ok(results.length >= 2, 'Should find both files');
+    // beta.md should be boosted to top due to hotset frequency
+    assert.equal(results[0].path, 'beta.md', 'Frequently accessed file should rank higher');
+  });
 });
 
 // Clean up DB