diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3e2aad7..cf67aa0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,38 @@ All notable changes to DeepCode are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.2] — 2026-05-28
+
+### Fixes — caught from user playtest of 0.1.1
+- **Tool input field-name fix.** `tool_write` (and read / edit / bash /
+  glob / grep) were failing with `missing required key filePath` when
+  DeepSeek emitted snake_case keys but the wrapper expected camelCase.
+  All 6 Mac tool wrappers now accept either case via a tolerant
+  `pickStr / pickNum / pickBool` helper.
+- **Project folder picker.** First launch now shows a "Pick a project
+  folder" overlay before chat. The chosen path is persisted to
+  `~/.deepcode/settings.json#projectPath` and threaded into every
+  agent turn as `cwd`. Sidebar shows the active project + a `⇄`
+  switch button.
+- **Session persistence.** Each turn now writes a JSONL session under
+  `~/.deepcode/sessions/<id>.jsonl`. Sidebar refreshes after every
+  turn so newly-started sessions appear in the Today bucket.
+- **Mid-turn controls locked.** Mode / model / effort dropdowns disable
+  while the agent is responding or awaiting approval (was previously
+  freely switchable mid-turn).
+- **Inspector rail buttons work.** All 6 rail icons now route to
+  their respective screens (Plan → Permissions, Sessions, Plugins,
+  Skills, MCP, About, Settings). Expand-chevron ‹ still deferred.
+
+### UX improvements
+- **Proper dropdowns** for mode / model / effort — click-popover with
+  inline descriptions and meta annotations, replacing the brittle
+  click-to-cycle pattern.
+- 5 official mode options surfaced (default / acceptEdits / plan /
+  dontAsk / bypassPermissions) instead of 3.
+- ReplScreen carries projectPath through to the system prompt so the
+  LLM knows where it's working.
+
 ## [0.1.1] — 2026-05-28
 
 ### Visual redesign — phase 1
