fix: onboarding stability, invalid JSON from hooks, file tree race conditions

Issue 1 — Onboarding re-triggering after completion:
- ChatView.tsx: fence regex now tolerates CRLF, trailing whitespace, leading
  whitespace before closing fence; JSON.parse input trimmed
- ChatView.tsx: hookTriggeredSessionId only cleared when backend returns ok
- assistant-workspace.ts: saveState uses atomic write (tmp + rename)

Issue 2 — "CLI output was not valid JSON" during document reads:
- claude-client.ts: remove all SDK hooks (Notification + PostToolUse) to
  eliminate hook_callback control_request transport that corrupts stdout
- claude-client.ts: TodoWrite sync moved to message stream — tool_use records
  pending input, tool_result emits task_update only on success
- claude-client.ts: notifications derived from system/task_notification and
  result/is_error messages; Telegram forwarding preserved via notifyGeneric

Issue 3 — File tree not updating on project switch:
- FileTree.tsx: AbortController cancels in-flight requests on directory change;
  abort fires before empty-directory early return to prevent stale overwrites;
  error state distinguishes empty dir from load failure; loading always reset
- page.tsx: clear workingDirectory immediately on session switch
- SplitColumn.tsx: clear workingDirectory when active column has no directory

Tests: 9 new tests for fence parsing, atomic write, corrupted state fallback.

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

Author: 7418

package-lock.json

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

package.json

@@ -506,6 +506,103 @@ describe('hotset boosts search results', () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Issue 1: Onboarding stability fixes
+// ---------------------------------------------------------------------------
+
+describe('completion fence parsing tolerates formatting variations', () => {
+  // These test the regex patterns used in ChatView.tsx for parsing
+  // onboarding-complete and checkin-complete fences.
+
+  const onboardingRegex = /```onboarding-complete\s*\r?\n([\s\S]*?)\r?\n\s*```/;
+  const checkinRegex = /```checkin-complete\s*\r?\n([\s\S]*?)\r?\n\s*```/;
+
+  it('should match standard LF format', () => {
+    const content = '```onboarding-complete\n{"lang":"zh"}\n```';
+    const match = content.match(onboardingRegex);
+    assert.ok(match, 'Should match LF format');
+    assert.equal(JSON.parse(match![1].trim()).lang, 'zh');
+  });
+
+  it('should match CRLF format', () => {
+    const content = '```onboarding-complete\r\n{"lang":"zh"}\r\n```';
+    const match = content.match(onboardingRegex);
+    assert.ok(match, 'Should match CRLF format');
+    assert.equal(JSON.parse(match![1].trim()).lang, 'zh');
+  });
+
+  it('should match with trailing spaces after tag', () => {
+    const content = '```onboarding-complete   \n{"lang":"zh"}\n```';
+    const match = content.match(onboardingRegex);
+    assert.ok(match, 'Should match with trailing spaces');
+  });
+
+  it('should match with leading whitespace before closing fence', () => {
+    const content = '```onboarding-complete\n{"lang":"zh"}\n  ```';
+    const match = content.match(onboardingRegex);
+    assert.ok(match, 'Should match with leading whitespace before closing fence');
+  });
+
+  it('should match checkin-complete with CRLF', () => {
+    const content = '```checkin-complete\r\n{"mood":"good"}\r\n```';
+    const match = content.match(checkinRegex);
+    assert.ok(match, 'Should match checkin CRLF format');
+    assert.equal(JSON.parse(match![1].trim()).mood, 'good');
+  });
+
+  it('should handle JSON with whitespace padding', () => {
+    const content = '```onboarding-complete\n  {"lang":"zh"}  \n```';
+    const match = content.match(onboardingRegex);
+    assert.ok(match, 'Should match');
+    assert.equal(JSON.parse(match![1].trim()).lang, 'zh');
+  });
+});
+
+describe('saveState is atomic (write-then-rename)', () => {
+  let workDir2: string;
+
+  beforeEach(() => {
+    workDir2 = fs.mkdtempSync(path.join(os.tmpdir(), 'atomic-write-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(workDir2, { recursive: true, force: true });
+  });
+
+  it('should persist onboardingComplete = true reliably', () => {
+    initializeWorkspace(workDir2);
+    const state = loadState(workDir2);
+    state.onboardingComplete = true;
+    state.lastCheckInDate = getLocalDateString();
+    saveState(workDir2, state);
+
+    // Read raw file to verify it's valid JSON
+    const statePath = path.join(workDir2, '.assistant', 'state.json');
+    const raw = fs.readFileSync(statePath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    assert.equal(parsed.onboardingComplete, true);
+  });
+
+  it('should not leave .tmp file after successful write', () => {
+    initializeWorkspace(workDir2);
+    const state = loadState(workDir2);
+    state.onboardingComplete = true;
+    saveState(workDir2, state);
+
+    const tmpPath = path.join(workDir2, '.assistant', 'state.json.tmp');
+    assert.ok(!fs.existsSync(tmpPath), 'Temp file should be removed after atomic rename');
+  });
+
+  it('loadState should return default when state.json is corrupted', () => {
+    const stateDir = path.join(workDir2, '.assistant');
+    fs.mkdirSync(stateDir, { recursive: true });
+    fs.writeFileSync(path.join(stateDir, 'state.json'), '{corrupted', 'utf-8');
+
+    const state = loadState(workDir2);
+    assert.equal(state.onboardingComplete, false, 'Corrupted state should fall back to default');
+  });
+});
+
 // Clean up DB
 describe('cleanup', () => {
   it('close db', () => {

src/__tests__/unit/assistant-workspace.test.ts

@@ -80,6 +80,8 @@ export default function ChatSessionPage({ params }: ChatSessionPageProps) {
   // Load session info and set working directory
   useEffect(() => {
     let cancelled = false;
+    // Clear stale directory immediately so FileTree doesn't show old project
+    setWorkingDirectory('');
 
     async function loadSession() {
       try {

src/app/chat/[id]/page.tsx

@@ -455,33 +455,41 @@ export function ChatView({ sessionId, initialMessages = [], initialHasMore = fal
       }).catch(() => {});
 
     // Check for onboarding completion
-    const onboardingMatch = content.match(/```onboarding-complete\n([\s\S]*?)\n```/);
+    const onboardingMatch = content.match(/```onboarding-complete\s*\r?\n([\s\S]*?)\r?\n\s*```/);
     if (onboardingMatch) {
       try {
-        const answers = JSON.parse(onboardingMatch[1]);
-        await fetch('/api/workspace/onboarding', {
+        const answers = JSON.parse(onboardingMatch[1].trim());
+        const resp = await fetch('/api/workspace/onboarding', {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify({ answers, sessionId }),
         });
-        await clearHookTriggered();
+        if (resp.ok) {
+          await clearHookTriggered();
+        } else {
+          console.error('[ChatView] Onboarding API returned', resp.status);
+        }
       } catch (e) {
         console.error('[ChatView] Onboarding completion failed:', e);
       }
       return;
     }
 
     // Check for check-in completion
-    const checkinMatch = content.match(/```checkin-complete\n([\s\S]*?)\n```/);
+    const checkinMatch = content.match(/```checkin-complete\s*\r?\n([\s\S]*?)\r?\n\s*```/);
     if (checkinMatch) {
       try {
-        const answers = JSON.parse(checkinMatch[1]);
-        await fetch('/api/workspace/checkin', {
+        const answers = JSON.parse(checkinMatch[1].trim());
+        const resp = await fetch('/api/workspace/checkin', {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify({ answers, sessionId }),
         });
-        await clearHookTriggered();
+        if (resp.ok) {
+          await clearHookTriggered();
+        } else {
+          console.error('[ChatView] Check-in API returned', resp.status);
+        }
       } catch (e) {
         console.error('[ChatView] Check-in completion failed:', e);
       }

src/components/chat/ChatView.tsx

@@ -95,6 +95,9 @@ export function SplitColumn({ sessionId, isActive, onClose, onFocus }: SplitColu
       setWorkingDirectory(sessionWorkingDir);
       localStorage.setItem("codepilot:last-working-directory", sessionWorkingDir);
       window.dispatchEvent(new Event("refresh-file-tree"));
+    } else {
+      // Clear stale directory from previous column so FileTree doesn't show old project
+      setWorkingDirectory('');
     }
     setSessionId(sessionId);
     setPanelOpen(true);

src/components/layout/SplitColumn.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import { useState, useEffect, useCallback } from "react";
+import { useState, useEffect, useCallback, useRef } from "react";
 import { HugeiconsIcon } from "@hugeicons/react";
 import { RefreshIcon, Search01Icon, SourceCodeIcon, CodeIcon, File01Icon } from "@hugeicons/core-free-icons";
 import { Button } from "@/components/ui/button";
@@ -109,36 +109,70 @@ function RenderTreeNodes({ nodes, searchQuery }: { nodes: FileTreeNode[]; search
 export function FileTree({ workingDirectory, onFileSelect, onFileAdd }: FileTreeProps) {
   const [tree, setTree] = useState<FileTreeNode[]>([]);
   const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
   const [searchQuery, setSearchQuery] = useState("");
+  const abortRef = useRef<AbortController | null>(null);
   const { t } = useTranslation();
 
   const fetchTree = useCallback(async () => {
+    // Always cancel in-flight request first — even when clearing directory,
+    // otherwise a stale response from the old project can arrive and repopulate the tree.
+    if (abortRef.current) {
+      abortRef.current.abort();
+    }
+
     if (!workingDirectory) {
+      abortRef.current = null;
       setTree([]);
+      setError(null);
+      setLoading(false);
       return;
     }
+
+    const controller = new AbortController();
+    abortRef.current = controller;
+
     setLoading(true);
+    setError(null);
     try {
       const res = await fetch(
-        `/api/files?dir=${encodeURIComponent(workingDirectory)}&baseDir=${encodeURIComponent(workingDirectory)}&depth=4&_t=${Date.now()}`
+        `/api/files?dir=${encodeURIComponent(workingDirectory)}&baseDir=${encodeURIComponent(workingDirectory)}&depth=4&_t=${Date.now()}`,
+        { signal: controller.signal }
       );
+      if (controller.signal.aborted) return;
       if (res.ok) {
         const data = await res.json();
+        if (controller.signal.aborted) return;
         setTree(data.tree || []);
       } else {
+        const errData = await res.json().catch(() => ({ error: res.statusText }));
         setTree([]);
+        setError(errData.error || `Failed to load (${res.status})`);
       }
-    } catch {
+    } catch (e) {
+      if ((e as Error).name === 'AbortError') return;
       setTree([]);
+      setError('Failed to load file tree');
     } finally {
-      setLoading(false);
+      if (!controller.signal.aborted) {
+        setLoading(false);
+      }
     }
   }, [workingDirectory]);
 
   useEffect(() => {
     fetchTree();
   }, [fetchTree]);
 
+  // Cleanup abort controller on unmount
+  useEffect(() => {
+    return () => {
+      if (abortRef.current) {
+        abortRef.current.abort();
+      }
+    };
+  }, []);
+
   // Auto-refresh when AI finishes streaming
   useEffect(() => {
     const handler = () => fetchTree();
@@ -182,7 +216,7 @@ export function FileTree({ workingDirectory, onFileSelect, onFileAdd }: FileTree
           </div>
         ) : tree.length === 0 ? (
           <p className="py-4 text-center text-xs text-muted-foreground">
-            {workingDirectory ? t('fileTree.noFiles') : t('fileTree.selectFolder')}
+            {error ? error : workingDirectory ? t('fileTree.noFiles') : t('fileTree.selectFolder')}
           </p>
         ) : (
           <AIFileTree

src/components/project/FileTree.tsx

@@ -527,7 +527,9 @@ export function saveState(dir: string, state: AssistantWorkspaceState): void {
     fs.mkdirSync(stateDir, { recursive: true });
   }
   const statePath = path.join(stateDir, STATE_FILE);
-  fs.writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf-8');
+  const tmpPath = statePath + '.tmp';
+  fs.writeFileSync(tmpPath, JSON.stringify(state, null, 2), 'utf-8');
+  fs.renameSync(tmpPath, statePath);
 }
 
 export function needsDailyCheckIn(state: AssistantWorkspaceState, now?: Date): boolean {