diff --git a/apps/cli/package.json b/apps/cli/package.json
index 6e8851b..d58cf77 100644
--- a/apps/cli/package.json
+++ b/apps/cli/package.json
@@ -1,6 +1,6 @@
 {
   "name": "deepcode-cli",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "DeepCode CLI — DeepSeek-powered AI coding agent, parity with Claude Code",
   "license": "MIT",
   "type": "module",
diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index 0863f6a..47d2f91 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@deepcode/desktop",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "private": true,
   "description": "DeepCode Mac desktop client — Tauri + React",
   "license": "MIT",
diff --git a/apps/desktop/src-tauri/Cargo.lock b/apps/desktop/src-tauri/Cargo.lock
index ef83151..4198971 100644
--- a/apps/desktop/src-tauri/Cargo.lock
+++ b/apps/desktop/src-tauri/Cargo.lock
@@ -672,7 +672,7 @@ dependencies = [
 
 [[package]]
 name = "deepcode_desktop"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "dirs 5.0.1",
  "serde",
diff --git a/apps/desktop/src-tauri/Cargo.toml b/apps/desktop/src-tauri/Cargo.toml
index f1ccd9e..21adc80 100644
--- a/apps/desktop/src-tauri/Cargo.toml
+++ b/apps/desktop/src-tauri/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deepcode_desktop"
-version = "0.1.1"
+version = "0.1.2"
 description = "DeepCode Mac desktop client"
 authors = ["oratis"]
 edition = "2021"
diff --git a/apps/desktop/src-tauri/src/commands.rs b/apps/desktop/src-tauri/src/commands.rs
index f26b976..8d99697 100644
--- a/apps/desktop/src-tauri/src/commands.rs
+++ b/apps/desktop/src-tauri/src/commands.rs
@@ -114,6 +114,81 @@ pub fn append_allow_matcher(matcher: String) -> Result<(), String> {
     settings::write_user(&value)
 }
 
+/// Create a new session JSONL with a metadata header line. Returns the
+/// generated session id. The id format matches what @deepcode/core's
+/// SessionManager produces: `YYYY-MM-DD-<random>`.
+#[tauri::command]
+pub fn session_create(cwd: String) -> Result<String, String> {
+    let Some(home) = dirs::home_dir() else {
+        return Err("no home directory".into());
+    };
+    let now = std::time::SystemTime::now();
+    let secs = now
+        .duration_since(std::time::UNIX_EPOCH)
+        .map_err(|e| e.to_string())?
+        .as_secs();
+    let date = format_date(secs);
+    // Lightweight unique suffix from time-nanos — no extra crate dep
+    let nanos = now
+        .duration_since(std::time::UNIX_EPOCH)
+        .map_err(|e| e.to_string())?
+        .subsec_nanos();
+    let rand_id = format!("{:08x}", nanos);
+    let id = format!("{}-{}", date, rand_id);
+    let dir = home.join(".deepcode").join("sessions");
+    std::fs::create_dir_all(&dir).map_err(|e| format!("mkdir {}: {}", dir.display(), e))?;
+    let path = dir.join(format!("{}.jsonl", id));
+    let header = serde_json::json!({
+        "type": "session_meta",
+        "id": id,
+        "cwd": cwd,
+        "created_at": secs,
+        "client": "desktop"
+    });
+    let line = format!("{}\n", header);
+    std::fs::write(&path, line).map_err(|e| format!("write {}: {}", path.display(), e))?;
+    Ok(id)
+}
+
+/// Append a single JSON line to a session's JSONL file.
+#[tauri::command]
+pub fn session_append(id: String, message: serde_json::Value) -> Result<(), String> {
+    let Some(home) = dirs::home_dir() else {
+        return Err("no home directory".into());
+    };
+    let path = home
+        .join(".deepcode")
+        .join("sessions")
+        .join(format!("{}.jsonl", id));
+    let line = format!("{}\n", message);
+    use std::io::Write;
+    let mut f = std::fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(&path)
+        .map_err(|e| format!("open {}: {}", path.display(), e))?;
+    f.write_all(line.as_bytes())
+        .map_err(|e| format!("write {}: {}", path.display(), e))
+}
+
+fn format_date(secs: u64) -> String {
+    // Simple YYYY-MM-DD; days since epoch math is enough for filename use.
+    let days = secs / 86_400;
+    // Reference: 1970-01-01 was a Thursday; we compute YMD via the
+    // standard "civil_from_days" algorithm by Howard Hinnant.
+    let z = days as i64 + 719_468;
+    let era = if z >= 0 { z } else { z - 146_096 } / 146_097;
+    let doe = (z - era * 146_097) as u64;
+    let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146_096) / 365;
+    let y = yoe as i64 + era * 400;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    let mp = (5 * doy + 2) / 153;
+    let d = doy - (153 * mp + 2) / 5 + 1;
+    let m = if mp < 10 { mp + 3 } else { mp - 9 };
+    let y = if m <= 2 { y + 1 } else { y };
+    format!("{:04}-{:02}-{:02}", y, m, d)
+}
+
 /// List session files under ~/.deepcode/sessions/. Returns just metadata.
 #[derive(Serialize)]
 pub struct SessionMeta {
diff --git a/apps/desktop/src-tauri/src/lib.rs b/apps/desktop/src-tauri/src/lib.rs
index 778ca3a..2d80747 100644
--- a/apps/desktop/src-tauri/src/lib.rs
+++ b/apps/desktop/src-tauri/src/lib.rs
@@ -17,7 +17,7 @@ mod tools;
 use commands::{
     append_allow_matcher, cli_path, get_app_info, get_settings_path, list_sessions,
     load_keybindings, load_settings_file, open_url, read_credentials, save_credentials,
-    save_keybindings, save_settings_file,
+    save_keybindings, save_settings_file, session_append, session_create,
 };
 use tools::{tool_bash, tool_edit, tool_glob, tool_grep, tool_read, tool_write};
 use tauri::Manager;
@@ -41,6 +41,8 @@ pub fn run() {
             append_allow_matcher,
             load_keybindings,
             save_keybindings,
+            session_create,
+            session_append,
             list_sessions,
             cli_path,
             open_url,
diff --git a/apps/desktop/src-tauri/tauri.conf.json b/apps/desktop/src-tauri/tauri.conf.json
index 223ca7f..dffa658 100644
--- a/apps/desktop/src-tauri/tauri.conf.json
+++ b/apps/desktop/src-tauri/tauri.conf.json
@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "DeepCode",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "identifier": "dev.deepcode.desktop",
   "build": {
     "frontendDist": "../dist",
diff --git a/apps/desktop/src/App.tsx b/apps/desktop/src/App.tsx
index 419e937..3012c99 100644
--- a/apps/desktop/src/App.tsx
+++ b/apps/desktop/src/App.tsx
@@ -1,14 +1,16 @@
 // Top-level React component for desktop client.
 // Spec: docs/VISUAL_DESIGN.html
-// Milestone: 0.1.1 — design-aligned 3-column shell
+// Milestone: 0.1.2 — adds project-folder flow + inspector wiring + session refresh.
 
 import { useEffect, useState } from 'react';
 import { InspectorRail } from './components/InspectorRail.js';
+import { ProjectPickerOverlay } from './components/ProjectPickerOverlay.js';
 import { Sidebar } from './components/Sidebar.js';
 import { UpdateBanner } from './components/UpdateBanner.js';
+import { clearHistory as clearAgentHistory } from './lib/mac-agent.js';
+import { loadProjectPath, saveProjectPath } from './lib/project.js';
 import { onUpdateDownloaded, startUpdaterPolling } from './lib/updater.js';
 import { AboutScreen } from './screens/About.js';
-import { ChatScreen } from './screens/Chat.js';
 import { MCPManagerScreen } from './screens/MCPManager.js';
 import { OnboardingScreen } from './screens/Onboarding.js';
 import { PermissionsScreen } from './screens/Permissions.js';
@@ -22,12 +24,15 @@ import type { UpdateInfo } from './types/global.js';
 
 export function App(): JSX.Element {
   const [hasKey, setHasKey] = useState<boolean | null>(null);
+  const [projectPath, setProjectPath] = useState<string | null | undefined>(undefined);
   const [update, setUpdate] = useState<UpdateInfo | null>(null);
   const [screen, setScreen] = useState<ScreenName>('repl');
   const [activeSessionId, setActiveSessionId] = useState<string | null>(null);
+  const [sessionEpoch, setSessionEpoch] = useState(0);
 
   useEffect(() => {
     void window.deepcode.creds.load().then((c) => setHasKey(c.hasKey));
+    void loadProjectPath().then((p) => setProjectPath(p ?? null));
     const offShim = window.deepcode.onUpdateDownloaded((info) => setUpdate(info));
     const offReal = onUpdateDownloaded((info) => setUpdate(info));
     startUpdaterPolling();
@@ -37,7 +42,13 @@ export function App(): JSX.Element {
     };
   }, []);
 
-  if (hasKey === null) {
+  async function handlePickProject(path: string): Promise<void> {
+    await saveProjectPath(path);
+    setProjectPath(path);
+  }
+
+  // Loading state
+  if (hasKey === null || projectPath === undefined) {
     return (
       <div
         style={{
@@ -59,22 +70,40 @@ export function App(): JSX.Element {
     return <OnboardingScreen onComplete={() => setHasKey(true)} />;
   }
 
+  // No project picked yet → folder picker overlay
+  if (!projectPath) {
+    return <ProjectPickerOverlay onPicked={handlePickProject} />;
+  }
+
   // Main shell: 3-column grid.
   return (
     <div className="app-shell">
       {update && <UpdateBanner info={update} />}
       <Sidebar
+        key={`sb-${sessionEpoch}`}
+        projectPath={projectPath}
         activeSessionId={activeSessionId}
         onPickSession={(id) => {
           setActiveSessionId(id);
           setScreen('repl');
         }}
         onNewSession={() => {
+          clearAgentHistory();
           setActiveSessionId(null);
           setScreen('repl');
+          // Force ReplScreen to remount with a clean message history
+          setSessionEpoch((k) => k + 1);
+        }}
+        onSwitchProject={async () => {
+          // Force-show the picker again by clearing state.
+          setProjectPath(null);
         }}
       />
-      <main className="chat-main">{renderScreen(screen, setScreen)}</main>
+      <main className="chat-main" key={`main-${sessionEpoch}`}>
+        {renderScreen(screen, setScreen, projectPath, () =>
+          setSessionEpoch((k) => k + 1),
+        )}
+      </main>
       <InspectorRail
         activeScreen={screen}
         onChange={(s) => setScreen(s)}
@@ -87,10 +116,13 @@ export function App(): JSX.Element {
 function renderScreen(
   screen: ScreenName,
   setScreen: (s: ScreenName) => void,
+  projectPath: string,
+  onTurnComplete: () => void,
 ): JSX.Element {
   switch (screen) {
     case 'chat':
-      return <ChatScreen />;
+      // 'chat' folded into 'repl' — the new shell has only the REPL surface.
+      return <ReplScreen projectPath={projectPath} onTurnComplete={onTurnComplete} />;
     case 'sessions':
       return (
         <div className="legacy-screen">
@@ -138,6 +170,6 @@ function renderScreen(
       );
     case 'repl':
     default:
-      return <ReplScreen />;
+      return <ReplScreen projectPath={projectPath} onTurnComplete={onTurnComplete} />;
   }
 }
diff --git a/apps/desktop/src/components/Dropdown.tsx b/apps/desktop/src/components/Dropdown.tsx
new file mode 100644
index 0000000..0ceecda
--- /dev/null
+++ b/apps/desktop/src/components/Dropdown.tsx
@@ -0,0 +1,177 @@
+// Lightweight click-popover dropdown. Matches the design's model-picker
+// style (rounded pill + caret) so it can stand in for native <select>
+// inside the composer toolbar.
+//
+// Closes on outside click + escape. No portal — sits in normal DOM,
+// positioned absolute below the trigger. Good enough for composer
+// dropdowns that don't need to escape clipping.
+
+import { useEffect, useRef, useState, type ReactNode } from 'react';
+
+export interface DropdownOption<T extends string> {
+  value: T;
+  label: string;
+  description?: string;
+  meta?: string; // small right-aligned annotation
+}
+
+interface DropdownProps<T extends string> {
+  /** Current selection. */
+  value: T;
+  options: DropdownOption<T>[];
+  onChange: (next: T) => void;
+  /** Optional left-side icon — gets a mint dot if you set `dot`. */
+  dot?: boolean;
+  /** Override how the trigger is rendered. Default: label + meta. */
+  renderTrigger?: (opt: DropdownOption<T>) => ReactNode;
+  /** Disabled state — clicks no-op, color dims. */
+  disabled?: boolean;
+  /** Width of the popover panel in px. Default 240. */
+  panelWidth?: number;
+  /** Tooltip on the trigger button. */
+  title?: string;
+  /** Extra className for the trigger pill (e.g. 'mode-badge default'). */
+  triggerClass?: string;
+}
+
+export function Dropdown<T extends string>({
+  value,
+  options,
+  onChange,
+  dot,
+  renderTrigger,
+  disabled,
+  panelWidth = 260,
+  title,
+  triggerClass,
+}: DropdownProps<T>): JSX.Element {
+  const [open, setOpen] = useState(false);
+  const rootRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    if (!open) return;
+    function handle(e: MouseEvent): void {
+      if (!rootRef.current?.contains(e.target as Node)) {
+        setOpen(false);
+      }
+    }
+    function escape(e: KeyboardEvent): void {
+      if (e.key === 'Escape') setOpen(false);
+    }
+    window.addEventListener('mousedown', handle);
+    window.addEventListener('keydown', escape);
+    return () => {
+      window.removeEventListener('mousedown', handle);
+      window.removeEventListener('keydown', escape);
+    };
+  }, [open]);
+
+  const selected = options.find((o) => o.value === value) ?? options[0]!;
+
+  return (
+    <div ref={rootRef} style={{ position: 'relative', display: 'inline-flex' }}>
+      <button
+        type="button"
+        className={triggerClass ?? 'model-picker'}
+        onClick={() => !disabled && setOpen((o) => !o)}
+        disabled={disabled}
+        title={title}
+        style={{ cursor: disabled ? 'not-allowed' : 'pointer' }}
+      >
+        {dot && <span className="dot" />}
+        {renderTrigger ? (
+          renderTrigger(selected)
+        ) : (
+          <>
+            <span>{selected.label}</span>
+            {selected.meta && <span className="meta">{selected.meta}</span>}
+          </>
+        )}
+        <span style={{ color: 'var(--text-3)', fontSize: 11, marginLeft: 2 }}>
+          ⌄
+        </span>
+      </button>
+
+      {open && (
+        <div
+          style={{
+            position: 'absolute',
+            bottom: 'calc(100% + 6px)',
+            right: 0,
+            width: panelWidth,
+            background: 'var(--bg-2)',
+            border: '1px solid var(--line)',
+            borderRadius: 'var(--radius)',
+            boxShadow: 'var(--shadow)',
+            padding: 4,
+            zIndex: 20,
+          }}
+          role="listbox"
+        >
+          {options.map((opt) => {
+            const active = opt.value === value;
+            return (
+              <button
+                type="button"
+                key={opt.value}
+                onClick={() => {
+                  onChange(opt.value);
+                  setOpen(false);
+                }}
+                role="option"
+                aria-selected={active}
+                style={{
+                  width: '100%',
+                  textAlign: 'left',
+                  padding: '8px 10px',
+                  borderRadius: 'var(--radius-sm)',
+                  background: active ? 'var(--brand-tint)' : 'transparent',
+                  color: active ? '#B4C2FF' : 'var(--text-0)',
+                  display: 'flex',
+                  flexDirection: 'column',
+                  gap: 2,
+                  cursor: 'pointer',
+                  font: 'inherit',
+                  fontSize: 13,
+                  border: 0,
+                }}
+                onMouseEnter={(e) => {
+                  if (!active) e.currentTarget.style.background = 'var(--bg-3)';
+                }}
+                onMouseLeave={(e) => {
+                  if (!active) e.currentTarget.style.background = 'transparent';
+                }}
+              >
+                <div style={{ display: 'flex', alignItems: 'baseline', gap: 8 }}>
+                  <span style={{ fontWeight: 500 }}>{opt.label}</span>
+                  {opt.meta && (
+                    <span
+                      style={{
+                        marginLeft: 'auto',
+                        color: 'var(--text-3)',
+                        fontSize: 11,
+                      }}
+                    >
+                      {opt.meta}
+                    </span>
+                  )}
+                </div>
+                {opt.description && (
+                  <div
+                    style={{
+                      fontSize: 11,
+                      color: 'var(--text-2)',
+                      lineHeight: 1.4,
+                    }}
+                  >
+                    {opt.description}
+                  </div>
+                )}
+              </button>
+            );
+          })}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/apps/desktop/src/components/InspectorRail.tsx b/apps/desktop/src/components/InspectorRail.tsx
index fe3a21a..a0d91f4 100644
--- a/apps/desktop/src/components/InspectorRail.tsx
+++ b/apps/desktop/src/components/InspectorRail.tsx
@@ -1,9 +1,10 @@
-// Right-column collapsed inspector (48 px) — design spec screen #3.
-// Five rail buttons with optional dot-badge counts:
-//   ‹ (expand) · ▤ (Plan + N) · ◐ (context %) · 📁 (files) · ⓘ (info) · ⚙ (settings)
+// Right-column collapsed inspector rail (48 px).
+// Design spec screen #3.
 //
-// For v0.1.1 expand is a stub — clicking ‹ does nothing yet (the
-// full-width inspector panel lands in P2 with the rest of the screens).
+// Each rail button routes to a screen so users can reach Plan / Files /
+// Info / Settings without scrolling for a hidden menu. The ‹ expand
+// chevron is still deferred (the full-width inspector panel lands in
+// the next phase) — we leave it disabled with a tooltip.
 
 import type { ScreenName } from './Nav.js';
 
@@ -14,7 +15,7 @@ interface InspectorRailProps {
   contextFill?: number;
   /** Active screen so settings cog highlights when on settings. */
   activeScreen: ScreenName;
-  /** Switch screen — only wired for settings cog right now. */
+  /** Switch screen. */
   onChange: (screen: ScreenName) => void;
 }
 
@@ -38,22 +39,25 @@ export function InspectorRail({
       <button
         type="button"
         className="rail-btn"
-        title="Expand inspector  (⌘\\) — coming in P2"
+        title="Expand inspector (⌘\\) — coming in next phase"
         disabled
       >
         ‹
       </button>
       <div className="rail-divider" />
+
       <button
         type="button"
-        className="rail-btn"
-        title={planCount ? `Plan · ${planCount} pending` : 'Plan'}
+        className={'rail-btn' + (activeScreen === 'permissions' ? ' active' : '')}
+        title={planCount ? `Plan & permissions · ${planCount} pending` : 'Plan & permissions'}
+        onClick={() => onChange('permissions')}
       >
         ▤
         {planCount !== undefined && planCount > 0 && (
           <span className="dot-badge">{planCount}</span>
         )}
       </button>
+
       <button
         type="button"
         className="rail-btn"
@@ -63,20 +67,56 @@ export function InspectorRail({
             : `Context: ${Math.round(contextFill * 100)}% used`
         }
         style={{ color: ctxColor, borderColor: 'rgba(20,228,162,.18)' }}
+        onClick={() => onChange('repl')}
       >
         ◐
       </button>
+
       <button
         type="button"
-        className="rail-btn"
-        title="Recent files"
-        onClick={() => onChange('repl')}
+        className={'rail-btn' + (activeScreen === 'sessions' ? ' active' : '')}
+        title="Sessions"
+        onClick={() => onChange('sessions')}
       >
-        📁
+        ◫
       </button>
-      <button type="button" className="rail-btn" title="Session info">
+
+      <button
+        type="button"
+        className={'rail-btn' + (activeScreen === 'plugins' ? ' active' : '')}
+        title="Plugins"
+        onClick={() => onChange('plugins')}
+      >
+        ⊞
+      </button>
+
+      <button
+        type="button"
+        className={'rail-btn' + (activeScreen === 'skills' ? ' active' : '')}
+        title="Skills"
+        onClick={() => onChange('skills')}
+      >
+        ✦
+      </button>
+
+      <button
+        type="button"
+        className={'rail-btn' + (activeScreen === 'mcp' ? ' active' : '')}
+        title="MCP servers"
+        onClick={() => onChange('mcp')}
+      >
+        ⊕
+      </button>
+
+      <button
+        type="button"
+        className={'rail-btn' + (activeScreen === 'about' ? ' active' : '')}
+        title="About / Info"
+        onClick={() => onChange('about')}
+      >
         ⓘ
       </button>
+
       <span className="rail-spacer" />
       <button
         type="button"
diff --git a/apps/desktop/src/components/ProjectPickerOverlay.tsx b/apps/desktop/src/components/ProjectPickerOverlay.tsx
new file mode 100644
index 0000000..a6122fc
--- /dev/null
+++ b/apps/desktop/src/components/ProjectPickerOverlay.tsx
@@ -0,0 +1,123 @@
+// First-run overlay: shown after onboarding but before chat is usable.
+// User picks a project folder via the native macOS file picker; the
+// path is persisted to settings.json#projectPath and threaded into
+// every agent.start as `cwd`.
+
+import { useState } from 'react';
+import { BrandMark } from './BrandMark.js';
+import { pickFolder } from '../lib/tauri-api.js';
+
+interface Props {
+  onPicked: (path: string) => void;
+}
+
+export function ProjectPickerOverlay({ onPicked }: Props): JSX.Element {
+  const [pending, setPending] = useState(false);
+  const [err, setErr] = useState<string | null>(null);
+
+  async function handlePick(): Promise<void> {
+    setPending(true);
+    setErr(null);
+    try {
+      const path = await pickFolder();
+      if (!path) {
+        setPending(false);
+        return; // user cancelled
+      }
+      onPicked(path);
+    } catch (e) {
+      setErr((e as Error).message ?? String(e));
+      setPending(false);
+    }
+  }
+
+  return (
+    <div className="onboarding">
+      <div className="card">
+        <span className="brand-chip">
+          <BrandMark />
+          DeepCode
+        </span>
+
+        <h1>Pick a project folder.</h1>
+        <p className="tagline">
+          Everything DeepCode reads, writes, runs, or remembers happens inside
+          one folder you choose. You can switch projects anytime from the
+          sidebar.
+        </p>
+
+        <div
+          style={{
+            background: 'var(--bg-1)',
+            border: '1px solid var(--line)',
+            borderRadius: 'var(--radius-lg)',
+            padding: 32,
+            textAlign: 'center',
+            boxShadow: 'var(--shadow)',
+          }}
+        >
+          <div
+            style={{
+              fontSize: 48,
+              marginBottom: 12,
+              color: 'var(--text-2)',
+            }}
+          >
+            📁
+          </div>
+          <div
+            style={{
+              fontSize: 13,
+              color: 'var(--text-2)',
+              marginBottom: 18,
+              lineHeight: 1.6,
+            }}
+          >
+            Common picks: a git repo, a single project root, or a sandboxed
+            scratch directory. DeepCode will never read or write outside the
+            folder you pick.
+          </div>
+
+          <button
+            type="button"
+            className="btn btn-primary"
+            onClick={handlePick}
+            disabled={pending}
+            style={{ fontSize: 14 }}
+          >
+            {pending && <span className="spinner" />}
+            {pending ? 'Opening picker…' : 'Choose folder…'}
+          </button>
+
+          {err && (
+            <div
+              style={{
+                marginTop: 14,
+                padding: '8px 12px',
+                background: 'rgba(255, 84, 112, 0.12)',
+                border: '1px solid rgba(255, 84, 112, 0.3)',
+                color: 'var(--error)',
+                borderRadius: 'var(--radius-sm)',
+                fontSize: 12,
+              }}
+            >
+              {err}
+            </div>
+          )}
+        </div>
+
+        <div
+          style={{
+            marginTop: 16,
+            fontSize: 11,
+            color: 'var(--text-3)',
+            textAlign: 'center',
+          }}
+        >
+          The path is saved to ~/.deepcode/settings.json so you don't have to
+          pick again on next launch.
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/desktop/src/components/Sidebar.tsx b/apps/desktop/src/components/Sidebar.tsx
index ad1c86f..482a71d 100644
--- a/apps/desktop/src/components/Sidebar.tsx
+++ b/apps/desktop/src/components/Sidebar.tsx
@@ -1,19 +1,23 @@
 // Left-column sessions sidebar — design spec screen #3.
 //
-// Sections: "Today / Yesterday / Earlier" bucketed by updatedAt; each
-// row shows a dot + label + relative-time meta. Active row gets the
-// brand-tinted background + 1 px brand-line border (no flat color block
-// per the spec note ①).
+// Above the session list: a "project" chip showing the currently active
+// folder + a small switch-folder button. Below: sessions bucketed by
+// Today/Yesterday/Earlier per the spec note ①.
 
 import { useEffect, useState } from 'react';
+import { projectName } from '../lib/project.js';
 import { listSessions, type SessionMeta } from '../lib/tauri-api.js';
 import { BrandMark } from './BrandMark.js';
 
 interface SidebarProps {
+  /** Absolute path of the active project folder. */
+  projectPath: string;
   /** Currently active session id; null when on transient/global screens. */
   activeSessionId: string | null;
   onPickSession: (id: string) => void;
   onNewSession: () => void;
+  /** Triggers a re-show of the folder picker so the user can switch projects. */
+  onSwitchProject: () => void;
 }
 
 type Bucket = 'Today' | 'Yesterday' | 'Earlier';
@@ -34,9 +38,11 @@ function relTime(updatedAtSecs: number, nowSecs: number): string {
 }
 
 export function Sidebar({
+  projectPath,
   activeSessionId,
   onPickSession,
   onNewSession,
+  onSwitchProject,
 }: SidebarProps): JSX.Element {
   const [sessions, setSessions] = useState<SessionMeta[]>([]);
   const [now, setNow] = useState<number>(Math.floor(Date.now() / 1000));
@@ -49,7 +55,6 @@ export function Sidebar({
     return () => clearInterval(t);
   }, []);
 
-  // Group sessions by bucket, preserving order
   const grouped: Record<Bucket, SessionMeta[]> = {
     Today: [],
     Yesterday: [],
@@ -66,6 +71,70 @@ export function Sidebar({
         <span className="name">DeepCode</span>
       </div>
 
+      {/* Active project chip */}
+      <div
+        style={{
+          margin: '4px 4px 12px',
+          padding: '8px 10px',
+          background: 'var(--bg-1)',
+          border: '1px solid var(--line)',
+          borderRadius: 'var(--radius-sm)',
+          fontSize: 11,
+          color: 'var(--text-2)',
+        }}
+        title={projectPath}
+      >
+        <div
+          style={{
+            fontSize: 9,
+            textTransform: 'uppercase',
+            letterSpacing: 1,
+            color: 'var(--text-3)',
+            marginBottom: 3,
+          }}
+        >
+          Project
+        </div>
+        <div
+          style={{
+            display: 'flex',
+            alignItems: 'center',
+            gap: 6,
+            color: 'var(--text-0)',
+            fontSize: 12,
+            fontWeight: 500,
+          }}
+        >
+          <span>📁</span>
+          <span
+            style={{
+              overflow: 'hidden',
+              textOverflow: 'ellipsis',
+              whiteSpace: 'nowrap',
+              flex: 1,
+              minWidth: 0,
+            }}
+          >
+            {projectName(projectPath)}
+          </span>
+          <button
+            type="button"
+            onClick={onSwitchProject}
+            title="Switch to another folder"
+            style={{
+              background: 'transparent',
+              border: 0,
+              color: 'var(--text-3)',
+              cursor: 'pointer',
+              fontSize: 11,
+              padding: 2,
+            }}
+          >
+            ⇄
+          </button>
+        </div>
+      </div>
+
       <button type="button" className="new-btn" onClick={onNewSession}>
         <span>+ New session</span>
         <kbd>⌘N</kbd>
@@ -96,21 +165,23 @@ export function Sidebar({
       {sessions.length === 0 && (
         <div
           style={{
-            marginTop: 16,
-            padding: '12px 8px',
+            marginTop: 12,
+            padding: '8px 8px',
             color: 'var(--text-3)',
-            fontSize: 12,
+            fontSize: 11,
             textAlign: 'center',
+            lineHeight: 1.5,
           }}
         >
-          No sessions yet — talk to DeepCode to start one.
+          No sessions yet — your conversations will appear here once you
+          start one.
         </div>
       )}
     </aside>
   );
 }
 
-/** Session ids are `2026-05-28-abc123` — strip the date for display. */
+/** Session ids look like `2026-05-28-abc123` — strip the date for display. */
 function shortTitle(id: string): string {
   const m = id.match(/^\d{4}-\d{2}-\d{2}-(.+)$/);
   return m ? m[1]! : id;
diff --git a/apps/desktop/src/lib/mac-agent.ts b/apps/desktop/src/lib/mac-agent.ts
index e46d0c6..b170288 100644
--- a/apps/desktop/src/lib/mac-agent.ts
+++ b/apps/desktop/src/lib/mac-agent.ts
@@ -23,7 +23,7 @@ import type {
   ToolHandler,
 } from '@deepcode/core/dist/types.js';
 import { MAC_TOOLS } from './mac-tools.js';
-import { readCredentials } from './tauri-api.js';
+import { readCredentials, sessionAppend, sessionCreate } from './tauri-api.js';
 
 // Local minimal ToolRegistry — same shape as @deepcode/core's, without
 // the BUILTIN_TOOLS top-level import that drags in fs.
@@ -46,9 +46,16 @@ class LocalToolRegistry {
   }
 }
 
-const SYSTEM_PROMPT = `You are DeepCode, an AI coding assistant powered by DeepSeek. \
-Help the user with their codebase using the available tools (Read, Write, Edit, Bash, Grep, Glob). \
-Be concise and accurate. When you modify files, briefly explain what you changed and why.`;
+function buildSystemPrompt(cwd?: string): string {
+  return `You are DeepCode, an AI coding assistant powered by DeepSeek.
+Help the user with their codebase using the available tools (Read, Write, Edit, Bash, Grep, Glob).
+Be concise and accurate. When you modify files, briefly explain what you changed and why.
+
+${cwd ? `Working directory: ${cwd}\nAll relative paths resolve against this directory.` : 'NO project folder has been picked yet. Tell the user to pick one before asking for file edits.'}
+
+Tool input schemas use snake_case field names (e.g. file_path, old_string).
+ALWAYS pass absolute paths or paths relative to the working directory above.`;
+}
 
 /** A single in-flight turn. */
 interface ActiveTurn {
@@ -59,6 +66,13 @@ interface ActiveTurn {
 const turns = new Map<string, ActiveTurn>();
 let history: import('@deepcode/core/dist/types.js').StoredMessage[] = [];
 let provider: DeepSeekProvider | null = null;
+// One active session id per app run — created lazily on first turn.
+let currentSessionId: string | null = null;
+
+export function clearSession(): void {
+  currentSessionId = null;
+  history = [];
+}
 
 async function ensureProvider(): Promise<DeepSeekProvider> {
   if (provider) return provider;
@@ -82,6 +96,9 @@ export interface StartTurnArgs {
   mode?: Mode;
   /** Effort tier — controls maxTokens + temperature. Default 'medium'. */
   effort?: Effort;
+  /** Project folder absolute path. Tools resolve relative paths against this.
+   *  When undefined, tools error because the agent can't safely guess. */
+  cwd?: string;
   onEvent: (e: AgentEvent) => void;
   onDone: (reason: 'end_turn' | 'max_turns' | 'aborted' | 'error') => void;
   /** Called when the agent needs user approval for a tool call. Resolves to:
@@ -104,6 +121,29 @@ export async function startAgentTurn(args: StartTurnArgs): Promise<StartTurnResu
   const abort = new AbortController();
   turns.set(turnId, { turnId, abortController: abort });
 
+  // Lazily create a session JSONL on first turn, so the sidebar can
+  // surface it. Failures here are non-fatal — we just don't persist.
+  if (!currentSessionId) {
+    try {
+      currentSessionId = await sessionCreate(args.cwd ?? '/');
+    } catch (err) {
+      console.warn('session_create failed (continuing without persistence):', err);
+    }
+  }
+  // Append the user message right away so the file shows non-zero activity.
+  if (currentSessionId) {
+    try {
+      await sessionAppend(currentSessionId, {
+        type: 'message',
+        role: 'user',
+        content: [{ type: 'text', text: args.userMessage }],
+        timestamp: new Date().toISOString(),
+      });
+    } catch (err) {
+      console.warn('session_append (user) failed:', err);
+    }
+  }
+
   const prov = await ensureProvider();
   // Cast: nominal-typing on the private `tools` field makes TS reject the
   // structural match. Runtime shape is identical.
@@ -118,13 +158,13 @@ export async function startAgentTurn(args: StartTurnArgs): Promise<StartTurnResu
       const result = await runAgent({
         provider: prov,
         tools,
-        systemPrompt: SYSTEM_PROMPT,
+        systemPrompt: buildSystemPrompt(args.cwd),
         userMessage: args.userMessage,
         history,
         model: args.model ?? 'deepseek-chat',
         maxTokens: effortParams.maxTokens,
         temperature: effortParams.temperature,
-        cwd: '/', // Renderer doesn't know real cwd; tools accept absolute paths
+        cwd: args.cwd ?? '/',
         signal: abort.signal,
         mode: args.mode,
         // Disable system reminders in the renderer — they require node:fs
@@ -143,6 +183,22 @@ export async function startAgentTurn(args: StartTurnArgs): Promise<StartTurnResu
         // No hook dispatcher, no sessions persistence, no autoCompact in v1 Mac MVP.
       });
       history = result.history;
+      // Append the new assistant message(s) for persistence.
+      if (currentSessionId && history.length > 0) {
+        const newestAssistant = [...history]
+          .reverse()
+          .find((m) => m.role === 'assistant');
+        if (newestAssistant) {
+          try {
+            await sessionAppend(currentSessionId, {
+              type: 'message',
+              ...newestAssistant,
+            });
+          } catch (err) {
+            console.warn('session_append (assistant) failed:', err);
+          }
+        }
+      }
       args.onDone(result.stopReason);
     } catch (err) {
       args.onEvent({ type: 'error', error: (err as Error).message ?? String(err) });
@@ -164,6 +220,7 @@ export function abortAgentTurn(turnId: string): boolean {
 
 export function clearHistory(): void {
   history = [];
+  currentSessionId = null;
 }
 
 export function getHistoryLength(): number {
diff --git a/apps/desktop/src/lib/mac-tools.ts b/apps/desktop/src/lib/mac-tools.ts
index 97e9c32..e748c9c 100644
--- a/apps/desktop/src/lib/mac-tools.ts
+++ b/apps/desktop/src/lib/mac-tools.ts
@@ -12,6 +12,44 @@
 import { invoke } from '@tauri-apps/api/core';
 import type { ToolHandler, ToolResult } from '@deepcode/core/dist/types.js';
 
+/**
+ * Tolerant key pick — accepts either snake_case or camelCase. DeepSeek
+ * occasionally normalizes JSON Schema keys to camelCase regardless of
+ * what we asked for; if the agent loop doesn't see the field by the
+ * exact name in the schema, the value is undefined and the Tauri call
+ * fails with "missing required key …". This helper lets us accept both.
+ */
+function pickStr(
+  input: Record<string, unknown>,
+  ...keys: string[]
+): string | undefined {
+  for (const k of keys) {
+    const v = input[k];
+    if (typeof v === 'string') return v;
+  }
+  return undefined;
+}
+function pickNum(
+  input: Record<string, unknown>,
+  ...keys: string[]
+): number | undefined {
+  for (const k of keys) {
+    const v = input[k];
+    if (typeof v === 'number') return v;
+  }
+  return undefined;
+}
+function pickBool(
+  input: Record<string, unknown>,
+  ...keys: string[]
+): boolean | undefined {
+  for (const k of keys) {
+    const v = input[k];
+    if (typeof v === 'boolean') return v;
+  }
+  return undefined;
+}
+
 // ──────────────────────────────────────────────────────────────────────────
 // Read
 // ──────────────────────────────────────────────────────────────────────────
@@ -34,15 +72,19 @@ export const MacReadTool: ToolHandler = {
   },
   async execute(input: Record<string, unknown>): Promise<ToolResult> {
     try {
+      const filePath = pickStr(input, 'file_path', 'filePath', 'path');
+      if (!filePath) {
+        return { content: 'Error: missing file_path', isError: true };
+      }
       const r = (await invoke('tool_read', {
-        filePath: input['file_path'] as string,
-        offset: input['offset'] as number | undefined,
-        limit: input['limit'] as number | undefined,
+        filePath,
+        offset: pickNum(input, 'offset'),
+        limit: pickNum(input, 'limit'),
       })) as { content: string; linesTotal: number; linesShown: number; offset: number };
       return {
         content: r.content,
         data: {
-          file: input['file_path'],
+          file: filePath,
           lines_total: r.linesTotal,
           lines_shown: r.linesShown,
           offset: r.offset,
@@ -75,14 +117,16 @@ export const MacWriteTool: ToolHandler = {
   },
   async execute(input: Record<string, unknown>): Promise<ToolResult> {
     try {
-      await invoke('tool_write', {
-        filePath: input['file_path'] as string,
-        content: input['content'] as string,
-      });
-      const lines = String(input['content'] ?? '').split('\n').length;
+      const filePath = pickStr(input, 'file_path', 'filePath', 'path');
+      const content = pickStr(input, 'content', 'text', 'body') ?? '';
+      if (!filePath) {
+        return { content: 'Error: missing file_path', isError: true };
+      }
+      await invoke('tool_write', { filePath, content });
+      const lines = content.split('\n').length;
       return {
-        content: `Wrote ${input['file_path']} (${lines} lines).`,
-        data: { file: input['file_path'], lines },
+        content: `Wrote ${filePath} (${lines} lines).`,
+        data: { file: filePath, lines },
       };
     } catch (err) {
       return { content: `Error: ${(err as Error).message ?? String(err)}`, isError: true };
@@ -113,17 +157,27 @@ export const MacEditTool: ToolHandler = {
   },
   async execute(input: Record<string, unknown>): Promise<ToolResult> {
     try {
+      const filePath = pickStr(input, 'file_path', 'filePath', 'path');
+      const oldStr = pickStr(input, 'old_string', 'oldString', 'old');
+      const newStr = pickStr(input, 'new_string', 'newString', 'new');
+      const replaceAll = pickBool(input, 'replace_all', 'replaceAll') ?? false;
+      if (!filePath || oldStr === undefined || newStr === undefined) {
+        return {
+          content: 'Error: missing file_path / old_string / new_string',
+          isError: true,
+        };
+      }
       const r = (await invoke('tool_edit', {
         input: {
-          file_path: input['file_path'] as string,
-          old_string: input['old_string'] as string,
-          new_string: input['new_string'] as string,
-          replace_all: (input['replace_all'] as boolean | undefined) ?? false,
+          file_path: filePath,
+          old_string: oldStr,
+          new_string: newStr,
+          replace_all: replaceAll,
         },
       })) as { replaced: number; diffPreview: string };
       return {
-        content: `Replaced ${r.replaced} occurrence(s) in ${input['file_path']}.\n${r.diffPreview}`,
-        data: { file: input['file_path'], replaced: r.replaced },
+        content: `Replaced ${r.replaced} occurrence(s) in ${filePath}.\n${r.diffPreview}`,
+        data: { file: filePath, replaced: r.replaced },
       };
     } catch (err) {
       return { content: `Error: ${(err as Error).message ?? String(err)}`, isError: true };
@@ -153,11 +207,15 @@ export const MacBashTool: ToolHandler = {
   },
   async execute(input: Record<string, unknown>): Promise<ToolResult> {
     try {
+      const command = pickStr(input, 'command', 'cmd');
+      if (!command) {
+        return { content: 'Error: missing command', isError: true };
+      }
       const r = (await invoke('tool_bash', {
         input: {
-          command: input['command'] as string,
-          cwd: input['cwd'] as string | undefined,
-          timeout_ms: input['timeout_ms'] as number | undefined,
+          command,
+          cwd: pickStr(input, 'cwd', 'working_dir'),
+          timeout_ms: pickNum(input, 'timeout_ms', 'timeoutMs', 'timeout'),
         },
       })) as { stdout: string; stderr: string; exitCode: number; timedOut: boolean };
       const combined =
@@ -193,9 +251,11 @@ export const MacGlobTool: ToolHandler = {
   },
   async execute(input: Record<string, unknown>): Promise<ToolResult> {
     try {
+      const pattern = pickStr(input, 'pattern', 'glob');
+      if (!pattern) return { content: 'Error: missing pattern', isError: true };
       const r = (await invoke('tool_glob', {
-        pattern: input['pattern'] as string,
-        cwd: input['cwd'] as string | undefined,
+        pattern,
+        cwd: pickStr(input, 'cwd', 'path', 'working_dir'),
       })) as { files: string[]; truncated: boolean };
       const body =
         r.files.length === 0
@@ -233,12 +293,15 @@ export const MacGrepTool: ToolHandler = {
   },
   async execute(input: Record<string, unknown>): Promise<ToolResult> {
     try {
+      const pattern = pickStr(input, 'pattern', 'regex');
+      if (!pattern) return { content: 'Error: missing pattern', isError: true };
       const r = (await invoke('tool_grep', {
         input: {
-          pattern: input['pattern'] as string,
-          path: input['path'] as string | undefined,
-          include: input['include'] as string | undefined,
-          case_insensitive: (input['case_insensitive'] as boolean | undefined) ?? false,
+          pattern,
+          path: pickStr(input, 'path', 'cwd', 'dir'),
+          include: pickStr(input, 'include', 'glob'),
+          case_insensitive:
+            pickBool(input, 'case_insensitive', 'caseInsensitive', 'ignore_case') ?? false,
         },
       })) as {
         matches: Array<{ file: string; line: number; text: string }>;
diff --git a/apps/desktop/src/lib/project.ts b/apps/desktop/src/lib/project.ts
new file mode 100644
index 0000000..3c3a84f
--- /dev/null
+++ b/apps/desktop/src/lib/project.ts
@@ -0,0 +1,32 @@
+// Project context — the absolute path to the currently-active project
+// folder. Persisted to settings.json#projectPath so the choice survives
+// restart. Driving cwd for every agent turn + tool call.
+
+import { loadSettingsFile, saveSettingsFile } from './tauri-api.js';
+
+const KEY = 'projectPath';
+
+export async function loadProjectPath(): Promise<string | undefined> {
+  try {
+    const s = (await loadSettingsFile()) as Record<string, unknown>;
+    const v = s[KEY];
+    return typeof v === 'string' ? v : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export async function saveProjectPath(path: string): Promise<void> {
+  try {
+    const s = (await loadSettingsFile()) as Record<string, unknown>;
+    await saveSettingsFile({ ...s, [KEY]: path });
+  } catch (err) {
+    console.warn('Failed to persist project path:', err);
+  }
+}
+
+/** Display the last segment of an absolute path (project name). */
+export function projectName(path: string): string {
+  const parts = path.split('/').filter(Boolean);
+  return parts[parts.length - 1] ?? path;
+}
diff --git a/apps/desktop/src/lib/tauri-api.ts b/apps/desktop/src/lib/tauri-api.ts
index 4cc6e2b..c265ce6 100644
--- a/apps/desktop/src/lib/tauri-api.ts
+++ b/apps/desktop/src/lib/tauri-api.ts
@@ -90,10 +90,38 @@ export async function saveKeybindings(value: KeybindingsConfigOnDisk): Promise<v
   await invoke('save_keybindings', { value });
 }
 
+/** Show native folder-picker dialog. Returns absolute path or null on cancel. */
+export async function pickFolder(): Promise<string | null> {
+  const { open } = await import('@tauri-apps/plugin-dialog');
+  const result: unknown = await open({
+    multiple: false,
+    directory: true,
+    title: 'Choose a project folder for DeepCode',
+  });
+  if (typeof result === 'string') return result;
+  if (Array.isArray(result) && result.length > 0 && typeof result[0] === 'string') {
+    return result[0];
+  }
+  return null;
+}
+
 export async function listSessions(): Promise<SessionMeta[]> {
   return (await invoke('list_sessions')) as SessionMeta[];
 }
 
+/** Create a new session JSONL file. Returns the generated id. */
+export async function sessionCreate(cwd: string): Promise<string> {
+  return (await invoke('session_create', { cwd })) as string;
+}
+
+/** Append one JSON message line to a session's JSONL file. */
+export async function sessionAppend(
+  id: string,
+  message: Record<string, unknown>,
+): Promise<void> {
+  await invoke('session_append', { id, message });
+}
+
 export async function cliPath(): Promise<string | null> {
   return (await invoke('cli_path')) as string | null;
 }
diff --git a/apps/desktop/src/lib/window-shim.ts b/apps/desktop/src/lib/window-shim.ts
index 7b6713d..76a11ca 100644
--- a/apps/desktop/src/lib/window-shim.ts
+++ b/apps/desktop/src/lib/window-shim.ts
@@ -4,7 +4,7 @@
 
 import type { AgentEvent, Mode } from '@deepcode/core/dist/types.js';
 import type { DeepCodeAPI } from '../types/global.js';
-import { abortAgentTurn, startAgentTurn } from './mac-agent.js';
+import { abortAgentTurn, clearHistory, startAgentTurn } from './mac-agent.js';
 import {
   appendAllowMatcher,
   getAppInfo,
@@ -102,7 +102,7 @@ export function installTauriShim(): void {
       },
     },
     agent: {
-      async start({ userMessage, model, mode, effort }) {
+      async start({ userMessage, model, mode, effort, cwd }) {
         // Pre-allocate turn ID so onEvent callbacks can reference it
         // without waiting for the promise to resolve.
         let pendingTurnId = `pending-${Date.now()}`;
@@ -110,6 +110,7 @@ export function installTauriShim(): void {
           userMessage,
           model,
           mode: mode as Mode | undefined,
+          cwd,
           effort: effort as
             | 'low'
             | 'medium'
diff --git a/apps/desktop/src/screens/Chat.tsx b/apps/desktop/src/screens/Chat.tsx
index ed9ed9b..72fc54c 100644
--- a/apps/desktop/src/screens/Chat.tsx
+++ b/apps/desktop/src/screens/Chat.tsx
@@ -1,35 +1,22 @@
-// Chat screen — REPL + side terminal pane.
-// Spec: docs/VISUAL_DESIGN.html screen #2 + #8
-// Milestone: M6-rest (terminal embed)
-
-import { useState } from 'react';
-import { Terminal } from '../components/Terminal.js';
-import { ReplScreen } from './Repl.js';
+// Legacy ChatScreen — kept for type-export symmetry only. The new shell
+// renders ReplScreen directly. The xterm terminal side-pane lives here
+// for now but isn't reachable from the active navigation; it'll move
+// into the "+ menu" panel work in the next phase.
 
 export function ChatScreen(): JSX.Element {
-  const [showTerm, setShowTerm] = useState(false);
   return (
-    <div className="relative flex h-full">
-      <div className="flex-1">
-        <ReplScreen />
-      </div>
-      <div
-        className={
-          showTerm
-            ? 'border-l border-border w-1/2'
-            : 'border-l border-border w-0 overflow-hidden'
-        }
-      >
-        {showTerm && <Terminal />}
-      </div>
-      <button
-        type="button"
-        onClick={() => setShowTerm((v) => !v)}
-        className="absolute right-3 top-3 z-10 rounded border border-border bg-bg-elevated px-2 py-1 text-xs text-muted hover:text-fg"
-        title={showTerm ? 'Hide terminal' : 'Show terminal (xterm)'}
-      >
-        {showTerm ? '◧ Hide terminal' : '⌃ Terminal'}
-      </button>
+    <div
+      style={{
+        padding: 32,
+        color: 'var(--text-2)',
+        fontSize: 13,
+      }}
+    >
+      <h2 style={{ color: 'var(--text-0)', margin: '0 0 12px' }}>Chat</h2>
+      <p>
+        The chat surface has moved into the main REPL. Click the ◐ icon in
+        the right rail to go there.
+      </p>
     </div>
   );
 }
diff --git a/apps/desktop/src/screens/Repl.tsx b/apps/desktop/src/screens/Repl.tsx
index 527ced2..0ae1c16 100644
--- a/apps/desktop/src/screens/Repl.tsx
+++ b/apps/desktop/src/screens/Repl.tsx
@@ -24,8 +24,10 @@ import {
   type KeyBinding,
   type VimMode,
 } from '@deepcode/core/dist/keybindings/vim.js';
+import { Dropdown, type DropdownOption } from '../components/Dropdown.js';
 import { Pill } from '../components/Pill.js';
 import { ToolCard } from '../components/ToolCard.js';
+import { projectName } from '../lib/project.js';
 import {
   appendAllowMatcher,
   loadKeybindings,
@@ -33,17 +35,64 @@ import {
   saveSettingsFile,
 } from '../lib/tauri-api.js';
 
+interface ReplScreenProps {
+  projectPath: string;
+  /** Called after each turn ends so the parent can refresh the sidebar. */
+  onTurnComplete?: () => void;
+}
+
 // ─── Types ────────────────────────────────────────────────────────────
 
 type Effort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
 const EFFORTS: Effort[] = ['low', 'medium', 'high', 'xhigh', 'max'];
-const EFFORT_LABELS: Record<Effort, string> = {
-  low: 'Standard',
-  medium: 'Standard+',
-  high: 'High',
-  xhigh: 'Extra High',
-  max: 'Max',
-};
+
+const EFFORT_OPTIONS: DropdownOption<Effort>[] = [
+  { value: 'low', label: 'Low', meta: '4k', description: 'Cheap & quick — short answers, simple edits.' },
+  { value: 'medium', label: 'Medium', meta: '8k', description: 'Balanced default. Good for most coding tasks.' },
+  { value: 'high', label: 'High', meta: '16k', description: 'Longer context — multi-file refactors.' },
+  { value: 'xhigh', label: 'Extra High', meta: '24k', description: 'Deep reasoning for architecture changes.' },
+  { value: 'max', label: 'Max', meta: '32k', description: 'Max tokens. Slow & expensive — use sparingly.' },
+];
+
+const MODEL_OPTIONS: DropdownOption<'deepseek-chat' | 'deepseek-reasoner'>[] = [
+  { value: 'deepseek-chat', label: 'DeepSeek-Chat', meta: '128k', description: 'Faster, cheaper. Best default.' },
+  {
+    value: 'deepseek-reasoner',
+    label: 'DeepSeek-Reasoner (R1)',
+    meta: '128k',
+    description: 'Chain-of-thought reasoning for hard problems.',
+  },
+];
+
+const MODE_OPTIONS: DropdownOption<
+  'default' | 'acceptEdits' | 'plan' | 'dontAsk' | 'bypassPermissions'
+>[] = [
+  { value: 'default', label: 'Default', meta: '●', description: 'Ask before every tool call that needs approval.' },
+  {
+    value: 'acceptEdits',
+    label: 'Accept edits',
+    meta: '✎',
+    description: 'Auto-approve Edit/Write; still ask for Bash and dangerous tools.',
+  },
+  {
+    value: 'plan',
+    label: 'Plan mode',
+    meta: '◐',
+    description: 'Read-only — write tools blocked. Use for exploring.',
+  },
+  {
+    value: 'dontAsk',
+    label: "Don't ask",
+    meta: '↯',
+    description: 'Auto-approve everything safe (no destructive operations).',
+  },
+  {
+    value: 'bypassPermissions',
+    label: 'Bypass',
+    meta: '⚡',
+    description: 'YOLO. Run anything, no approvals. Use only in scratch dirs.',
+  },
+];
 
 interface ToolInvocation {
   toolId: string;
@@ -102,13 +151,14 @@ interface PendingApproval {
 
 // ─── Component ────────────────────────────────────────────────────────
 
-export function ReplScreen(): JSX.Element {
+export function ReplScreen({
+  projectPath,
+  onTurnComplete,
+}: ReplScreenProps): JSX.Element {
   const [messages, setMessages] = useState<Msg[]>([
     {
       role: 'system',
-      text:
-        'DeepCode is ready. Ask anything about your codebase — I can ' +
-        'Read / Write / Edit / Bash / Grep / Glob your files.',
+      text: `DeepCode is ready in ${projectPath}. Ask anything about your codebase — I can Read / Write / Edit / Bash / Grep / Glob your files.`,
     },
   ]);
   const [input, setInput] = useState('');
@@ -117,9 +167,9 @@ export function ReplScreen(): JSX.Element {
   const [pendingApproval, setPendingApproval] = useState<PendingApproval | null>(null);
   const [effort, setEffort] = useState<Effort>('medium');
   const [model, setModel] = useState<string>('deepseek-chat');
-  const [mode, setMode] = useState<'default' | 'plan' | 'bypassPermissions'>(
-    'default',
-  );
+  const [mode, setMode] = useState<
+    'default' | 'acceptEdits' | 'plan' | 'dontAsk' | 'bypassPermissions'
+  >('default');
   const [usage, setUsage] = useState<{ inputTokens: number; outputTokens: number }>({
     inputTokens: 0,
     outputTokens: 0,
@@ -169,6 +219,7 @@ export function ReplScreen(): JSX.Element {
         setBusy(false);
         setActiveTurnId(null);
         setMessages((m) => finalizeStreaming(m));
+        onTurnComplete?.();
         return;
       }
       switch (e.type) {
@@ -371,6 +422,7 @@ export function ReplScreen(): JSX.Element {
         effort,
         model,
         mode,
+        cwd: projectPath,
       });
       setActiveTurnId(r.turnId);
     } catch (err) {
@@ -391,6 +443,11 @@ export function ReplScreen(): JSX.Element {
     await window.deepcode.agent.abort({ turnId: activeTurnId });
   }
 
+  // Lock all the toolbar controls (mode / model / effort) once a turn
+  // is in flight or pending approval — changing them mid-turn would
+  // contradict the system prompt already sent.
+  const controlsLocked = busy || pendingApproval !== null;
+
   // ── Context bar fill ──
   const contextWindow = 128_000;
   const usedTokens = usage.inputTokens + usage.outputTokens;
@@ -418,8 +475,11 @@ export function ReplScreen(): JSX.Element {
     <>
       <div className="chat-header">
         <span className="crumb">
-          <b>DeepCode</b>
-          {' · '}REPL
+          <b>{projectName(projectPath)}</b>
+          {' · '}
+          <span title={projectPath} className="muted">
+            {abbreviatePath(projectPath)}
+          </span>
         </span>
         <div className="right">{headerPills}</div>
       </div>
@@ -467,8 +527,12 @@ export function ReplScreen(): JSX.Element {
               >
                 +
               </button>
-              <span
-                className={
+
+              <Dropdown<typeof mode>
+                value={mode}
+                onChange={setMode}
+                disabled={controlsLocked}
+                triggerClass={
                   'mode-badge ' +
                   (mode === 'bypassPermissions'
                     ? 'bypass'
@@ -476,24 +540,12 @@ export function ReplScreen(): JSX.Element {
                       ? 'plan'
                       : 'default')
                 }
-                onClick={() =>
-                  setMode((cur) =>
-                    cur === 'default'
-                      ? 'plan'
-                      : cur === 'plan'
-                        ? 'bypassPermissions'
-                        : 'default',
-                  )
-                }
-                title="Click to cycle: default → plan → bypassPermissions"
-                style={{ cursor: 'pointer' }}
-              >
-                {mode === 'bypassPermissions'
-                  ? '⚡ Bypass'
-                  : mode === 'plan'
-                    ? '◐ Plan mode'
-                    : '● Default'}
-              </span>
+                renderTrigger={(opt) => <span>{opt.meta} {opt.label}</span>}
+                title="Mode controls how tool calls are approved"
+                panelWidth={300}
+                options={MODE_OPTIONS}
+              />
+
               {vimEnabled && (
                 <span
                   className={
@@ -510,39 +562,38 @@ export function ReplScreen(): JSX.Element {
                 </span>
               )}
               <span className="spacer" />
-              <div
-                className="model-picker"
-                onClick={() =>
-                  setModel((m) =>
-                    m === 'deepseek-chat' ? 'deepseek-reasoner' : 'deepseek-chat',
-                  )
-                }
-                title="Click to toggle model"
-              >
-                <span className="dot" />
-                <span>{model}</span>
-                <span className="meta">128k · {effort}</span>
-              </div>
-              <select
+
+              <Dropdown<typeof model>
+                value={model}
+                onChange={setModel}
+                disabled={controlsLocked}
+                dot
+                title="DeepSeek model"
+                panelWidth={280}
+                options={MODEL_OPTIONS}
+                renderTrigger={(opt) => (
+                  <>
+                    <span>{opt.label}</span>
+                    <span className="meta">{opt.meta}</span>
+                  </>
+                )}
+              />
+
+              <Dropdown<Effort>
                 value={effort}
-                onChange={(e) => void handleEffortChange(e.target.value as Effort)}
-                disabled={busy}
-                title="Effort tier — maxTokens + temperature"
-                style={{
-                  background: 'var(--bg-2)',
-                  border: '1px solid var(--line-soft)',
-                  borderRadius: 'var(--radius-sm)',
-                  color: 'var(--text-1)',
-                  padding: '5px 8px',
-                  fontSize: 12,
-                }}
-              >
-                {EFFORTS.map((t) => (
-                  <option key={t} value={t}>
-                    {t} — {EFFORT_LABELS[t]}
-                  </option>
-                ))}
-              </select>
+                onChange={(v) => void handleEffortChange(v)}
+                disabled={controlsLocked}
+                title="Effort — maxTokens + temperature"
+                panelWidth={280}
+                options={EFFORT_OPTIONS}
+                renderTrigger={(opt) => (
+                  <>
+                    <span>{opt.label}</span>
+                    <span className="meta">{opt.meta}</span>
+                  </>
+                )}
+              />
+
               {busy ? (
                 <button
                   type="button"
@@ -684,6 +735,14 @@ function renderMessage(
 
 // ─── Mutators ────────────────────────────────────────────────────────
 
+/** Abbreviate a long path by replacing $HOME prefix with "~". */
+function abbreviatePath(p: string): string {
+  // Best-effort home detection — works for /Users/<n>/... on macOS
+  const m = p.match(/^\/Users\/[^/]+/);
+  if (m) return '~' + p.slice(m[0].length);
+  return p;
+}
+
 function pickTarget(input: Record<string, unknown>): string | undefined {
   for (const k of ['file_path', 'command', 'pattern', 'path', 'url', 'query']) {
     const v = input[k];
diff --git a/apps/desktop/src/types/global.d.ts b/apps/desktop/src/types/global.d.ts
index 6f80b46..07b264b 100644
--- a/apps/desktop/src/types/global.d.ts
+++ b/apps/desktop/src/types/global.d.ts
@@ -71,6 +71,8 @@ export interface DeepCodeAPI {
       /** 'low' | 'medium' | 'high' | 'xhigh' | 'max' — controls
        *  maxTokens + temperature. Defaults to 'medium'. */
       effort?: string;
+      /** Absolute project folder path. When unset, tools error. */
+      cwd?: string;
       allowedTools?: string[];
     }) => Promise<{ turnId: string }>;
     abort: (args: { turnId: string }) => Promise<boolean>;