From 873e811aeb14c413cef6aba7b472ead25866a750 Mon Sep 17 00:00:00 2001
From: Si Hyeong Lee <writingdeveloper@users.noreply.github.com>
Date: Tue, 20 Oct 2026 20:32:49 -0700
Subject: [PATCH 1/6] feat(host): session turns for a timeline, documents
 received for a session, stored quick replies

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016NLGwiBY5uEivJqERQzcoY
---
 src/main/api/deckApi.surface.test.ts | 49 ++++++++++++++++++-
 src/main/api/deckApi.ts              | 35 +++++++++++++-
 src/main/sessionImages.test.ts       | 33 ++++++++++++-
 src/main/sessionImages.ts            | 12 ++++-
 src/main/store.ts                    |  6 ++-
 src/main/tempClean.test.ts           | 15 ++++++
 src/main/tempClean.ts                |  6 ++-
 src/preload/preload.ts               |  5 ++
 src/renderer/global.d.ts             |  7 ++-
 src/renderer/machineDeck.ts          |  5 ++
 src/shared/quickReplies.test.ts      | 34 +++++++++++++
 src/shared/quickReplies.ts           | 35 ++++++++++++++
 src/shared/sentFiles.test.ts         | 37 +++++++++++++++
 src/shared/sentFiles.ts              | 40 ++++++++++++++++
 src/shared/sessionImages.ts          | 51 +++++++++++++++++++-
 src/shared/timeline.test.ts          | 44 +++++++++++++++++
 src/shared/timeline.ts               | 71 ++++++++++++++++++++++++++++
 17 files changed, 475 insertions(+), 10 deletions(-)
 create mode 100644 src/shared/quickReplies.test.ts
 create mode 100644 src/shared/quickReplies.ts
 create mode 100644 src/shared/sentFiles.test.ts
 create mode 100644 src/shared/sentFiles.ts
 create mode 100644 src/shared/timeline.test.ts
 create mode 100644 src/shared/timeline.ts

diff --git a/src/main/api/deckApi.surface.test.ts b/src/main/api/deckApi.surface.test.ts
index c9ae341..67a80d9 100644
--- a/src/main/api/deckApi.surface.test.ts
+++ b/src/main/api/deckApi.surface.test.ts
@@ -1,5 +1,7 @@
 import { describe, it, expect, vi, beforeAll } from 'vitest';
-import { join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
+import { readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 
 // deckApi reaches Electron for dialogs/clipboard/app info; none of that is exercised here — this file
 // is about the SHAPE of the capability table, not its handlers' behavior (ipc.guard/ipc.cockpit cover those).
@@ -291,6 +293,51 @@ describe('receiving a pasted image from another machine', () => {
   });
 });
 
+describe('receiving a document from another machine', () => {
+  const b64 = (s: string | Buffer) => Buffer.from(s).toString('base64');
+  const receive = (name: unknown, data: unknown) => api['cockpit:receiveFile'].handler(name, data) as string | null;
+
+  it('needs control, like an image', () => {
+    expect(mayCallRemotely(api['cockpit:receiveFile'], ['observe'])).toBe(false);
+    expect(mayCallRemotely(api['cockpit:receiveFile'], ['control'])).toBe(true);
+  });
+
+  it('writes a text file into the temp directory under its own name, never a path the caller picked', () => {
+    const written = receive('..\\..\\Windows\\build.log', b64('line 1\nline 2\n'));
+    expect(written).not.toBeNull();
+    expect(dirname(written!)).toBe(tmpdir());
+    expect(basename(written!)).toMatch(/^devdeck-file-[0-9a-f-]{36}-build\.log$/);
+    expect(readFileSync(written!, 'utf8')).toBe('line 1\nline 2\n');
+    rmSync(written!);
+  });
+
+  it('refuses kinds that could run, and bytes that are not what the name says', () => {
+    expect(receive('setup.exe', b64('MZ'))).toBeNull();
+    expect(receive('run.ps1', b64('Remove-Item'))).toBeNull();
+    expect(receive('page.html', b64('<script>'))).toBeNull();
+    expect(receive('notes.txt', b64(Buffer.from([0x4d, 0x5a, 0x00, 0x01])))).toBeNull(); // a renamed binary
+    expect(receive('spec.pdf', b64('not a pdf'))).toBeNull();
+    expect(receive('empty.txt', '')).toBeNull();
+    expect(receive(42, b64('x'))).toBeNull();
+    expect(receive('a.txt', 42)).toBeNull();
+  });
+
+  it('accepts a PDF that starts like one', () => {
+    const written = receive('spec.pdf', b64('%PDF-1.7\n...'));
+    expect(written).toMatch(/-spec\.pdf$/);
+    rmSync(written!);
+  });
+
+  it('refuses an oversized payload before decoding it', () => {
+    expect(receive('big.log', 'A'.repeat(30 * 1024 * 1024))).toBeNull();
+  });
+});
+
+it('reads a session timeline only for an allowed project, as an observer may', async () => {
+  expect(mayCallRemotely(api['cockpit:sessionTurns'], ['observe'])).toBe(true);
+  await expect(api['cockpit:sessionTurns'].handler(join(process.cwd(), 'outside'), '00000000-0000-0000-0000-000000000000', 'claude')).resolves.toEqual([]);
+});
+
 
 it('allows revision-checked task saves only to write-authorized devices', () => {
   expect(mayCallRemotely(api['project:saveTodos'], ['observe'])).toBe(false);
diff --git a/src/main/api/deckApi.ts b/src/main/api/deckApi.ts
index 40d3c2a..d38d09e 100644
--- a/src/main/api/deckApi.ts
+++ b/src/main/api/deckApi.ts
@@ -24,14 +24,15 @@ import type { WtTab } from '../../shared/wtArgs';
 import { scanUsage } from '../usageScan';
 import { scanCodexUsage } from '../codexUsageScan';
 import { combineLocalUsageScans } from '../localUsageReport';
-import { PASTE_IMAGE_PREFIX } from '../tempClean';
+import { PASTE_IMAGE_PREFIX, SENT_FILE_PREFIX } from '../tempClean';
+import { MAX_SENT_FILE_BYTES, safeSentFileName, sentFileContentOk } from '../../shared/sentFiles';
 import { listClaudeProjectDirs } from '../usageProjectsScan';
 import { classifyUsageProjects } from '../../shared/usageProjects';
 import { validThresholds } from '../../shared/settingsValidation';
 import { sanitizeTodos } from '../../shared/tasks';
 import { getClaudeUsage, readClaudeCredentials, fetchUsageApi } from '../claudeUsage';
 import { getCodexUsage, spawnCodexAppServer } from '../codexUsage';
-import { claudeTranscriptPath, listSessionImages, readEmbeddedImage } from '../sessionImages';
+import { claudeTranscriptPath, listSessionImages, listSessionTurns, readEmbeddedImage } from '../sessionImages';
 import { encodeImageForView, MAX_VIEW_IMAGE_FILE_BYTES, VIEWABLE_IMAGE_EXT, type ViewImage } from '../imageView';
 import { runClaudeUpdate } from '../agentUpdate';
 import { UsageCoordinator, antigravityUsage } from '../usageProviders';
@@ -397,8 +398,10 @@ export function createDeckApi(cfg: DeckApiConfig): DeckApiBundle {
     shutdownIdleMinutes: cfg.store.getShutdownIdleMinutes(),
     cockpitSidebarCollapsed: cfg.store.getCockpitSidebarCollapsed(),
     sessionSummary: cfg.store.getSessionSummary(), aiSessionSummary: cfg.store.getAiSessionSummary(),
+    quickReplies: cfg.store.getQuickReplies(),
   }));
   invoke('settings:setSessionSummary', localOnly, (on: boolean) => cfg.store.setSessionSummary(on === true));
+  invoke('settings:setQuickReplies', localOnly, (list: unknown) => cfg.store.setQuickReplies(list));
   invoke('settings:setAiSessionSummary', localOnly, (on: boolean) => {
     cfg.store.setAiSessionSummary(on === true);
     aiSummarizer.setEnabled(on === true); // takes effect on the next meta refresh, no restart
@@ -1156,6 +1159,27 @@ export function createDeckApi(cfg: DeckApiConfig): DeckApiBundle {
     try { writeFileSync(file, png); } catch { return null; }
     return file;
   });
+  /**
+   * Land a document another machine attached to a session here — a log, a data file, a PDF — and
+   * hand back its path. The same narrowness as receiveImage: a fixed list of inert kinds whose bytes
+   * must match the name (see shared/sentFiles), written only into the temp directory under a name
+   * the sweeper owns, never at a caller-chosen path, and counted against the same hourly budget.
+   */
+  invoke('cockpit:receiveFile', allow('control'), (name: unknown, base64: unknown) => {
+    if (typeof name !== 'string' || typeof base64 !== 'string' || base64.length > MAX_SENT_FILE_BYTES * 2) return null;
+    const safe = safeSentFileName(name);
+    if (!safe) return null;
+    let bytes: Buffer;
+    try { bytes = Buffer.from(base64, 'base64'); } catch { return null; }
+    if (bytes.length === 0 || !sentFileContentOk(safe, bytes)) return null;
+    const now = Date.now();
+    if (now - remoteImageWindow.startMs > 3_600_000) { remoteImageWindow.startMs = now; remoteImageWindow.bytes = 0; }
+    if (remoteImageWindow.bytes + bytes.length > REMOTE_IMAGE_BYTES_PER_HOUR) return null;
+    remoteImageWindow.bytes += bytes.length;
+    const file = join(tmpdir(), `${SENT_FILE_PREFIX}${randomUUID()}-${safe}`);
+    try { writeFileSync(file, bytes); } catch { return null; }
+    return file;
+  });
 
   // Open a clicked terminal link. Terminal output is arbitrary, so (unlike shell:openExternal, which is
   // locked to DevDeck's own repo) any host is allowed — but only the http/https scheme, never file:/etc.
@@ -1194,6 +1218,13 @@ export function createDeckApi(cfg: DeckApiConfig): DeckApiBundle {
     const file = claudeTranscriptPath(pp, sessionId, CLAUDE_PROJECTS);
     return file ? listSessionImages(file) : [];
   });
+  /** The prompts the person sent in a session, with when and what came back, for the cockpit's timeline. */
+  invoke('cockpit:sessionTurns', allow('observe'), async (projectPath: string, sessionId: string, agentId?: AgentId) => {
+    const pp = String(projectPath);
+    if (!isAllowedPath(effFolders(), pp) || agentFor(agentId).id !== 'claude' || typeof sessionId !== 'string') return [];
+    const file = claudeTranscriptPath(pp, sessionId, CLAUDE_PROJECTS);
+    return file ? listSessionTurns(file) : [];
+  });
   /**
    * One of those images, as a thumbnail or at full size.
    *
diff --git a/src/main/sessionImages.test.ts b/src/main/sessionImages.test.ts
index 86a6053..a1dbfcc 100644
--- a/src/main/sessionImages.test.ts
+++ b/src/main/sessionImages.test.ts
@@ -3,7 +3,7 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { mkdtempSync, writeFileSync, appendFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { listSessionImages, readEmbeddedImage, _clearSessionImageCache } from './sessionImages';
+import { listSessionImages, listSessionTurns, readEmbeddedImage, _clearSessionImageCache } from './sessionImages';
 import { mergeImageRefs, SessionImageCollector } from '../shared/sessionImages';
 
 const PNG_B64 = Buffer.from([0x89, 0x50, 0x4e, 0x47, 1, 2, 3]).toString('base64');
@@ -131,3 +131,34 @@ describe('image context', () => {
     expect([ref.tool, ref.detail]).toEqual(['mcp__x__shot', null]);
   });
 });
+
+describe('session turns', () => {
+  const said = (text: string) => JSON.stringify({ type: 'assistant', timestamp: TS, message: { role: 'assistant', content: [{ type: 'text', text }] } });
+
+  it('keeps what the person typed, with its time and the reply that came back', () => {
+    const c = new SessionImageCollector();
+    const lines = [
+      plain('fix the login page\nit fails on submit'),
+      said('Looking at it.'),
+      toolCall('s1', 'mcp__playwright__browser_take_screenshot'),
+      toolResultWithImage('s1'),
+      said('Fixed: the handler was not awaited.'),
+      pasted(),
+      plain('<command-name>/clear</command-name>'),
+      JSON.stringify({ type: 'user', isMeta: true, timestamp: TS, message: { role: 'user', content: 'Caveat: hidden' } }),
+      plain('[Request interrupted by user]'),
+    ];
+    lines.forEach((l, i) => c.add(l, i * 100));
+    expect(c.turns).toEqual([
+      { id: 't0', ts: Date.parse(TS), text: 'fix the login page', pasted: 0, reply: 'Fixed: the handler was not awaited.' },
+      { id: 't500', ts: Date.parse(TS), text: 'look', pasted: 1, reply: null },
+    ]);
+  });
+
+  it('is listed from the same pass as the images', async () => {
+    writeFileSync(file, [plain('first'), said('ok'), plain('second')].join('\n') + '\n');
+    expect((await listSessionTurns(file)).map((t) => [t.text, t.reply])).toEqual([['first', 'ok'], ['second', null]]);
+    appendFileSync(file, said('done') + '\n');
+    expect((await listSessionTurns(file)).map((t) => t.reply)).toEqual(['ok', 'done']);
+  });
+});
diff --git a/src/main/sessionImages.ts b/src/main/sessionImages.ts
index 724bed6..7142eb7 100644
--- a/src/main/sessionImages.ts
+++ b/src/main/sessionImages.ts
@@ -3,7 +3,7 @@
 import { open, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { encodeProjectPath, isValidSessionId } from '../shared/paths';
-import { SessionImageCollector, embeddedImageBlocks, mergeImageRefs, parseEmbeddedImageId, type SessionImageRef } from '../shared/sessionImages';
+import { SessionImageCollector, embeddedImageBlocks, mergeImageRefs, parseEmbeddedImageId, type SessionImageRef, type SessionTurn } from '../shared/sessionImages';
 
 /** How far back the first look reaches. Transcripts reach 500MB; the images worth seeing are recent. */
 const FIRST_SCAN_TAIL_BYTES = 64 * 1024 * 1024;
@@ -30,6 +30,16 @@ export async function listSessionImages(file: string): Promise<SessionImageRef[]
   try { return await work; } finally { if (building.get(file) === work) building.delete(file); }
 }
 
+/**
+ * The person's prompts in the same session, oldest first — read in the same pass as the images, so
+ * the timeline costs no second walk of a transcript that can reach hundreds of megabytes.
+ */
+export async function listSessionTurns(file: string): Promise<SessionTurn[]> {
+  await listSessionImages(file);
+  const idx = cache.get(file);
+  return idx ? idx.collector.turns.map((t) => ({ ...t })) : [];
+}
+
 async function refresh(file: string): Promise<SessionImageRef[]> {
   let size: number; let mtimeMs: number;
   try { ({ size, mtimeMs } = await stat(file)); } catch { cache.delete(file); return []; }
diff --git a/src/main/store.ts b/src/main/store.ts
index 604439f..cf64df5 100644
--- a/src/main/store.ts
+++ b/src/main/store.ts
@@ -6,13 +6,14 @@ import type { StoreEntry, Folder, NoteSaveResult } from '../shared/types';
 import { sanitizePersistedList, type PersistedSession } from '../shared/cockpitPersist';
 import { sanitizeTodos, type Todo, type TodoSaveResult } from '../shared/tasks';
 import { sanitizeWindowBounds, type WindowBounds } from '../shared/windowBounds';
+import { sanitizeQuickReplies } from '../shared/quickReplies';
 import { LOCAL_MACHINE_ID, isValidMachineId, sanitizeMachineName } from '../shared/link/machine';
 import { sanitizeKnownHosts, sanitizePairedDevices, type KnownHost, type PairedDevice } from './link/devices';
 import { LINK_DEFAULT_PORT } from './link/protocol';
 
 interface StateFile {
   projects: Record<string, StoreEntry>;
-  settings?: { language?: string; baseDir?: string; folders?: Folder[]; thresholds?: { freshDays: number; warnDays: number; neglectedDays: number }; agent?: string; openAtLogin?: boolean; viewMode?: 'cards' | 'list'; cockpitSessions?: PersistedSession[]; trayAlert?: 'off' | 'attention' | 'all'; pendingAutoRestore?: PersistedSession[]; contextWindow?: number; shutdownIdleMinutes?: number; cockpitSidebarCollapsed?: boolean; sessionSummary?: boolean; aiSessionSummary?: boolean; windowBounds?: WindowBounds; machineId?: string; machineName?: string; linkHostMode?: boolean; linkPort?: number; linkDevices?: PairedDevice[]; linkHosts?: KnownHost[] };
+  settings?: { language?: string; baseDir?: string; folders?: Folder[]; thresholds?: { freshDays: number; warnDays: number; neglectedDays: number }; agent?: string; openAtLogin?: boolean; viewMode?: 'cards' | 'list'; cockpitSessions?: PersistedSession[]; trayAlert?: 'off' | 'attention' | 'all'; pendingAutoRestore?: PersistedSession[]; contextWindow?: number; shutdownIdleMinutes?: number; cockpitSidebarCollapsed?: boolean; sessionSummary?: boolean; aiSessionSummary?: boolean; quickReplies?: string[]; windowBounds?: WindowBounds; machineId?: string; machineName?: string; linkHostMode?: boolean; linkPort?: number; linkDevices?: PairedDevice[]; linkHosts?: KnownHost[] };
 }
 
 /** Error codes Windows returns while another process (AV scan, indexer, OneDrive) briefly holds the file. */
@@ -283,6 +284,9 @@ export class Store {
   // Opt-in AI refinement of that line (a haiku call per finished turn — it spends usage, so default off).
   getAiSessionSummary(): boolean { return this.state.settings?.aiSessionSummary === true; }
   setAiSessionSummary(on: boolean): void { this.state.settings = { ...(this.state.settings ?? {}), aiSessionSummary: on === true }; this.save(); }
+  /** The person's quick replies, or null while they have never edited them (the defaults are per language). */
+  getQuickReplies(): string[] | null { const q = this.state.settings?.quickReplies; return Array.isArray(q) ? sanitizeQuickReplies(q) : null; }
+  setQuickReplies(list: unknown): void { this.state.settings = { ...(this.state.settings ?? {}), quickReplies: sanitizeQuickReplies(list) }; this.save(); }
 
   getTrayAlert(): 'off' | 'attention' | 'all' { const t = this.state.settings?.trayAlert; return t === 'off' || t === 'all' ? t : 'attention'; }
   setTrayAlert(t: 'off' | 'attention' | 'all'): void { this.state.settings = { ...(this.state.settings ?? {}), trayAlert: t === 'off' || t === 'all' ? t : 'attention' }; this.save(); }
diff --git a/src/main/tempClean.test.ts b/src/main/tempClean.test.ts
index 6034828..4390aff 100644
--- a/src/main/tempClean.test.ts
+++ b/src/main/tempClean.test.ts
@@ -43,3 +43,18 @@ describe('cleanupPasteImages', () => {
     await expect(cleanupPasteImages(join(dir, 'nope'), Date.now())).resolves.toBe(0);
   });
 });
+
+describe('cleanupPasteImages and files sent from another machine', () => {
+  it('sweeps old sent files by their own prefix, and nothing that merely looks similar', async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'devdeck-clean-'));
+    try {
+      const now = Date.now();
+      const put = (name: string): string => { const p = join(dir, name); writeFileSync(p, 'x'); const t = new Date(now - 2 * DAY); utimesSync(p, t, t); return p; };
+      const sent = put('devdeck-file-0a1b2c3d-4e5f-6789-abcd-ef0123456789-build.log');
+      const near = put('devdeck-file-build.log');
+      expect(await cleanupPasteImages(dir, now)).toBe(1);
+      expect(existsSync(sent)).toBe(false);
+      expect(existsSync(near)).toBe(true);
+    } finally { rmSync(dir, { recursive: true, force: true, maxRetries: 5 }); }
+  });
+});
diff --git a/src/main/tempClean.ts b/src/main/tempClean.ts
index f1260cd..bb3e67d 100644
--- a/src/main/tempClean.ts
+++ b/src/main/tempClean.ts
@@ -6,6 +6,10 @@ import { join } from 'node:path';
 export const PASTE_IMAGE_PREFIX = 'devdeck-paste-';
 // Matches the files clipboard:readImage writes (<prefix><uuid>.png) — nothing else.
 const PASTE_IMAGE_RE = new RegExp(`^${PASTE_IMAGE_PREFIX}[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\\.png$`, 'i');
+/** Prefix for a file another machine sent to a session here (cockpit:receiveFile); swept the same way. */
+export const SENT_FILE_PREFIX = 'devdeck-file-';
+// <prefix><uuid>-<the sender's file name>
+const SENT_FILE_RE = new RegExp(`^${SENT_FILE_PREFIX}[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}-.+$`, 'i');
 
 /**
  * Best-effort sweep of stale clipboard-paste images from the OS temp dir. They're written so the
@@ -18,7 +22,7 @@ export async function cleanupPasteImages(dir: string, nowMs: number, maxAgeMs =
   try { names = await readdir(dir); } catch { return 0; }
   let removed = 0;
   for (const name of names) {
-    if (!PASTE_IMAGE_RE.test(name)) continue;
+    if (!PASTE_IMAGE_RE.test(name) && !SENT_FILE_RE.test(name)) continue;
     const file = join(dir, name);
     try {
       if (nowMs - (await stat(file)).mtimeMs > maxAgeMs) { await unlink(file); removed++; }
diff --git a/src/preload/preload.ts b/src/preload/preload.ts
index a22e43f..2b1fdb8 100644
--- a/src/preload/preload.ts
+++ b/src/preload/preload.ts
@@ -33,6 +33,7 @@ contextBridge.exposeInMainWorld('devdeck', {
   setCockpitSidebar: (collapsed: boolean) => ipcRenderer.invoke('settings:setCockpitSidebar', collapsed),
   setSessionSummary: (on: boolean) => ipcRenderer.invoke('settings:setSessionSummary', on),
   setAiSessionSummary: (on: boolean) => ipcRenderer.invoke('settings:setAiSessionSummary', on),
+  setQuickReplies: (list: string[]) => ipcRenderer.invoke('settings:setQuickReplies', list),
   usageSnapshot: () => ipcRenderer.invoke('usage:snapshot'),
   refreshUsageProviders: (opts?: { force?: boolean }) => ipcRenderer.invoke('usage:refresh', { force: opts?.force === true }),
   openUsageLogin: (providerId: 'claude' | 'codex', cols: number, rows: number) => ipcRenderer.invoke('usage:login', providerId, cols, rows),
@@ -108,6 +109,8 @@ contextBridge.exposeInMainWorld('devdeck', {
     openLink: (url: string) => ipcRenderer.invoke('cockpit:openLink', url),
     openFile: (projectPath: string, filePath: string) => ipcRenderer.invoke('cockpit:openFile', projectPath, filePath),
     receiveImage: (base64: string) => ipcRenderer.invoke('cockpit:receiveImage', base64),
+    receiveFile: (name: string, base64: string) => ipcRenderer.invoke('cockpit:receiveFile', name, base64),
+    sessionTurns: (projectPath: string, sessionId: string, agentId?: string) => ipcRenderer.invoke('cockpit:sessionTurns', projectPath, sessionId, agentId),
     sessionImages: (projectPath: string, sessionId: string, agentId?: string) => ipcRenderer.invoke('cockpit:sessionImages', projectPath, sessionId, agentId),
     sessionImage: (projectPath: string, sessionId: string, imageId: string, size?: 'thumb' | 'full') => ipcRenderer.invoke('cockpit:sessionImage', projectPath, sessionId, imageId, size),
     imageFile: (projectPath: string, filePath: string, size?: 'thumb' | 'full') => ipcRenderer.invoke('cockpit:imageFile', projectPath, filePath, size),
@@ -187,6 +190,8 @@ contextBridge.exposeInMainWorld('devdeck', {
       liveAgent: (id: string) => ipcRenderer.invoke('link:call', machineId, 'cockpit:liveAgent', [id]),
       gitInfo: (projectPath: string) => ipcRenderer.invoke('link:call', machineId, 'cockpit:gitInfo', [projectPath]),
       receiveImage: (base64: string) => ipcRenderer.invoke('link:call', machineId, 'cockpit:receiveImage', [base64]),
+      receiveFile: (name: string, base64: string) => ipcRenderer.invoke('link:call', machineId, 'cockpit:receiveFile', [name, base64]),
+      sessionTurns: (projectPath: string, sessionId: string, agentId?: string) => ipcRenderer.invoke('link:call', machineId, 'cockpit:sessionTurns', [projectPath, sessionId, agentId]),
       sessionImages: (projectPath: string, sessionId: string, agentId?: string) => ipcRenderer.invoke('link:call', machineId, 'cockpit:sessionImages', [projectPath, sessionId, agentId]),
       sessionImage: (projectPath: string, sessionId: string, imageId: string, size?: 'thumb' | 'full') => ipcRenderer.invoke('link:call', machineId, 'cockpit:sessionImage', [projectPath, sessionId, imageId, size]),
       imageFile: (projectPath: string, filePath: string, size?: 'thumb' | 'full') => ipcRenderer.invoke('link:call', machineId, 'cockpit:imageFile', [projectPath, filePath, size]),
diff --git a/src/renderer/global.d.ts b/src/renderer/global.d.ts
index 9747425..27e812f 100644
--- a/src/renderer/global.d.ts
+++ b/src/renderer/global.d.ts
@@ -18,7 +18,7 @@ declare global {
       getAgent(): Promise<import('../shared/types').AgentId>;
       setAgent(id: string): Promise<void>;
       availableAgents(): Promise<import('../shared/types').AgentId[]>;
-      getSettings(): Promise<{ baseDir: string; thresholds: { freshDays: number; warnDays: number; neglectedDays: number }; language: string; openAtLogin: boolean; platform: string; osRelease: string; ptyAvailable: boolean; viewMode: 'cards' | 'list'; trayAlert: 'off' | 'attention' | 'all'; contextWindow: number; shutdownIdleMinutes: number; cockpitSidebarCollapsed: boolean; sessionSummary: boolean; aiSessionSummary: boolean }>;
+      getSettings(): Promise<{ baseDir: string; thresholds: { freshDays: number; warnDays: number; neglectedDays: number }; language: string; openAtLogin: boolean; platform: string; osRelease: string; ptyAvailable: boolean; viewMode: 'cards' | 'list'; trayAlert: 'off' | 'attention' | 'all'; contextWindow: number; shutdownIdleMinutes: number; cockpitSidebarCollapsed: boolean; sessionSummary: boolean; aiSessionSummary: boolean; quickReplies: string[] | null }>;
       link: {
         hostStatus(): Promise<import('../main/link/linkService').HostStatus>;
         setHostMode(on: boolean): Promise<import('../main/link/linkService').HostStatus>;
@@ -65,6 +65,8 @@ declare global {
           liveAgent(id: string): Promise<import('../shared/types').AgentId | null>;
           gitInfo(projectPath: string): Promise<{ branch: string | null; dirty: number } | null>;
           receiveImage(base64: string): Promise<string | null>;
+          receiveFile(name: string, base64: string): Promise<string | null>;
+          sessionTurns(projectPath: string, sessionId: string, agentId?: string): Promise<import('../shared/sessionImages').SessionTurn[]>;
           sessionImages(projectPath: string, sessionId: string, agentId?: string): Promise<import('../shared/sessionImages').SessionImageRef[]>;
           sessionImage(projectPath: string, sessionId: string, imageId: string, size?: 'thumb' | 'full'): Promise<import('../main/imageView').ViewImage | null>;
           imageFile(projectPath: string, filePath: string, size?: 'thumb' | 'full'): Promise<import('../main/imageView').ViewImage | null>;
@@ -94,6 +96,7 @@ declare global {
       setCockpitSidebar(collapsed: boolean): Promise<void>;
       setSessionSummary(on: boolean): Promise<void>;
       setAiSessionSummary(on: boolean): Promise<void>;
+      setQuickReplies(list: string[]): Promise<void>;
       usageSnapshot(): Promise<import('../shared/usageWindows').UsageSnapshot | null>;
       refreshUsageProviders(opts?: { force?: boolean }): Promise<import('../shared/usageWindows').UsageSnapshot>;
       openUsageLogin(providerId: 'claude' | 'codex', cols: number, rows: number): Promise<{ id: string; providerId: 'claude' | 'codex' } | null>;
@@ -156,6 +159,8 @@ declare global {
         openLink(url: string): Promise<void>;
         openFile(projectPath: string, filePath: string): Promise<string>;
         receiveImage(base64: string): Promise<string | null>;
+        receiveFile(name: string, base64: string): Promise<string | null>;
+        sessionTurns(projectPath: string, sessionId: string, agentId?: string): Promise<import('../shared/sessionImages').SessionTurn[]>;
         sessionImages(projectPath: string, sessionId: string, agentId?: string): Promise<import('../shared/sessionImages').SessionImageRef[]>;
         sessionImage(projectPath: string, sessionId: string, imageId: string, size?: 'thumb' | 'full'): Promise<import('../main/imageView').ViewImage | null>;
         imageFile(projectPath: string, filePath: string, size?: 'thumb' | 'full'): Promise<import('../main/imageView').ViewImage | null>;
diff --git a/src/renderer/machineDeck.ts b/src/renderer/machineDeck.ts
index 11737b1..b63982d 100644
--- a/src/renderer/machineDeck.ts
+++ b/src/renderer/machineDeck.ts
@@ -42,6 +42,8 @@ export interface DeckFacade {
     liveAgent: (id: string) => Promise<import('../shared/types').AgentId | null>;
     gitInfo: (projectPath: string) => Promise<{ branch: string | null; dirty: number } | null>;
     receiveImage: (base64: string) => Promise<string | null>;
+    receiveFile: (name: string, base64: string) => Promise<string | null>;
+    sessionTurns: (projectPath: string, sessionId: string, agentId?: string) => Promise<import('../shared/sessionImages').SessionTurn[]>;
     sessionImages: (projectPath: string, sessionId: string, agentId?: string) => Promise<import('../shared/sessionImages').SessionImageRef[]>;
     sessionImage: (projectPath: string, sessionId: string, imageId: string, size?: 'thumb' | 'full') => Promise<import('../main/imageView').ViewImage | null>;
     imageFile: (projectPath: string, filePath: string, size?: 'thumb' | 'full') => Promise<import('../main/imageView').ViewImage | null>;
@@ -103,6 +105,9 @@ export function deckFor(machineId: string): DeckFacade {
       liveAgent: (id) => remote.cockpit.liveAgent(parseRemoteId(id).hostId),
       gitInfo: (projectPath) => remote.cockpit.gitInfo(projectPath),
       receiveImage: (base64) => remote.cockpit.receiveImage(base64),
+      // An older host has no receiveFile: its 'no such method' is passed on, so the sender can say why.
+      receiveFile: (name, base64) => remote.cockpit.receiveFile(name, base64),
+      sessionTurns: (projectPath, sessionId, agentId) => remote.cockpit.sessionTurns(projectPath, sessionId, agentId).catch(() => []),
       // A host older than the image panel has no such method; it simply has no images to show.
       sessionImages: (projectPath, sessionId, agentId) => remote.cockpit.sessionImages(projectPath, sessionId, agentId).catch(() => []),
       sessionImage: (projectPath, sessionId, imageId, size) => remote.cockpit.sessionImage(projectPath, sessionId, imageId, size).catch(() => null),
diff --git a/src/shared/quickReplies.test.ts b/src/shared/quickReplies.test.ts
new file mode 100644
index 0000000..efd43e3
--- /dev/null
+++ b/src/shared/quickReplies.test.ts
@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest';
+import { MAX_QUICK_REPLIES, parseQuickReplyText, quickReplySlot, sanitizeQuickReplies } from './quickReplies';
+
+describe('sanitizeQuickReplies', () => {
+  it('trims, drops empties and non-strings, keeps each to one line and at most nine', () => {
+    expect(sanitizeQuickReplies(['  yes ', '', 3, 'two\nlines'])).toEqual(['yes', 'two lines']);
+    expect(sanitizeQuickReplies(Array.from({ length: 12 }, (_, i) => `p${i}`))).toHaveLength(MAX_QUICK_REPLIES);
+    expect(sanitizeQuickReplies('not a list')).toEqual([]);
+  });
+
+  it('reads the settings field one phrase per line', () => {
+    expect(parseQuickReplyText('commit it\r\n\r\n  run the tests \n')).toEqual(['commit it', 'run the tests']);
+  });
+});
+
+describe('quickReplySlot', () => {
+  const key = (code: string, extra: Partial<Parameters<typeof quickReplySlot>[0]> = {}) =>
+    quickReplySlot({ type: 'keydown', ctrlKey: true, shiftKey: true, altKey: false, code, ...extra });
+
+  it('maps Ctrl+Shift+1..9 by key position, whatever character Shift makes of it', () => {
+    expect(key('Digit1')).toBe(0);
+    expect(key('Digit9')).toBe(8);
+    expect(key('Numpad3')).toBe(2);
+  });
+
+  it('leaves everything else to the terminal', () => {
+    expect(key('Digit0')).toBeNull();
+    expect(key('KeyA')).toBeNull();
+    expect(key('Digit1', { shiftKey: false })).toBeNull();
+    expect(key('Digit1', { altKey: true })).toBeNull(); // AltGr arrives as Ctrl+Alt
+    expect(key('Digit1', { repeat: true })).toBeNull();
+    expect(key('Digit1', { type: 'keyup' })).toBeNull();
+  });
+});
diff --git a/src/shared/quickReplies.ts b/src/shared/quickReplies.ts
new file mode 100644
index 0000000..4451628
--- /dev/null
+++ b/src/shared/quickReplies.ts
@@ -0,0 +1,35 @@
+// src/shared/quickReplies.ts
+// The cockpit's quick replies: a handful of phrases the person sends often ("yes, go on", "commit
+// it"), each one click or Ctrl+Shift+<n> away instead of retyped.
+
+/** As many as there are digit keys for them. */
+export const MAX_QUICK_REPLIES = 9;
+export const QUICK_REPLY_MAX_CHARS = 500;
+
+/**
+ * The phrases as they are kept: trimmed, empty ones dropped, each one line (a newline would submit
+ * half of it), at most MAX_QUICK_REPLIES. Anything that is not a list of strings is no list at all.
+ */
+export function sanitizeQuickReplies(raw: unknown): string[] {
+  if (!Array.isArray(raw)) return [];
+  const out: string[] = [];
+  for (const v of raw) {
+    if (typeof v !== 'string') continue;
+    const t = v.replace(/\s*[\r\n]+\s*/g, ' ').trim().slice(0, QUICK_REPLY_MAX_CHARS);
+    if (t) out.push(t);
+    if (out.length === MAX_QUICK_REPLIES) break;
+  }
+  return out;
+}
+
+/** The settings field's text — one phrase per line — as a list. */
+export function parseQuickReplyText(text: string): string[] {
+  return sanitizeQuickReplies(text.split(/\r?\n/));
+}
+
+/** Ctrl+Shift+1..9 → 0..8, by the key's position (Shift turns `1` into `!` on most layouts). */
+export function quickReplySlot(e: { type?: string; ctrlKey: boolean; shiftKey: boolean; altKey: boolean; metaKey?: boolean; repeat?: boolean; code?: string }): number | null {
+  if ((e.type && e.type !== 'keydown') || e.repeat || !e.ctrlKey || !e.shiftKey || e.altKey || e.metaKey) return null;
+  const m = /^(?:Digit|Numpad)([1-9])$/.exec(e.code ?? '');
+  return m ? Number(m[1]) - 1 : null;
+}
diff --git a/src/shared/sentFiles.test.ts b/src/shared/sentFiles.test.ts
new file mode 100644
index 0000000..ed5f48d
--- /dev/null
+++ b/src/shared/sentFiles.test.ts
@@ -0,0 +1,37 @@
+import { describe, it, expect } from 'vitest';
+import { MAX_SENT_FILE_BYTES, safeSentFileName, sentFileContentOk } from './sentFiles';
+
+describe('safeSentFileName', () => {
+  it('keeps only the base name and swaps out characters Windows refuses', () => {
+    expect(safeSentFileName('C:\\logs\\app.log')).toBe('app.log');
+    expect(safeSentFileName('../../etc/notes.md')).toBe('notes.md');
+    expect(safeSentFileName('what?:"now".txt')).toBe('what___now_.txt');
+    expect(safeSentFileName('보고서.pdf')).toBe('보고서.pdf');
+  });
+
+  it('refuses kinds that could run or render as a page', () => {
+    for (const n of ['a.exe', 'a.bat', 'a.ps1', 'a.js', 'a.html', 'a.svg', 'a.lnk', 'noext', 'a.txt.exe', '.txt']) {
+      expect(safeSentFileName(n), n).toBeNull();
+    }
+  });
+
+  it('caps a long name and keeps its extension', () => {
+    const out = safeSentFileName('x'.repeat(200) + '.json')!;
+    expect(out.length).toBe(80);
+    expect(out.endsWith('.json')).toBe(true);
+  });
+});
+
+describe('sentFileContentOk', () => {
+  const bytes = (s: string) => new TextEncoder().encode(s);
+  it('wants a PDF to start like one and text to hold no NUL', () => {
+    expect(sentFileContentOk('a.pdf', bytes('%PDF-1.4 ...'))).toBe(true);
+    expect(sentFileContentOk('a.pdf', bytes('MZ....'))).toBe(false);
+    expect(sentFileContentOk('a.log', bytes('ok\nfine\n'))).toBe(true);
+    expect(sentFileContentOk('a.log', new Uint8Array([0x4d, 0x5a, 0, 1]))).toBe(false);
+  });
+
+  it('refuses more than the limit', () => {
+    expect(sentFileContentOk('a.txt', new Uint8Array(MAX_SENT_FILE_BYTES + 1).fill(65))).toBe(false);
+  });
+});
diff --git a/src/shared/sentFiles.ts b/src/shared/sentFiles.ts
new file mode 100644
index 0000000..c269f75
--- /dev/null
+++ b/src/shared/sentFiles.ts
@@ -0,0 +1,40 @@
+// src/shared/sentFiles.ts
+// Which files besides images may be sent to a session on another machine, and how one is checked
+// before it is written there.
+//
+// The host writes what it is sent into its temp directory for the agent to read off a path, on
+// behalf of a device that merely holds "type in sessions". So the kinds are documents an agent reads
+// — text, data, logs, PDF — and never anything a double-click would run: no scripts, no
+// executables, no HTML.
+
+/** File kinds that travel; checked on the sender (to say so up front) and again on the host. */
+export const SENDABLE_FILE_RE = /\.(?:txt|log|md|markdown|json|jsonl|ndjson|csv|tsv|ya?ml|xml|toml|ini|cfg|conf|diff|patch|sql|pdf)$/i;
+/** What a sent file may weigh. A log or a PDF spec fits; the link's frame (8MB) holds it base64'd. */
+export const MAX_SENT_FILE_BYTES = 5 * 1024 * 1024;
+const NAME_MAX = 80;
+
+/**
+ * The sender's file name, made safe to write as the tail of a temp file name: no directories, no
+ * characters Windows refuses, at most NAME_MAX characters with the extension kept. Null for a kind
+ * that does not travel.
+ */
+export function safeSentFileName(name: string): string | null {
+  const base = String(name).split(/[\\/]/).pop() ?? '';
+  let clean = base.replace(/[<>:"|?*\u0000-\u001f]/g, '_').replace(/^[\s.]+|[\s.]+$/g, '');
+  if (!SENDABLE_FILE_RE.test(clean)) return null;
+  if (clean.length > NAME_MAX) {
+    const ext = /\.[^.]+$/.exec(clean)?.[0] ?? '';
+    clean = clean.slice(0, NAME_MAX - ext.length) + ext;
+  }
+  return clean;
+}
+
+/**
+ * Whether the bytes are what the name says: a PDF starts with `%PDF-`, and everything else is text,
+ * which never holds a NUL byte. A renamed executable is neither.
+ */
+export function sentFileContentOk(name: string, bytes: Uint8Array): boolean {
+  if (bytes.length > MAX_SENT_FILE_BYTES) return false;
+  if (/\.pdf$/i.test(name)) return bytes.length >= 5 && String.fromCharCode(...bytes.subarray(0, 5)) === '%PDF-';
+  return !bytes.includes(0);
+}
diff --git a/src/shared/sessionImages.ts b/src/shared/sessionImages.ts
index 8b42603..f287f8d 100644
--- a/src/shared/sessionImages.ts
+++ b/src/shared/sessionImages.ts
@@ -5,6 +5,7 @@
 // Claude Desktop shows those inline; a terminal cannot, so the cockpit shows them beside it. The
 // transcript is the only record that covers every source — a screenshot from an MCP tool exists
 // nowhere else on disk, only as a base64 block inside the tool result that carried it.
+import { isWrapper } from './sessionParse';
 
 /** `screenshot` = an image a tool returned; `pasted` = an image the person sent; `file` = an image path a tool touched. */
 export type SessionImageKind = 'screenshot' | 'pasted' | 'file';
@@ -30,6 +31,22 @@ export interface SessionImageRef {
   said?: string | null;
 }
 
+/** One prompt the person sent, for the cockpit's timeline. */
+export interface SessionTurn {
+  /** `t<byte offset of the prompt's line>` — stable for as long as the transcript is. */
+  id: string;
+  ts: number | null;
+  /** The prompt's first line; '' for a prompt that was only a pasted image. */
+  text: string;
+  /** How many images the person pasted with it. */
+  pasted: number;
+  /** The agent's last words in reply, as one line; null until it has said something. */
+  reply: string | null;
+}
+
+/** How many turns a session's index keeps — far more than a terminal's scrollback shows. */
+export const MAX_SESSION_TURNS = 500;
+
 const IMAGE_FILE_RE = /\.(?:png|jpe?g|gif|webp|bmp)$/i;
 /** Tool-input fields that name a file the tool reads or writes. */
 const PATH_FIELDS = ['file_path', 'path', 'filePath', 'output_path', 'outputPath', 'filename'];
@@ -132,6 +149,8 @@ export class SessionImageCollector {
   /** Per MCP server, the page its browser was last sent to. */
   private pages = new Map<string, string>();
   private lastSaid: string | null = null;
+  /** The person's prompts, oldest first, at most MAX_SESSION_TURNS. */
+  readonly turns: SessionTurn[] = [];
 
   /** `line` is one complete transcript line; `offset` is the byte offset it starts at. */
   add(line: string, offset: number): SessionImageRef[] {
@@ -140,7 +159,7 @@ export class SessionImageCollector {
     // said meanwhile. Only small lines are parsed for it; the rest are named by a regex alone.
     const small = line.length <= CONTEXT_PARSE_MAX;
     let entry: unknown;
-    if (mayHoldImage || (small && (line.includes('"tool_use"') || line.includes('"type":"text"')))) {
+    if (mayHoldImage || (small && (line.includes('"tool_use"') || line.includes('"type":"text"') || line.includes('"type":"user"')))) {
       try { entry = JSON.parse(line); } catch { entry = undefined; }
     }
     if (entry === undefined && line.includes('"tool_use"')) {
@@ -173,7 +192,12 @@ export class SessionImageCollector {
     }
     // What the agent said; a user line's text belongs to that user's own images, read below.
     const said = blocks.length ? textOf(blocks) : null;
-    if (role === 'assistant' && said) this.lastSaid = said;
+    if (role === 'assistant' && said) {
+      this.lastSaid = said;
+      const turn = this.turns[this.turns.length - 1];
+      if (turn) turn.reply = said;
+    }
+    if (role === 'user' && entry !== undefined) this.noteTurn(entry, content, offset, ts);
 
     if (mayHoldImage && entry !== undefined) {
       embeddedImageBlocks(entry).forEach((img, n) => {
@@ -191,6 +215,29 @@ export class SessionImageCollector {
     return refs;
   }
 
+  /** A user line that is something the person typed — not a tool result, a command or a reminder. */
+  private noteTurn(entry: unknown, content: unknown, offset: number, ts: number | null): void {
+    const e = entry as { type?: unknown; isMeta?: unknown; isSidechain?: unknown };
+    if (e.type !== 'user' || e.isMeta === true || e.isSidechain === true) return;
+    let raw = '';
+    let pasted = 0;
+    if (typeof content === 'string') raw = content;
+    else if (Array.isArray(content)) {
+      for (const item of content) {
+        const b = (item ?? {}) as Block;
+        if (b.type === 'tool_result') return; // the agent's own tool coming back, not a prompt
+        if (b.type === 'text' && typeof b.text === 'string') raw += (raw ? '\n' : '') + b.text;
+        else if (isEmbeddedImage(b)) pasted++;
+      }
+    } else return;
+    if (raw && isWrapper(raw)) return;
+    if (/^\s*\[Request interrupted/.test(raw)) return;
+    const text = oneLine(stripImageNoise(raw)) ?? '';
+    if (!text && pasted === 0) return;
+    this.turns.push({ id: `t${offset}`, ts, text, pasted, reply: null });
+    if (this.turns.length > MAX_SESSION_TURNS) this.turns.splice(0, this.turns.length - MAX_SESSION_TURNS);
+  }
+
   private remember(id: string, name: string, detail: string | null): void {
     this.toolNames.set(id, { name, detail });
     if (this.toolNames.size > TOOL_NAME_MEMORY) this.toolNames.delete(this.toolNames.keys().next().value as string);
diff --git a/src/shared/timeline.test.ts b/src/shared/timeline.test.ts
new file mode 100644
index 0000000..1a0ce02
--- /dev/null
+++ b/src/shared/timeline.test.ts
@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'vitest';
+import { imagesByTurn, pairTurnsWithRows, promptKey } from './timeline';
+import type { SessionImageRef, SessionTurn } from './sessionImages';
+
+const turn = (id: string, text: string, ts: number | null = null): SessionTurn => ({ id, ts, text, pasted: 0, reply: null });
+const img = (id: string, ts: number | null): SessionImageRef => ({ id, kind: 'screenshot', ts, tool: null, path: null });
+
+describe('promptKey', () => {
+  it('drops the pointer, image placeholders, an ellipsis and spacing, and folds case', () => {
+    expect(promptKey('❯  [Image #1] Fix   the Login page')).toBe('fix the login page');
+    expect(promptKey('> hello')).toBe('hello');
+    expect(promptKey('a long prompt cut short…')).toBe('a long prompt cut short');
+  });
+});
+
+describe('pairTurnsWithRows', () => {
+  it('pairs prompts newest first by how they start — a row is cut at the terminal width', () => {
+    const turns = [turn('t1', 'first question'), turn('t2', 'second, much longer question that wraps past the width of the terminal')];
+    const rows = [{ row: 10, text: '❯ first question' }, { row: 40, text: '❯ second, much longer question that wra' }];
+    expect([...pairTurnsWithRows(turns, rows)]).toEqual([['t2', 40], ['t1', 10]]);
+  });
+
+  it('skips turns the screen no longer shows, and leaves a row nothing matches alone', () => {
+    const turns = [turn('t1', 'alpha'), turn('t2', 'cleared away'), turn('t3', 'gamma')];
+    const rows = [{ row: 3, text: '❯ alpha' }, { row: 7, text: '❯ something typed elsewhere' }, { row: 9, text: '❯ gamma' }];
+    expect(pairTurnsWithRows(turns, rows)).toEqual(new Map([['t3', 9], ['t1', 3]]));
+  });
+
+  it('pairs a prompt that was only a pasted image with a row that only shows the placeholder', () => {
+    expect(pairTurnsWithRows([turn('t1', '')], [{ row: 2, text: '❯ [Image #1]' }])).toEqual(new Map([['t1', 2]]));
+  });
+
+  it('never pairs an empty row with a prompt that had words', () => {
+    expect(pairTurnsWithRows([turn('t1', 'words')], [{ row: 2, text: '❯ [Image #1]' }]).size).toBe(0);
+  });
+});
+
+describe('imagesByTurn', () => {
+  it('gives each image to the newest turn sent at or before it', () => {
+    const turns = [turn('a', 'one', 100), turn('b', 'two', 200)];
+    const refs = [img('x', 50), img('y', 150), img('z', 200), img('w', 999), img('n', null)];
+    expect(imagesByTurn(turns, refs)).toEqual(new Map([['a', ['y']], ['b', ['z', 'w']]]));
+  });
+});
diff --git a/src/shared/timeline.ts b/src/shared/timeline.ts
new file mode 100644
index 0000000..b2054a8
--- /dev/null
+++ b/src/shared/timeline.ts
@@ -0,0 +1,71 @@
+// src/shared/timeline.ts
+// The cockpit's session timeline: the prompts the person sent, from the transcript, each tied to the
+// row of the terminal it is drawn on and to the images that turn produced. Pure, so it is testable
+// without a terminal.
+import type { SessionImageRef, SessionTurn } from './sessionImages';
+
+export interface PromptRow { row: number; text: string }
+
+/** How many transcript turns may be missing from the screen (cleared, compacted) between two that show. */
+const MAX_SKIP = 6;
+/** Characters compared; a prompt row is cut at the terminal's width, so its start is what is shared. */
+const COMPARE_CHARS = 40;
+
+/** A prompt's text as it is compared: pointer, image placeholders and spacing away, case folded. */
+export function promptKey(text: string): string {
+  return text
+    .replace(/^\s*[❯>›]\s+/, '')
+    .replace(/\[Image\b[^\]]*\]/gi, ' ')
+    .replace(/…$/, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase();
+}
+
+function same(screen: string, turn: string): boolean {
+  if (!screen || !turn) return screen === turn;
+  const k = Math.min(screen.length, turn.length, COMPARE_CHARS);
+  return screen.slice(0, k) === turn.slice(0, k);
+}
+
+/**
+ * Pair each turn with the prompt row it is drawn on, walking both from the newest end.
+ *
+ * A turn the screen no longer shows (scrolled out, cleared, a long paste Claude Code folds into
+ * `[Pasted text]`) is skipped, up to MAX_SKIP in a row; a prompt row no turn matches is left alone
+ * rather than given a neighbour's turn. Returns turn id → buffer row.
+ */
+export function pairTurnsWithRows(turns: readonly SessionTurn[], rows: readonly PromptRow[]): Map<string, number> {
+  const out = new Map<string, number>();
+  let ti = turns.length - 1;
+  for (let ri = rows.length - 1; ri >= 0 && ti >= 0; ri--) {
+    const key = promptKey(rows[ri].text);
+    for (let skip = 0; skip <= MAX_SKIP && ti - skip >= 0; skip++) {
+      if (same(key, promptKey(turns[ti - skip].text))) {
+        out.set(turns[ti - skip].id, rows[ri].row);
+        ti -= skip + 1;
+        break;
+      }
+    }
+  }
+  return out;
+}
+
+/**
+ * The images each turn led to: an image belongs to the newest turn sent at or before it. Images
+ * older than the first known turn belong to none. Returns turn id → image ids, oldest first.
+ */
+export function imagesByTurn(turns: readonly SessionTurn[], refs: readonly SessionImageRef[]): Map<string, string[]> {
+  const out = new Map<string, string[]>();
+  const timed = turns.filter((t) => t.ts !== null);
+  for (const ref of refs) {
+    if (ref.ts === null) continue;
+    let owner: SessionTurn | null = null;
+    for (let i = timed.length - 1; i >= 0; i--) if ((timed[i].ts as number) <= ref.ts) { owner = timed[i]; break; }
+    if (!owner) continue;
+    const list = out.get(owner.id) ?? [];
+    list.push(ref.id);
+    out.set(owner.id, list);
+  }
+  return out;
+}

From 18f6c0bb149790f3f5c86526c5f6773508129044 Mon Sep 17 00:00:00 2001
From: Si Hyeong Lee <writingdeveloper@users.noreply.github.com>
Date: Tue, 20 Oct 2026 20:32:49 -0700
Subject: [PATCH 2/6] feat(cockpit): quick replies, session timeline, image
 markup sent back to the session, documents to a remote session

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016NLGwiBY5uEivJqERQzcoY
---
 qa/image-rows.mjs                         |   4 +-
 qa/images.mjs                             |   4 +-
 src/renderer/attachments.ts               |  74 ++++--
 src/renderer/cockpitView.ts               |  96 +++++++-
 src/renderer/features/cockpit/cockpit.css | 271 ++++++++++++++++++++++
 src/renderer/icons.ts                     |   9 +-
 src/renderer/imageMarkup.ts               | 148 ++++++++++++
 src/renderer/imageStrip.ts                |  66 +++++-
 src/renderer/locales/en.json              |  35 ++-
 src/renderer/locales/ja.json              |  35 ++-
 src/renderer/locales/ko.json              |  35 ++-
 src/renderer/locales/zh.json              |  35 ++-
 src/renderer/main.ts                      |   4 +-
 src/renderer/quickReplyMenu.ts            |  62 +++++
 src/renderer/settingsSave.ts              |   2 +-
 src/renderer/settingsView.ts              |  20 +-
 src/renderer/termMarks.ts                 |  25 +-
 src/renderer/timeline.ts                  | 157 +++++++++++++
 18 files changed, 1023 insertions(+), 59 deletions(-)
 create mode 100644 src/renderer/imageMarkup.ts
 create mode 100644 src/renderer/quickReplyMenu.ts
 create mode 100644 src/renderer/timeline.ts

diff --git a/qa/image-rows.mjs b/qa/image-rows.mjs
index 92f5e8c..ddd9612 100644
--- a/qa/image-rows.mjs
+++ b/qa/image-rows.mjs
@@ -171,7 +171,7 @@ try {
   });
 
   await check('the viewer says what led to an image and goes to its row in the terminal', async () => {
-    await win.locator('#ck-header button[aria-pressed]').click();
+    await win.locator('#ck-header button.ck-img-toggle').click();
     await win.waitForFunction(() => document.querySelectorAll('#ck-images .ck-img-thumb').length === 2);
     await win.locator('#ck-images .ck-img-thumb').nth(1).click(); // oldest: the login screenshot
     await win.waitForFunction(() => document.querySelector('.ck-img-viewer .ck-img-stage img')?.getAttribute('src')?.startsWith('data:image'));
@@ -193,7 +193,7 @@ try {
     assert.ok(spans.some((s) => s.row.includes('[Image]')), 'the login screenshot row is on screen');
     assert.ok((await screenText()).some((r) => r.includes('browser_take_screenshot (MCP)(element: "Submit button")')), 'with its call above it');
     await win.screenshot({ path: join(shots, '4-revealed.png') });
-    await win.locator('#ck-header button[aria-pressed]').click(); // close the strip again
+    await win.locator('#ck-header button.ck-img-toggle').click(); // close the strip again
     await win.waitForFunction(() => document.querySelector('#ck-images')?.classList.contains('hidden'));
   });
 
diff --git a/qa/images.mjs b/qa/images.mjs
index 4e6a639..d6fb630 100644
--- a/qa/images.mjs
+++ b/qa/images.mjs
@@ -79,7 +79,7 @@ try {
   });
 
   await check('toggle opens the strip with three thumbnails, newest first', async () => {
-    await win.locator('#ck-header button[aria-pressed]').click();
+    await win.locator('#ck-header button.ck-img-toggle').click();
     await win.waitForFunction(() => document.querySelectorAll('#ck-images .ck-img-thumb img[src^="data:image"]').length === 3);
     const kinds = await win.evaluate(() => [...document.querySelectorAll('#ck-images .ck-img-thumb')].map((b) => b.className.match(/kind-(\w+)/)[1]));
     assert.deepEqual(kinds, ['file', 'pasted', 'screenshot']);
@@ -120,7 +120,7 @@ try {
   });
 
   await check('a new image in the transcript shows up as unseen when the strip is closed', async () => {
-    await win.locator('#ck-header button[aria-pressed="true"]').click(); // close
+    await win.locator('#ck-header button.ck-img-toggle').click(); // close
     writeFileSync(join(tdir, sid + '.jsonl'), readFileSync(join(tdir, sid + '.jsonl'), 'utf8') + JSON.stringify({ type: 'user', timestamp: new Date().toISOString(), message: { role: 'user', content: [{ type: 'image', source: { type: 'base64', media_type: 'image/png', data: pngB } }] } }) + '\n');
     // Re-select to refresh (a turn end does the same in real use).
     await win.evaluate(() => window.dispatchEvent(new Event('focus')));
diff --git a/src/renderer/attachments.ts b/src/renderer/attachments.ts
index c010b2c..26ecdf0 100644
--- a/src/renderer/attachments.ts
+++ b/src/renderer/attachments.ts
@@ -3,8 +3,9 @@
 //
 // An agent takes a file by its PATH, typed into its prompt — the same trick the Ctrl+V image paste
 // uses. A local session gets the file's own path. A session on another machine cannot read this
-// disk, so an image travels instead (as PNG, the one format the host accepts) and the path it was
-// written to over there is what gets typed.
+// disk, so the file travels instead and the path it was written to over there is what gets typed:
+// an image as PNG, a document (text, data, log, PDF — see shared/sentFiles) as it is.
+import { MAX_SENT_FILE_BYTES, SENDABLE_FILE_RE } from '../shared/sentFiles';
 
 /** What the host accepts per image (see cockpit:receiveImage); kept a little under it. */
 const MAX_IMAGE_BYTES = 5 * 1024 * 1024 - 64 * 1024;
@@ -15,22 +16,47 @@ export interface AttachTarget {
   local: boolean;
   /** Writes PNG bytes where the session runs and returns that path. */
   receiveImage(base64: string): Promise<string | null>;
+  /** Writes a document where the session runs and returns that path; absent where it cannot. */
+  receiveFile?(name: string, base64: string): Promise<string | null>;
   pathForFile(file: File): string;
 }
 
-export interface AttachOutcome { paths: string[]; skippedNonImage: number; failed: number; tooLarge: number }
+/**
+ * `skippedNonImage`: kinds that cannot travel at all. `hostTooOld`: documents the other machine
+ * could not take because its DevDeck predates receiving them.
+ */
+export interface AttachOutcome { paths: string[]; skippedNonImage: number; failed: number; tooLarge: number; hostTooOld: number }
 
 export function isImageFile(file: File): boolean {
   return IMAGE_TYPE_RE.test(file.type) || IMAGE_NAME_RE.test(file.name);
 }
 
+export function isSendableFile(file: File): boolean {
+  return SENDABLE_FILE_RE.test(file.name);
+}
+
+/** What the 📎 picker offers for a session on another machine. */
+export const REMOTE_ACCEPT = 'image/png,image/jpeg,image/gif,image/webp,image/bmp,' +
+  '.txt,.log,.md,.markdown,.json,.jsonl,.ndjson,.csv,.tsv,.yaml,.yml,.xml,.toml,.ini,.cfg,.conf,.diff,.patch,.sql,.pdf';
+
 export async function attachFiles(files: File[], target: AttachTarget): Promise<AttachOutcome> {
-  const out: AttachOutcome = { paths: [], skippedNonImage: 0, failed: 0, tooLarge: 0 };
+  const out: AttachOutcome = { paths: [], skippedNonImage: 0, failed: 0, tooLarge: 0, hostTooOld: 0 };
   for (const file of files) {
     const own = target.local ? target.pathForFile(file) : '';
     if (own) { out.paths.push(own); continue; }
-    // Remote, or dragged out of a browser with no file behind it: only an image can travel.
-    if (!isImageFile(file)) { out.skippedNonImage++; continue; }
+    // Remote, or dragged out of a browser with no file behind it: the file itself has to travel.
+    if (!isImageFile(file)) {
+      if (!target.receiveFile || !isSendableFile(file)) { out.skippedNonImage++; continue; }
+      if (file.size > MAX_SENT_FILE_BYTES) { out.tooLarge++; continue; }
+      let landed: string | null = null;
+      try { landed = await target.receiveFile(file.name, bytesToBase64(new Uint8Array(await file.arrayBuffer()))); }
+      catch (error) {
+        if (/no such method/.test(error instanceof Error ? error.message : String(error))) { out.hostTooOld++; continue; }
+        landed = null;
+      }
+      if (landed) out.paths.push(landed); else out.failed++;
+      continue;
+    }
     let png: string | null;
     try { png = await toPngBase64(file); } catch { png = null; }
     if (png === null) { out.tooLarge++; continue; }
@@ -54,21 +80,27 @@ export function pathsAsPrompt(paths: string[]): string {
 async function toPngBase64(file: File): Promise<string | null> {
   if (/png$/i.test(file.type) && file.size <= MAX_IMAGE_BYTES) return bytesToBase64(new Uint8Array(await file.arrayBuffer()));
   const bitmap = await createImageBitmap(file);
-  try {
-    let scale = 1;
-    for (let attempt = 0; attempt < 6; attempt++) {
-      const w = Math.max(1, Math.round(bitmap.width * scale));
-      const h = Math.max(1, Math.round(bitmap.height * scale));
-      const canvas = document.createElement('canvas'); canvas.width = w; canvas.height = h;
-      const ctx = canvas.getContext('2d'); if (!ctx) return null;
-      ctx.drawImage(bitmap, 0, 0, w, h);
-      const blob = await new Promise<Blob | null>((resolve) => canvas.toBlob(resolve, 'image/png'));
-      if (!blob) return null;
-      if (blob.size <= MAX_IMAGE_BYTES) return bytesToBase64(new Uint8Array(await blob.arrayBuffer()));
-      scale *= Math.sqrt(MAX_IMAGE_BYTES / blob.size) * 0.9;
-    }
-    return null;
-  } finally { bitmap.close(); }
+  try { return await fitPngBase64(bitmap, bitmap.width, bitmap.height); } finally { bitmap.close(); }
+}
+
+/**
+ * A drawable (an image, a canvas with marks on it) as base64 PNG within the size the host accepts,
+ * scaled down until it fits. Null when it will not fit even small.
+ */
+export async function fitPngBase64(source: CanvasImageSource, width: number, height: number): Promise<string | null> {
+  let scale = 1;
+  for (let attempt = 0; attempt < 6; attempt++) {
+    const w = Math.max(1, Math.round(width * scale));
+    const h = Math.max(1, Math.round(height * scale));
+    const canvas = document.createElement('canvas'); canvas.width = w; canvas.height = h;
+    const ctx = canvas.getContext('2d'); if (!ctx) return null;
+    ctx.drawImage(source, 0, 0, w, h);
+    const blob = await new Promise<Blob | null>((resolve) => canvas.toBlob(resolve, 'image/png'));
+    if (!blob) return null;
+    if (blob.size <= MAX_IMAGE_BYTES) return bytesToBase64(new Uint8Array(await blob.arrayBuffer()));
+    scale *= Math.sqrt(MAX_IMAGE_BYTES / blob.size) * 0.9;
+  }
+  return null;
 }
 
 function bytesToBase64(bytes: Uint8Array): string {
diff --git a/src/renderer/cockpitView.ts b/src/renderer/cockpitView.ts
index 93d7c3e..c45df50 100644
--- a/src/renderer/cockpitView.ts
+++ b/src/renderer/cockpitView.ts
@@ -28,8 +28,12 @@ import { followPtySize, type TerminalDims } from '../shared/terminalSize';
 import { basename } from '../shared/paths';
 import type { PtySessionInfo as RunningSession } from '../main/ptyHost';
 import { currentImageRefs, currentImageSourceKey, imageStripState, imageThumbUrl, initImageStrip, openImageById, openSingleImage, refreshImages, showImagesFor, toggleImageStrip, type ImageSource } from './imageStrip';
-import { jumpToPrompt, marksFor } from './termMarks';
-import { attachFiles, pathsAsPrompt } from './attachments';
+import { jumpToPrompt, marksFor, promptRows, revealRow } from './termMarks';
+import { attachFiles, pathsAsPrompt, REMOTE_ACCEPT } from './attachments';
+import { initTimeline, isTimelineOpen, refreshTimeline, showTimelineFor, toggleTimeline, type TimelineSource } from './timeline';
+import { pairTurnsWithRows } from '../shared/timeline';
+import { isQuickReplyMenuOpen, quickReplies, setQuickReplies, toggleQuickReplyMenu } from './quickReplyMenu';
+import { quickReplySlot } from '../shared/quickReplies';
 
 /** What cockpit:sessionMeta answers with: the log-derived facts plus the ready-made summary line. */
 type SessionMetaView = { model: string | null; activeMs: number; contextTokens: number; contextWindow?: number; summary: string | null };
@@ -129,6 +133,8 @@ export function setCockpitSessionSummary(on: boolean): void {
 }
 /** The opt-in AI refinement — the renderer needs it only to know whether a result is worth waiting for. */
 export function setCockpitAiSummary(on: boolean): void { aiSummaryEnabled = on === true; }
+/** The person's quick replies (null = the defaults for the language); set at boot and from settings. */
+export function setCockpitQuickReplies(list: string[] | null): void { setQuickReplies(list); }
 let searchEl: HTMLInputElement, groupsEl: HTMLElement, headerEl: HTMLElement, termsEl: HTMLElement, emptyEl: HTMLElement, mainEl: HTMLElement;
 let mounted = false;
 // Session-sidebar collapse (terminal gets the full width) — set from settings at boot + on toggle.
@@ -159,7 +165,9 @@ export function mountCockpit(): void {
   mainEl = document.querySelector('#view-cockpit .ck-main')!;
   const strip = document.getElementById('ck-images');
   // The strip opening or closing changes the terminal's height, and its count lives in the header.
-  if (strip) initImageStrip(strip, () => { if (!editingId) renderHeader(); scheduleLayout(); }, { popupIn: termsEl, refsChanged: markSelectedTerminal });
+  if (strip) initImageStrip(strip, () => { if (!editingId) renderHeader(); scheduleLayout(); }, { popupIn: termsEl, refsChanged: () => { markSelectedTerminal(); void refreshTimeline(); } });
+  // Floats over the terminal's right edge, so opening it never resizes the pty.
+  initTimeline(termsEl, () => { if (!editingId) renderHeader(); });
   // Mid-turn, new screenshots show up as they are taken rather than at the end of the turn; between
   // turns a slow re-read still catches images written some other way (another process, a resume).
   // Only the selected session is ever read, and an unchanged transcript costs one stat.
@@ -717,11 +725,12 @@ function pasteClipboardText(term: Terminal): void {
   void window.devdeck.clipboard.readText().then((t) => { if (t) term.paste(t); });
 }
 
-/** Give files to a session: by their own path locally, as uploaded images on another machine. */
+/** Give files to a session: by their own path locally, as uploaded copies on another machine. */
 async function attachToTerminal(files: File[], machineId: string, term: Terminal): Promise<void> {
   const out = await attachFiles(files, {
     local: machineId === LOCAL_MACHINE_ID,
     receiveImage: (b64) => deckFor(machineId).cockpit.receiveImage(b64),
+    receiveFile: (name, b64) => deckFor(machineId).cockpit.receiveFile(name, b64),
     pathForFile: (f) => window.devdeck.cockpit.pathForFile(f),
   });
   if (out.paths.length) { term.paste(pathsAsPrompt(out.paths)); term.focus(); }
@@ -729,7 +738,8 @@ async function attachToTerminal(files: File[], machineId: string, term: Terminal
   // one the person goes on talking about while the agent never saw it.
   const notes: string[] = [];
   if (out.paths.length) notes.push(tr('cockpit.attached', { count: String(out.paths.length) }));
-  if (out.skippedNonImage) notes.push(tr('cockpit.attach_images_only', { count: String(out.skippedNonImage), machine: machineName(machineId) }));
+  if (out.skippedNonImage) notes.push(tr('cockpit.attach_kinds_only', { count: String(out.skippedNonImage), machine: machineName(machineId) }));
+  if (out.hostTooOld) notes.push(tr('cockpit.attach_host_too_old', { count: String(out.hostTooOld), machine: machineName(machineId) }));
   if (out.tooLarge) notes.push(tr('cockpit.remote_image_too_large'));
   if (out.failed) notes.push(tr('cockpit.remote_image_failed'));
   if (notes.length) toast(notes.join(' · '));
@@ -738,8 +748,8 @@ async function attachToTerminal(files: File[], machineId: string, term: Terminal
 /** 📎: the same as a drop, through the system file picker. */
 function pickAttachments(machineId: string, term: Terminal): void {
   const input = document.createElement('input'); input.type = 'file'; input.multiple = true;
-  // A remote session can only take images, so the picker offers only those there.
-  if (machineId !== LOCAL_MACHINE_ID) input.accept = 'image/png,image/jpeg,image/gif,image/webp,image/bmp';
+  // A remote session takes images and documents (see shared/sentFiles), so the picker offers those there.
+  if (machineId !== LOCAL_MACHINE_ID) input.accept = REMOTE_ACCEPT;
   input.addEventListener('change', () => { const files = Array.from(input.files ?? []); if (files.length) void attachToTerminal(files, machineId, term); });
   input.click();
 }
@@ -758,9 +768,52 @@ function imageSourceFor(l: { session: CockpitSession; machineId: string; openedS
     openFile: l.machineId === LOCAL_MACHINE_ID ? (path) => { void window.devdeck.cockpit.openFile(projectPath, path); } : undefined,
     canReveal: term ? (id) => marksFor(term).locate(id) !== null : undefined,
     reveal: term ? (id) => { marksFor(term).reveal(id); term.focus(); } : undefined,
+    attach: term ? (png) => attachPicture(l.machineId, term, png) : undefined,
   };
 }
 
+/**
+ * A picture from the viewer — marked up or as it was — handed to the session the way a pasted
+ * screenshot is: written where the session runs, its path typed into the prompt.
+ */
+async function attachPicture(machineId: string, term: Terminal, png: string): Promise<boolean> {
+  let path: string | null = null;
+  try { path = await deckFor(machineId).cockpit.receiveImage(png); } catch { path = null; }
+  if (!path) return false;
+  term.paste(path + ' ');
+  term.focus();
+  return true;
+}
+
+/** Where the timeline reads a session's turns from, and how it finds them in the terminal. */
+function timelineSourceFor(l: Live): TimelineSource | null {
+  const sid = l.openedSessionId;
+  if (!sid || l.session.agentId !== 'claude') return null;
+  const deck = deckFor(l.machineId);
+  const projectPath = l.session.projectPath;
+  const term = l.term;
+  const key = `${l.machineId}|${projectPath}|${sid}`;
+  return {
+    key,
+    turns: () => deck.cockpit.sessionTurns(projectPath, sid, 'claude'),
+    // Shared with the image strip, which reads the same session's list.
+    images: () => (currentImageSourceKey() === key ? currentImageRefs() : []),
+    locate: (turns) => pairTurnsWithRows(turns, promptRows(term)),
+    reveal: (row) => { revealRow(term, row); term.focus(); },
+    openImage: (id) => { openImageById(id); },
+  };
+}
+
+/** Type a quick reply into a session and send it, as if the person had typed it and pressed Enter. */
+function sendQuickReply(id: string, text: string): void {
+  const l = live.get(id);
+  if (!l || l.session.status === 'exited') return;
+  l.term.paste(text);
+  // Enter on its own, after the paste: inside the paste it would be text, not a submit.
+  setTimeout(() => l.term.input(String.fromCharCode(13)), 30);
+  l.term.focus();
+}
+
 /** Pair the selected session's images with the rows of its terminal they were printed on. */
 function markSelectedTerminal(): void {
   const l = selectedId ? live.get(selectedId) : null;
@@ -991,6 +1044,16 @@ async function buildTile(p: OpenReq): Promise<boolean> {
       return false;
     }
     if (action === 'find') { e.preventDefault(); openFindBar(); return false; } // Ctrl+F searches scrollback, never reaches the PTY
+    const slot = quickReplySlot(e);
+    if (slot !== null) {
+      e.preventDefault();
+      const text = quickReplies()[slot];
+      // By terminal, not by the session declared below: a key can arrive while the tile is still opening.
+      const owner = [...live.values()].find((x) => x.term === term);
+      if (!text) toast(tr('cockpit.quick_reply_none', { n: String(slot + 1) }));
+      else if (owner) sendQuickReply(owner.session.id, text);
+      return false;
+    }
     if (action === 'prompt-prev' || action === 'prompt-next') {
       e.preventDefault();
       if (!jumpToPrompt(term, action === 'prompt-prev' ? -1 : 1)) toast(tr('cockpit.prompt_none'));
@@ -1663,6 +1726,7 @@ function select(id: string): void {
   void refreshGit(id);
   void refreshImages(); // renderHeader pointed the strip at this session; a re-select re-reads it too
   markSelectedTerminal();
+  void refreshTimeline();
   // Selecting a tile is when its provider is most visible (header mark + usage footer) — re-check it
   // here too instead of waiting up to 30s for the tick. Main's listing is cached, so this is cheap.
   void refreshProvider(id);
@@ -1796,8 +1860,9 @@ function tickActivity(): void {
     }
     if (next !== prev) {
       l.session.activity = next; changed = true;
+      if (l.session.id === selectedId) headerEl.querySelector('.ck-qr-btn')?.classList.toggle('ready', next === 'turn' || next === 'idle');
       // A turn just ended: whatever it looked at is in the transcript now.
-      if (prev === 'working' && l.session.id === selectedId) void refreshImages();
+      if (prev === 'working' && l.session.id === selectedId) { void refreshImages(); void refreshTimeline(); }
       // A turn just finished → a new assistant model may have been logged; refresh so the sidebar model
       // isn't stuck on the previous turn's model after a /model switch (only otherwise refreshed on the
       // 30s tick). The drift check rides along so a /clear is adopted within seconds of the next turn,
@@ -2180,6 +2245,7 @@ function renderHeader(): void {
   headerEl.replaceChildren();
   const l = selectedId ? live.get(selectedId) : null;
   showImagesFor(l ? imageSourceFor(l) : null);
+  showTimelineFor(l ? timelineSourceFor(l) : null);
   if (!l) return;
   const s = l.session;
   const title = document.createElement('span'); title.className = 'title';
@@ -2213,12 +2279,24 @@ function renderHeader(): void {
   });
   const restart = actBtn('restart', tr('cockpit.restart'), () => restartSession(s.id));
   const attach = actBtn('paperclip', tr(l.machineId === LOCAL_MACHINE_ID ? 'cockpit.attach' : 'cockpit.attach_remote'), () => pickAttachments(l.machineId, l.term));
+  // Quick replies: lit up when the session is waiting for the person, which is when they are for.
+  const reply = actBtn('reply', tr('cockpit.quick_replies'), () => toggleQuickReplyMenu(reply, (text) => sendQuickReply(s.id, text)));
+  reply.classList.add('ck-qr-btn');
+  reply.setAttribute('aria-haspopup', 'menu'); reply.setAttribute('aria-expanded', String(isQuickReplyMenuOpen()));
+  reply.classList.toggle('ready', s.activity === 'turn' || s.activity === 'idle');
+  const timeline: HTMLElement[] = [];
+  if (s.agentId === 'claude') {
+    const b = actBtn('timeline', tr(isTimelineOpen() ? 'cockpit.timeline_hide' : 'cockpit.timeline_show'), () => toggleTimeline());
+    b.classList.toggle('on', isTimelineOpen()); b.setAttribute('aria-pressed', String(isTimelineOpen()));
+    timeline.push(b);
+  }
   // The image strip's toggle, with how many images there are — and how many arrived unseen, which is
   // the reason to open it.
   const images: HTMLElement[] = [];
   if (s.agentId === 'claude') {
     const st = imageStripState();
     const b = actBtn('image', tr(st.open ? 'cockpit.images_hide' : 'cockpit.images_show'), () => toggleImageStrip());
+    b.classList.add('ck-img-toggle');
     b.classList.toggle('on', st.open); b.setAttribute('aria-pressed', String(st.open));
     if (st.total > 0) {
       const n = document.createElement('span'); n.className = `ck-img-count${st.unseen > 0 ? ' new' : ''}`;
@@ -2250,7 +2328,7 @@ function renderHeader(): void {
     b.addEventListener('click', () => void updateAllClaude());
     update.push(b);
   }
-  headerEl.append(...pills, sp, ...update, ...images, attach, newSession, pin, rename, folder, restart, close);
+  headerEl.append(...pills, sp, ...update, reply, ...timeline, ...images, attach, newSession, pin, rename, folder, restart, close);
 }
 
 /** "+ New session": spawn another, fresh conversation in the SAME project as the selected session. */
diff --git a/src/renderer/features/cockpit/cockpit.css b/src/renderer/features/cockpit/cockpit.css
index 193d059..971fe94 100644
--- a/src/renderer/features/cockpit/cockpit.css
+++ b/src/renderer/features/cockpit/cockpit.css
@@ -320,3 +320,274 @@
   max-height: 160px;
   border-radius: 3px;
 }
+
+/* ---- quick replies ---- */
+/* The session is waiting for the person: a dot on the button says a reply is what it needs. */
+#view-cockpit .ck-act.ck-qr-btn.ready {
+  position: relative;
+  color: var(--text);
+}
+
+#view-cockpit .ck-act.ck-qr-btn.ready::after {
+  content: "";
+  position: absolute;
+  top: 5px;
+  right: 5px;
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: var(--dd-success);
+}
+
+.ck-qr-menu {
+  position: fixed;
+  z-index: 60;
+  display: flex;
+  flex-direction: column;
+  min-width: 240px;
+  max-width: min(420px, calc(100vw - 16px));
+  padding: 4px;
+  border: 1px solid var(--border-strong);
+  border-radius: 8px;
+  background: var(--dd-surface-raised);
+  box-shadow: 0 10px 28px rgba(0, 0, 0, 0.45);
+}
+
+.ck-qr-item {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 7px 10px;
+  border: 0;
+  border-radius: 5px;
+  background: transparent;
+  color: var(--text);
+  font: inherit;
+  font-size: var(--fs-body);
+  text-align: left;
+  cursor: pointer;
+}
+
+.ck-qr-item:hover,
+.ck-qr-item:focus-visible {
+  background: var(--surface);
+  outline: none;
+}
+
+.ck-qr-text {
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.ck-qr-key {
+  flex: 0 0 auto;
+  font-family: var(--mono);
+  font-size: 10.5px;
+  color: var(--text-faint);
+}
+
+.ck-qr-hint {
+  padding: 6px 10px 4px;
+  border-top: 1px solid var(--border);
+  margin-top: 4px;
+  font-size: var(--fs-meta);
+  color: var(--text-faint);
+}
+
+/* ---- timeline: floats over the terminal's right edge, so opening it never resizes the pty ---- */
+.ck-timeline {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  z-index: 5;
+  display: flex;
+  flex-direction: column;
+  width: min(320px, 45%);
+  border-left: 1px solid var(--border-strong);
+  background: color-mix(in srgb, var(--dd-surface-raised) 96%, transparent);
+  box-shadow: -8px 0 24px rgba(0, 0, 0, 0.35);
+}
+
+.ck-tl-head {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 6px 6px 6px 12px;
+  border-bottom: 1px solid var(--border);
+}
+
+.ck-tl-title {
+  flex: 1;
+  font-size: var(--fs-body);
+  font-weight: 600;
+  color: var(--text);
+}
+
+.ck-tl-head .ck-act {
+  display: inline-grid;
+  width: 26px;
+  height: 26px;
+  place-items: center;
+  padding: 0;
+}
+
+.ck-tl-list {
+  flex: 1;
+  min-height: 0;
+  margin: 0;
+  padding: 4px 0;
+  overflow-y: auto;
+  list-style: none;
+}
+
+.ck-tl-day {
+  padding: 8px 12px 2px;
+  font-size: 10.5px;
+  color: var(--text-faint);
+}
+
+.ck-tl-empty {
+  padding: 16px 12px;
+  font-size: var(--fs-body);
+  color: var(--text-dim);
+}
+
+.ck-tl-item {
+  display: flex;
+  align-items: flex-start;
+  gap: 2px;
+  padding: 0 6px;
+}
+
+.ck-tl-jump {
+  flex: 1;
+  min-width: 0;
+  display: grid;
+  grid-template-columns: auto 1fr;
+  column-gap: 8px;
+  row-gap: 1px;
+  padding: 6px;
+  border: 0;
+  border-radius: 5px;
+  background: transparent;
+  color: var(--text);
+  font: inherit;
+  text-align: left;
+  cursor: pointer;
+}
+
+.ck-tl-jump:hover,
+.ck-tl-jump:focus-visible {
+  background: var(--surface);
+  outline: none;
+}
+
+.ck-tl-time {
+  grid-row: span 2;
+  padding-top: 1px;
+  font-family: var(--mono);
+  font-size: 10.5px;
+  color: var(--text-faint);
+  font-variant-numeric: tabular-nums;
+}
+
+.ck-tl-text {
+  font-size: var(--fs-body);
+  line-height: 1.35;
+  display: -webkit-box;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+  overflow-wrap: anywhere;
+}
+
+.ck-tl-reply {
+  grid-column: 2;
+  font-size: var(--fs-meta);
+  color: var(--text-dim);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+/* Known from the transcript but no longer in the scrollback: shown, not jumpable. */
+.ck-tl-item.gone .ck-tl-jump {
+  cursor: default;
+}
+
+.ck-tl-item.gone .ck-tl-text {
+  color: var(--text-dim);
+}
+
+.ck-tl-images {
+  flex: 0 0 auto;
+  display: inline-flex;
+  align-items: center;
+  gap: 3px;
+  margin-top: 5px;
+  padding: 2px 6px;
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  background: transparent;
+  color: var(--text-dim);
+  font: inherit;
+  font-size: 10.5px;
+  cursor: pointer;
+}
+
+.ck-tl-images:hover,
+.ck-tl-images:focus-visible {
+  color: var(--text);
+  border-color: var(--border-strong);
+}
+
+.ck-tl-images svg {
+  width: 12px;
+  height: 12px;
+}
+
+/* ---- image markup ---- */
+.ck-img-markup {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  pointer-events: none;
+}
+
+.ck-img-markup.on {
+  pointer-events: auto;
+  cursor: crosshair;
+  touch-action: none;
+}
+
+.ck-img-tools {
+  display: inline-flex;
+  align-items: center;
+  gap: 2px;
+  padding: 0 6px;
+  border-left: 1px solid rgba(255, 255, 255, 0.1);
+  border-right: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.ck-img-tools[hidden] {
+  display: none;
+}
+
+.ck-img-bar .ck-act.on {
+  color: #fff;
+  background: rgba(255, 59, 48, 0.28);
+}
+
+/* ---- settings ---- */
+#settings-form .set-quick-replies {
+  width: 100%;
+  min-height: 7em;
+  resize: vertical;
+  font: inherit;
+  line-height: 1.5;
+}
diff --git a/src/renderer/icons.ts b/src/renderer/icons.ts
index 0379f78..31f1c94 100644
--- a/src/renderer/icons.ts
+++ b/src/renderer/icons.ts
@@ -2,7 +2,7 @@ export type IconName =
   | 'search' | 'projects' | 'sessions' | 'tasks' | 'usage'
   | 'settings' | 'refresh' | 'more' | 'play' | 'panel-left'
   | 'folder' | 'plus' | 'restart' | 'close' | 'pin' | 'edit' | 'brain' | 'clock'
-  | 'trash' | 'chevron-left' | 'chevron-right' | 'chevron-down' | 'minimize' | 'maximize' | 'restore' | 'moon' | 'power' | 'globe' | 'machine' | 'image' | 'paperclip' | 'download' | 'copy' | 'terminal';
+  | 'trash' | 'chevron-left' | 'chevron-right' | 'chevron-down' | 'minimize' | 'maximize' | 'restore' | 'moon' | 'power' | 'globe' | 'machine' | 'image' | 'paperclip' | 'download' | 'copy' | 'terminal' | 'reply' | 'timeline' | 'pen' | 'send' | 'undo' | 'square' | 'arrow';
 
 const paths: Record<IconName, string> = {
   search: '<circle cx="11" cy="11" r="7"></circle><path d="m20 20-3.5-3.5"></path>',
@@ -43,6 +43,13 @@ const paths: Record<IconName, string> = {
   download: '<path d="M12 4v11"></path><path d="m7 10 5 5 5-5"></path><path d="M5 20h14"></path>',
   copy: '<rect x="8" y="8" width="12" height="12" rx="2"></rect><path d="M16 8V6a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v8a2 2 0 0 0 2 2h2"></path>',
   terminal: '<rect x="3" y="4" width="18" height="16" rx="2"></rect><path d="m7 9 3 3-3 3"></path><path d="M12 15h5"></path>',
+  reply: '<path d="M21 12a8 8 0 0 1-11.6 7.1L4 20l1-4.6A8 8 0 1 1 21 12Z"></path><path d="M9 11h6"></path><path d="M9 14.5h3.5"></path>',
+  timeline: '<path d="M6 4v16"></path><circle cx="6" cy="7" r="1.6"></circle><circle cx="6" cy="17" r="1.6"></circle><path d="M10 7h10"></path><path d="M10 12h7"></path><path d="M10 17h10"></path>',
+  pen: '<path d="M4 20h4L19 9a2.8 2.8 0 0 0-4-4L4 16v4Z"></path><path d="m13.5 6.5 4 4"></path>',
+  send: '<path d="M21 3 10 14"></path><path d="M21 3 14.5 21l-4.5-7-7-4.5L21 3Z"></path>',
+  undo: '<path d="M9 14 4 9l5-5"></path><path d="M4 9h10.5a5.5 5.5 0 0 1 0 11H11"></path>',
+  square: '<rect x="4" y="4" width="16" height="16" rx="1.5"></rect>',
+  arrow: '<path d="M5 19 19 5"></path><path d="M10 5h9v9"></path>',
 };
 
 export function iconMarkup(name: IconName): string {
diff --git a/src/renderer/imageMarkup.ts b/src/renderer/imageMarkup.ts
new file mode 100644
index 0000000..e12bb3c
--- /dev/null
+++ b/src/renderer/imageMarkup.ts
@@ -0,0 +1,148 @@
+// src/renderer/imageMarkup.ts
+// Boxes, arrows and freehand marks drawn over an image in the viewer — "this button, here" — so the
+// marked-up picture can go straight back to the session instead of round-tripping through an editor.
+//
+// Marks are kept in the image's own pixels, so they land where they were drawn whatever size the
+// viewer shows the image at, and the picture that is sent is the full-resolution original with them.
+export type MarkTool = 'box' | 'arrow' | 'pen';
+
+interface Pt { x: number; y: number }
+interface Mark { tool: MarkTool; pts: Pt[] }
+
+const COLOR = '#ff3b30';
+/** A drag shorter than this (image pixels) was a click, not a mark. */
+const MIN_DRAG = 4;
+
+export class ImageMarkup {
+  readonly canvas = document.createElement('canvas');
+  tool: MarkTool = 'box';
+  private marks: Mark[] = [];
+  private drawing: Mark | null = null;
+  private enabled = false;
+  private readonly resize = new ResizeObserver(() => this.redraw());
+
+  /** `img` is the shown image; the canvas covers `stage`, which contains it. */
+  constructor(private readonly img: HTMLImageElement, private readonly stage: HTMLElement, private readonly changed: () => void) {
+    this.canvas.className = 'ck-img-markup';
+    stage.appendChild(this.canvas);
+    this.resize.observe(stage);
+    this.canvas.addEventListener('pointerdown', (e) => this.down(e));
+    this.canvas.addEventListener('pointermove', (e) => this.move(e));
+    this.canvas.addEventListener('pointerup', (e) => this.up(e));
+    this.canvas.addEventListener('pointercancel', () => { this.drawing = null; this.redraw(); });
+  }
+
+  get count(): number { return this.marks.length; }
+  get active(): boolean { return this.enabled; }
+
+  setEnabled(on: boolean): void {
+    this.enabled = on;
+    this.canvas.classList.toggle('on', on);
+    this.redraw();
+  }
+
+  undo(): void { this.marks.pop(); this.redraw(); this.changed(); }
+  clear(): void { this.marks = []; this.drawing = null; this.redraw(); this.changed(); }
+  dispose(): void { this.resize.disconnect(); this.canvas.remove(); }
+
+  /** The image with the marks on it, at the image's own resolution. Null before the image has loaded. */
+  composite(): HTMLCanvasElement | null {
+    const w = this.img.naturalWidth, h = this.img.naturalHeight;
+    if (!w || !h) return null;
+    const c = document.createElement('canvas'); c.width = w; c.height = h;
+    const ctx = c.getContext('2d'); if (!ctx) return null;
+    ctx.drawImage(this.img, 0, 0);
+    for (const m of this.marks) paint(ctx, m, strokeFor(w, h), (p) => p);
+    return c;
+  }
+
+  /** Where the image is drawn inside the stage, in CSS pixels; null while it has no size. */
+  private shown(): { left: number; top: number; width: number; height: number } | null {
+    const s = this.stage.getBoundingClientRect(), r = this.img.getBoundingClientRect();
+    if (!r.width || !r.height || !this.img.naturalWidth) return null;
+    return { left: r.left - s.left, top: r.top - s.top, width: r.width, height: r.height };
+  }
+
+  private toImage(e: PointerEvent): Pt | null {
+    const at = this.shown(); if (!at) return null;
+    const s = this.stage.getBoundingClientRect();
+    const x = (e.clientX - s.left - at.left) / at.width * this.img.naturalWidth;
+    const y = (e.clientY - s.top - at.top) / at.height * this.img.naturalHeight;
+    return { x: clamp(x, 0, this.img.naturalWidth), y: clamp(y, 0, this.img.naturalHeight) };
+  }
+
+  private down(e: PointerEvent): void {
+    if (!this.enabled || e.button !== 0) return;
+    const p = this.toImage(e); if (!p) return;
+    e.preventDefault(); e.stopPropagation();
+    this.canvas.setPointerCapture(e.pointerId);
+    this.drawing = { tool: this.tool, pts: [p, p] };
+  }
+
+  private move(e: PointerEvent): void {
+    if (!this.drawing) return;
+    const p = this.toImage(e); if (!p) return;
+    if (this.drawing.tool === 'pen') this.drawing.pts.push(p);
+    else this.drawing.pts[1] = p;
+    this.redraw();
+  }
+
+  private up(e: PointerEvent): void {
+    const m = this.drawing; this.drawing = null;
+    if (!m) return;
+    e.stopPropagation();
+    const a = m.pts[0], b = m.pts[m.pts.length - 1];
+    const span = m.tool === 'pen' ? m.pts.length : Math.hypot(b.x - a.x, b.y - a.y);
+    if (span >= MIN_DRAG) { this.marks.push(m); this.changed(); }
+    this.redraw();
+  }
+
+  redraw(): void {
+    const s = this.stage.getBoundingClientRect();
+    const dpr = window.devicePixelRatio || 1;
+    const w = Math.round(s.width * dpr), h = Math.round(s.height * dpr);
+    if (this.canvas.width !== w || this.canvas.height !== h) { this.canvas.width = w; this.canvas.height = h; }
+    const ctx = this.canvas.getContext('2d'); if (!ctx) return;
+    ctx.setTransform(1, 0, 0, 1, 0, 0);
+    ctx.clearRect(0, 0, w, h);
+    const at = this.shown(); if (!at) return;
+    const sx = at.width / this.img.naturalWidth, sy = at.height / this.img.naturalHeight;
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    const map = (p: Pt): Pt => ({ x: at.left + p.x * sx, y: at.top + p.y * sy });
+    // Drawn as thick on screen as it will be in the sent image, relative to the picture.
+    const width = strokeFor(this.img.naturalWidth, this.img.naturalHeight) * sx;
+    for (const m of this.marks) paint(ctx, m, width, map);
+    if (this.drawing) paint(ctx, this.drawing, width, map);
+  }
+}
+
+function clamp(v: number, lo: number, hi: number): number { return Math.min(hi, Math.max(lo, v)); }
+
+/** A line that reads at a glance on a 4K screenshot and does not swamp a small one. */
+function strokeFor(w: number, h: number): number { return Math.max(3, Math.round(Math.max(w, h) / 320)); }
+
+function paint(ctx: CanvasRenderingContext2D, m: Mark, width: number, map: (p: Pt) => Pt): void {
+  ctx.save();
+  ctx.strokeStyle = COLOR; ctx.lineWidth = width; ctx.lineCap = 'round'; ctx.lineJoin = 'round';
+  // A dark halo keeps red legible on red or busy backgrounds.
+  ctx.shadowColor = 'rgba(0, 0, 0, 0.55)'; ctx.shadowBlur = width * 1.5;
+  const pts = m.pts.map(map);
+  const a = pts[0], b = pts[pts.length - 1];
+  ctx.beginPath();
+  if (m.tool === 'box') {
+    ctx.rect(Math.min(a.x, b.x), Math.min(a.y, b.y), Math.abs(b.x - a.x), Math.abs(b.y - a.y));
+  } else if (m.tool === 'arrow') {
+    ctx.moveTo(a.x, a.y); ctx.lineTo(b.x, b.y);
+    const angle = Math.atan2(b.y - a.y, b.x - a.x);
+    const head = width * 4 + 6;
+    for (const side of [-1, 1]) {
+      ctx.moveTo(b.x, b.y);
+      ctx.lineTo(b.x - head * Math.cos(angle + side * 0.5), b.y - head * Math.sin(angle + side * 0.5));
+    }
+  } else {
+    ctx.moveTo(a.x, a.y);
+    for (const p of pts.slice(1)) ctx.lineTo(p.x, p.y);
+  }
+  ctx.stroke();
+  ctx.restore();
+}
diff --git a/src/renderer/imageStrip.ts b/src/renderer/imageStrip.ts
index 40ea8ee..b4124ba 100644
--- a/src/renderer/imageStrip.ts
+++ b/src/renderer/imageStrip.ts
@@ -9,6 +9,8 @@ import type { ViewImage } from '../main/imageView';
 import { tr } from './i18n-runtime';
 import { createIcon } from './icons';
 import { toast } from './loadError';
+import { fitPngBase64 } from './attachments';
+import { ImageMarkup, type MarkTool } from './imageMarkup';
 
 /** Everything the strip needs to know about one session — where its images come from. */
 export interface ImageSource {
@@ -22,6 +24,8 @@ export interface ImageSource {
   canReveal?(id: string): boolean;
   /** Scroll the session's terminal to the row this image was shown on. */
   reveal?(id: string): void;
+  /** Give a picture (base64 PNG) to the session, as a pasted image; false when it did not arrive. */
+  attach?(pngBase64: string): Promise<boolean>;
 }
 
 const THUMB_CACHE_LIMIT = 240;
@@ -269,7 +273,8 @@ function openViewer(src: ImageSource, list: SessionImageRef[], startIndex: numbe
   const openBtn = mk('folder', tr('cockpit.image_open_file'), () => { const r = list[index]; if (r.path && src.openFile) src.openFile(r.path); });
   const copy = mk('copy', tr('cockpit.image_copy'), () => {
     if (!img.src) return;
-    void toPngDataUrl(img).then((url) => window.devdeck.clipboard.writeImage(url))
+    const marked = markup.count > 0 ? markup.composite() : null;
+    void (marked ? Promise.resolve(marked.toDataURL('image/png')) : toPngDataUrl(img)).then((url) => window.devdeck.clipboard.writeImage(url))
       .then((ok) => toast(tr(ok ? 'cockpit.image_copied' : 'cockpit.image_copy_failed')))
       .catch(() => toast(tr('cockpit.image_copy_failed')));
   });
@@ -280,8 +285,48 @@ function openViewer(src: ImageSource, list: SessionImageRef[], startIndex: numbe
     done();
     src.reveal?.(id);
   });
+  // Mark it up, then hand it back: "this, here" as a picture rather than a paragraph.
+  const markup = new ImageMarkup(img, stage, () => syncMarkup());
+  const tools = document.createElement('div'); tools.className = 'ck-img-tools'; tools.setAttribute('role', 'toolbar');
+  tools.setAttribute('aria-label', tr('cockpit.image_markup'));
+  const toolBtns = new Map<MarkTool, HTMLButtonElement>();
+  for (const [tool, icon, key] of [['box', 'square', 'cockpit.markup_box'], ['arrow', 'arrow', 'cockpit.markup_arrow'], ['pen', 'pen', 'cockpit.markup_pen']] as const) {
+    const b = mk(icon, tr(key), () => { markup.tool = tool; syncMarkup(); });
+    toolBtns.set(tool, b); tools.appendChild(b);
+  }
+  const undo = mk('undo', tr('cockpit.markup_undo'), () => markup.undo());
+  const clear = mk('trash', tr('cockpit.markup_clear'), () => markup.clear());
+  tools.append(undo, clear);
+  const markBtn = mk('pen', tr('cockpit.image_markup'), () => { markup.setEnabled(!markup.active); syncMarkup(); });
+  let sending = false;
+  const send = mk('send', tr('cockpit.image_attach'), () => {
+    if (!img.src || sending || !src.attach) return;
+    sending = true; syncMarkup();
+    const marked = markup.count > 0 ? markup.composite() : null;
+    void (async () => {
+      let ok = false;
+      try {
+        await img.decode().catch(() => undefined);
+        const png = marked ? await fitPngBase64(marked, marked.width, marked.height) : await fitPngBase64(img, img.naturalWidth, img.naturalHeight);
+        ok = !!png && await src.attach!(png);
+      } catch { ok = false; }
+      sending = false;
+      if (ok) { toast(tr(marked ? 'cockpit.image_attached_marked' : 'cockpit.image_attached')); done(false); }
+      else { toast(tr('cockpit.image_attach_failed')); syncMarkup(); }
+    })();
+  });
+  const syncMarkup = (): void => {
+    tools.hidden = !markup.active;
+    markBtn.classList.toggle('on', markup.active); markBtn.setAttribute('aria-pressed', String(markup.active));
+    for (const [tool, b] of toolBtns) { b.classList.toggle('on', markup.tool === tool); b.setAttribute('aria-pressed', String(markup.tool === tool)); }
+    undo.disabled = clear.disabled = markup.count === 0;
+    send.hidden = !src.attach; send.disabled = sending;
+    send.title = tr(markup.count > 0 ? 'cockpit.image_attach_marked' : 'cockpit.image_attach');
+    send.setAttribute('aria-label', send.title);
+    prev.disabled = markup.active || index >= list.length - 1; next.disabled = markup.active || index <= 0;
+  };
   const close = mk('close', tr('cockpit.close'), () => done());
-  bar.append(prev, counter, next, caption, reveal, copy, save, openBtn, close);
+  bar.append(prev, counter, next, caption, tools, markBtn, send, reveal, copy, save, openBtn, close);
   overlay.append(stage, bar);
 
   let seq = 0;
@@ -299,6 +344,7 @@ function openViewer(src: ImageSource, list: SessionImageRef[], startIndex: numbe
     reveal.title = tr(locatable ? 'cockpit.image_reveal' : 'cockpit.image_reveal_gone');
     reveal.setAttribute('aria-label', reveal.title);
     prev.disabled = index >= list.length - 1; next.disabled = index <= 0; // prev = newer, next = older
+    syncMarkup();
     status.textContent = tr('cockpit.image_loading'); img.removeAttribute('src');
     void src.get(ref.id, 'full').then((v) => {
       if (my !== seq) return;
@@ -310,17 +356,27 @@ function openViewer(src: ImageSource, list: SessionImageRef[], startIndex: numbe
   /** +1 = one newer, -1 = one older. */
   const step = (d: number): void => {
     const to = index + d;
-    if (to < 0 || to >= list.length) return;
+    if (to < 0 || to >= list.length || markup.active) return;
+    markup.clear(); // marks belong to the picture they were drawn on
     index = to; show();
   };
   const onKey = (e: KeyboardEvent): void => {
+    if (markup.active) {
+      if (e.key === 'Escape') { e.preventDefault(); markup.setEnabled(false); syncMarkup(); return; }
+      if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === 'z') { e.preventDefault(); markup.undo(); return; }
+      if (e.key === 'ArrowLeft' || e.key === 'ArrowRight') return;
+    }
     if (e.key === 'Escape') { e.preventDefault(); done(); }
     else if (e.key === 'ArrowLeft') { e.preventDefault(); step(1); }
     else if (e.key === 'ArrowRight') { e.preventDefault(); step(-1); }
   };
   const restoreFocus = document.activeElement as HTMLElement | null;
-  const done = (): void => { document.removeEventListener('keydown', onKey, true); overlay.remove(); restoreFocus?.focus?.(); };
-  overlay.addEventListener('click', (e) => { if (e.target === overlay || e.target === stage) done(); });
+  /** `refocus` = false when the session's terminal has just been given the focus instead. */
+  const done = (refocus = true): void => {
+    document.removeEventListener('keydown', onKey, true); markup.dispose(); overlay.remove();
+    if (refocus) restoreFocus?.focus?.();
+  };
+  overlay.addEventListener('click', (e) => { if (!markup.active && (e.target === overlay || e.target === stage || e.target === markup.canvas)) done(); });
   document.addEventListener('keydown', onKey, true);
   document.body.appendChild(overlay);
   close.focus();
diff --git a/src/renderer/locales/en.json b/src/renderer/locales/en.json
index 7efb9b9..feb315b 100644
--- a/src/renderer/locales/en.json
+++ b/src/renderer/locales/en.json
@@ -469,9 +469,8 @@
   "cockpit.remote_file_unavailable": "That file is on {machine}, not on this computer.",
   "cockpit.redrawn": "Redrew {count} terminal(s) from their sessions.",
   "cockpit.attach": "Attach files",
-  "cockpit.attach_remote": "Attach images (sent to the machine running this session)",
+  "cockpit.attach_remote": "Attach images or documents (sent to the machine running this session)",
   "cockpit.attached": "📎 Attached {count}",
-  "cockpit.attach_images_only": "{count} skipped — only images can be sent to {machine}",
   "cockpit.images_show": "Show images from this session",
   "cockpit.images_hide": "Hide images",
   "cockpit.image_unavailable": "Image not available",
@@ -534,5 +533,35 @@
   "cockpit.rename_failed": "The rename could not be confirmed. Your text is kept. Check the connection or permission, then retry.",
   "cockpit.rename_hint": "Enter to save · Escape to cancel",
   "cockpit.rename_save": "Save title",
-  "cockpit.rename_cancel": "Cancel"
+  "cockpit.rename_cancel": "Cancel",
+  "cockpit.attach_kinds_only": "{count} skipped — only images and text, data, log or PDF files can be sent to {machine}",
+  "cockpit.attach_host_too_old": "{count} skipped — DevDeck on {machine} is too old to receive documents (update it to 1.41.0)",
+  "cockpit.quick_replies": "Quick replies",
+  "cockpit.quick_replies_hint": "Edit these in Settings → Quick replies",
+  "cockpit.quick_reply_none": "No quick reply {n} — add one in Settings",
+  "cockpit.quick_default_1": "Yes, go ahead",
+  "cockpit.quick_default_2": "Commit it",
+  "cockpit.quick_default_3": "Run the tests and check the result",
+  "cockpit.quick_default_4": "Summarize what you changed",
+  "cockpit.timeline": "Timeline",
+  "cockpit.timeline_count": "Timeline · {count} prompts",
+  "cockpit.timeline_show": "Show timeline",
+  "cockpit.timeline_hide": "Hide timeline",
+  "cockpit.timeline_empty": "No prompts in this session yet.",
+  "cockpit.timeline_image_only": "(image)",
+  "cockpit.timeline_gone": "This prompt is no longer in the terminal's scrollback.",
+  "cockpit.timeline_images": "{count} images from this turn — open",
+  "cockpit.image_markup": "Mark up",
+  "cockpit.markup_box": "Box",
+  "cockpit.markup_arrow": "Arrow",
+  "cockpit.markup_pen": "Pen",
+  "cockpit.markup_undo": "Undo (Ctrl+Z)",
+  "cockpit.markup_clear": "Clear marks",
+  "cockpit.image_attach": "Attach to the session",
+  "cockpit.image_attach_marked": "Attach the marked-up image to the session",
+  "cockpit.image_attached": "Image attached to the session",
+  "cockpit.image_attached_marked": "Marked-up image attached to the session",
+  "cockpit.image_attach_failed": "Could not attach the image — nothing was typed into the session.",
+  "set.quick_replies": "Quick replies",
+  "set.quick_replies_hint": "One per line, up to 9. Sent with the 💬 button in a session's header, or Ctrl+Shift+1…9 in its terminal. Leave empty for the defaults."
 }
diff --git a/src/renderer/locales/ja.json b/src/renderer/locales/ja.json
index a37632c..ba093e1 100644
--- a/src/renderer/locales/ja.json
+++ b/src/renderer/locales/ja.json
@@ -469,9 +469,8 @@
   "cockpit.remote_file_unavailable": "そのファイルはこの PC ではなく {machine} にあります。",
   "cockpit.redrawn": "ターミナル {count} 個をセッションから描き直しました。",
   "cockpit.attach": "ファイルを添付",
-  "cockpit.attach_remote": "画像を添付（このセッションを実行中のマシンへ送信）",
+  "cockpit.attach_remote": "画像・ドキュメントを添付 (このセッションを実行中のマシンへ送信)",
   "cockpit.attached": "📎 {count} 件を添付",
-  "cockpit.attach_images_only": "{count} 件をスキップ — {machine} には画像のみ送信できます",
   "cockpit.images_show": "このセッションの画像を表示",
   "cockpit.images_hide": "画像を隠す",
   "cockpit.image_unavailable": "画像を読み込めません",
@@ -534,5 +533,35 @@
   "cockpit.rename_failed": "名前の変更を確認できませんでした。入力は保持されています。接続や権限を確認して再試行してください。",
   "cockpit.rename_hint": "Enterで保存 · Escapeでキャンセル",
   "cockpit.rename_save": "名前を保存",
-  "cockpit.rename_cancel": "キャンセル"
+  "cockpit.rename_cancel": "キャンセル",
+  "cockpit.attach_kinds_only": "{count} 件をスキップ — {machine} には画像とテキスト・データ・ログ・PDF ファイルのみ送信できます",
+  "cockpit.attach_host_too_old": "{count} 件をスキップ — {machine} の DevDeck はドキュメントを受け取れないバージョンです (1.41.0 に更新してください)",
+  "cockpit.quick_replies": "クイック返信",
+  "cockpit.quick_replies_hint": "設定 → クイック返信 で変更できます",
+  "cockpit.quick_reply_none": "クイック返信 {n} がありません — 設定で追加してください",
+  "cockpit.quick_default_1": "はい、続けてください",
+  "cockpit.quick_default_2": "コミットしてください",
+  "cockpit.quick_default_3": "テストを実行して結果を確認してください",
+  "cockpit.quick_default_4": "変更内容を要約してください",
+  "cockpit.timeline": "タイムライン",
+  "cockpit.timeline_count": "タイムライン · プロンプト {count} 件",
+  "cockpit.timeline_show": "タイムラインを表示",
+  "cockpit.timeline_hide": "タイムラインを隠す",
+  "cockpit.timeline_empty": "このセッションで送ったプロンプトはまだありません。",
+  "cockpit.timeline_image_only": "(画像)",
+  "cockpit.timeline_gone": "このプロンプトはターミナルのスクロールバックから消えています。",
+  "cockpit.timeline_images": "このターンの画像 {count} 件 — 開く",
+  "cockpit.image_markup": "マークアップ",
+  "cockpit.markup_box": "四角",
+  "cockpit.markup_arrow": "矢印",
+  "cockpit.markup_pen": "ペン",
+  "cockpit.markup_undo": "元に戻す (Ctrl+Z)",
+  "cockpit.markup_clear": "マークをすべて消去",
+  "cockpit.image_attach": "セッションに添付",
+  "cockpit.image_attach_marked": "マークした画像をセッションに添付",
+  "cockpit.image_attached": "画像をセッションに添付しました",
+  "cockpit.image_attached_marked": "マークした画像をセッションに添付しました",
+  "cockpit.image_attach_failed": "画像を添付できませんでした — セッションには何も入力していません。",
+  "set.quick_replies": "クイック返信",
+  "set.quick_replies_hint": "1 行に 1 つ、最大 9 個。セッション上部の 💬 ボタン、またはターミナルで Ctrl+Shift+1…9 で送信します。空欄なら既定の文言を使います。"
 }
diff --git a/src/renderer/locales/ko.json b/src/renderer/locales/ko.json
index 0580fa1..974ea3c 100644
--- a/src/renderer/locales/ko.json
+++ b/src/renderer/locales/ko.json
@@ -469,9 +469,8 @@
   "cockpit.remote_file_unavailable": "그 파일은 이 컴퓨터가 아니라 {machine}에 있습니다.",
   "cockpit.redrawn": "터미널 {count}개를 세션에서 다시 그렸습니다.",
   "cockpit.attach": "파일 첨부",
-  "cockpit.attach_remote": "이미지 첨부 (이 세션을 실행 중인 기기로 전송)",
+  "cockpit.attach_remote": "이미지·문서 첨부 (이 세션을 실행 중인 기기로 전송)",
   "cockpit.attached": "📎 {count}개 첨부함",
-  "cockpit.attach_images_only": "{count}개 건너뜀 — {machine}에는 이미지만 보낼 수 있습니다",
   "cockpit.images_show": "이 세션의 이미지 보기",
   "cockpit.images_hide": "이미지 숨기기",
   "cockpit.image_unavailable": "이미지를 불러올 수 없음",
@@ -534,5 +533,35 @@
   "cockpit.rename_failed": "제목 변경을 확인하지 못했습니다. 입력은 보존됩니다. 연결이나 권한을 확인한 뒤 다시 시도하세요.",
   "cockpit.rename_hint": "Enter로 저장 · Escape로 취소",
   "cockpit.rename_save": "제목 저장",
-  "cockpit.rename_cancel": "취소"
+  "cockpit.rename_cancel": "취소",
+  "cockpit.attach_kinds_only": "{count}개 건너뜀 — {machine}에는 이미지와 텍스트·데이터·로그·PDF 파일만 보낼 수 있습니다",
+  "cockpit.attach_host_too_old": "{count}개 건너뜀 — {machine}의 DevDeck이 문서를 받을 수 없는 버전입니다 (1.41.0으로 업데이트하세요)",
+  "cockpit.quick_replies": "빠른 답장",
+  "cockpit.quick_replies_hint": "설정 → 빠른 답장에서 바꿀 수 있습니다",
+  "cockpit.quick_reply_none": "빠른 답장 {n}번이 없습니다 — 설정에서 추가하세요",
+  "cockpit.quick_default_1": "네 계속 진행해줘",
+  "cockpit.quick_default_2": "커밋해줘",
+  "cockpit.quick_default_3": "테스트 돌려서 결과 확인해줘",
+  "cockpit.quick_default_4": "변경한 내용 요약해줘",
+  "cockpit.timeline": "타임라인",
+  "cockpit.timeline_count": "타임라인 · 프롬프트 {count}개",
+  "cockpit.timeline_show": "타임라인 보기",
+  "cockpit.timeline_hide": "타임라인 숨기기",
+  "cockpit.timeline_empty": "이 세션에서 보낸 프롬프트가 아직 없습니다.",
+  "cockpit.timeline_image_only": "(이미지)",
+  "cockpit.timeline_gone": "이 프롬프트는 터미널 스크롤 기록에서 이미 밀려났습니다.",
+  "cockpit.timeline_images": "이 턴의 이미지 {count}개 — 열기",
+  "cockpit.image_markup": "표시하기",
+  "cockpit.markup_box": "박스",
+  "cockpit.markup_arrow": "화살표",
+  "cockpit.markup_pen": "펜",
+  "cockpit.markup_undo": "되돌리기 (Ctrl+Z)",
+  "cockpit.markup_clear": "표시 모두 지우기",
+  "cockpit.image_attach": "세션에 첨부",
+  "cockpit.image_attach_marked": "표시한 이미지를 세션에 첨부",
+  "cockpit.image_attached": "이미지를 세션에 첨부했습니다",
+  "cockpit.image_attached_marked": "표시한 이미지를 세션에 첨부했습니다",
+  "cockpit.image_attach_failed": "이미지를 첨부하지 못했습니다 — 세션에는 아무것도 입력하지 않았습니다.",
+  "set.quick_replies": "빠른 답장",
+  "set.quick_replies_hint": "한 줄에 하나씩, 최대 9개. 세션 상단의 💬 버튼이나 터미널에서 Ctrl+Shift+1…9로 보냅니다. 비워 두면 기본 문구를 씁니다."
 }
diff --git a/src/renderer/locales/zh.json b/src/renderer/locales/zh.json
index c6a034e..b894191 100644
--- a/src/renderer/locales/zh.json
+++ b/src/renderer/locales/zh.json
@@ -469,9 +469,8 @@
   "cockpit.remote_file_unavailable": "该文件位于 {machine}，而不是这台电脑上。",
   "cockpit.redrawn": "已从会话重绘 {count} 个终端。",
   "cockpit.attach": "附加文件",
-  "cockpit.attach_remote": "附加图片（发送到运行此会话的设备）",
+  "cockpit.attach_remote": "附加图片或文档 (发送到运行此会话的设备)",
   "cockpit.attached": "📎 已附加 {count} 个",
-  "cockpit.attach_images_only": "跳过 {count} 个 — 只能向 {machine} 发送图片",
   "cockpit.images_show": "显示此会话的图片",
   "cockpit.images_hide": "隐藏图片",
   "cockpit.image_unavailable": "无法加载图片",
@@ -534,5 +533,35 @@
   "cockpit.rename_failed": "无法确认名称更改。输入已保留。请检查连接或权限后重试。",
   "cockpit.rename_hint": "Enter保存 · Escape取消",
   "cockpit.rename_save": "保存名称",
-  "cockpit.rename_cancel": "取消"
+  "cockpit.rename_cancel": "取消",
+  "cockpit.attach_kinds_only": "跳过 {count} 个 — 只能向 {machine} 发送图片以及文本、数据、日志或 PDF 文件",
+  "cockpit.attach_host_too_old": "跳过 {count} 个 — {machine} 上的 DevDeck 版本过旧，无法接收文档 (请更新到 1.41.0)",
+  "cockpit.quick_replies": "快捷回复",
+  "cockpit.quick_replies_hint": "可在 设置 → 快捷回复 中修改",
+  "cockpit.quick_reply_none": "没有第 {n} 条快捷回复 — 请在设置中添加",
+  "cockpit.quick_default_1": "好的，继续",
+  "cockpit.quick_default_2": "提交一下",
+  "cockpit.quick_default_3": "运行测试并检查结果",
+  "cockpit.quick_default_4": "总结一下你的改动",
+  "cockpit.timeline": "时间线",
+  "cockpit.timeline_count": "时间线 · {count} 条提示",
+  "cockpit.timeline_show": "显示时间线",
+  "cockpit.timeline_hide": "隐藏时间线",
+  "cockpit.timeline_empty": "此会话还没有发送过提示。",
+  "cockpit.timeline_image_only": "(图片)",
+  "cockpit.timeline_gone": "这条提示已不在终端的回滚记录中。",
+  "cockpit.timeline_images": "本轮的 {count} 张图片 — 打开",
+  "cockpit.image_markup": "标注",
+  "cockpit.markup_box": "方框",
+  "cockpit.markup_arrow": "箭头",
+  "cockpit.markup_pen": "画笔",
+  "cockpit.markup_undo": "撤销 (Ctrl+Z)",
+  "cockpit.markup_clear": "清除所有标注",
+  "cockpit.image_attach": "附加到会话",
+  "cockpit.image_attach_marked": "将标注后的图片附加到会话",
+  "cockpit.image_attached": "已将图片附加到会话",
+  "cockpit.image_attached_marked": "已将标注后的图片附加到会话",
+  "cockpit.image_attach_failed": "无法附加图片 — 没有向会话输入任何内容。",
+  "set.quick_replies": "快捷回复",
+  "set.quick_replies_hint": "每行一条，最多 9 条。用会话顶部的 💬 按钮或在终端中按 Ctrl+Shift+1…9 发送。留空则使用默认文案。"
 }
diff --git a/src/renderer/main.ts b/src/renderer/main.ts
index 2883487..e9ee52d 100644
--- a/src/renderer/main.ts
+++ b/src/renderer/main.ts
@@ -7,7 +7,7 @@ import type { ShellSessionInput } from '../shared/shellNavigation';
 import { mountUsage, showUsage } from './usageView';
 import { mountSettings, showSettings } from './settingsView';
 import { mountNext, showNext } from './nextView';
-import { activateCockpitSession, closeCockpitSessionGroup, closeCockpitSessions, cockpitNavigationAliases, cockpitNavigationItems, manageCockpitSessionAction, mountCockpit, onCockpitNavigationChange, onCockpitSessionsLoaded, onCockpitSessionSelected, restoreAllCockpitSessions, setCockpitNavigationCallback, showCockpit, liveSessionCount, runningSessionsForAutoRestore, refreshLiveSessionIds, setCockpitContextWindow, setCockpitTrayAlert, setCockpitSidebarCollapsed, refreshCockpitSidebar, setCockpitSessionSummary, setCockpitAiSummary } from './cockpitView';
+import { activateCockpitSession, closeCockpitSessionGroup, closeCockpitSessions, cockpitNavigationAliases, cockpitNavigationItems, manageCockpitSessionAction, mountCockpit, onCockpitNavigationChange, onCockpitSessionsLoaded, onCockpitSessionSelected, restoreAllCockpitSessions, setCockpitNavigationCallback, showCockpit, liveSessionCount, runningSessionsForAutoRestore, refreshLiveSessionIds, setCockpitContextWindow, setCockpitTrayAlert, setCockpitSidebarCollapsed, refreshCockpitSidebar, setCockpitSessionSummary, setCockpitAiSummary, setCockpitQuickReplies } from './cockpitView';
 import { isCockpitAvailable } from '../shared/cockpitModel';
 import { setLanguage, tr, currentLang, languageName, SUPPORTED } from './i18n-runtime';
 import { toast } from './loadError';
@@ -280,7 +280,7 @@ async function boot(): Promise<void> {
   mountNext();
   mountUsageBar();
   mountShutdown(settings.platform);
-  if (cockpitOn) { mountCockpit(); setCockpitContextWindow(settings.contextWindow); setCockpitTrayAlert(settings.trayAlert); setCockpitSidebarCollapsed(settings.cockpitSidebarCollapsed); setCockpitSessionSummary(settings.sessionSummary); setCockpitAiSummary(settings.aiSessionSummary); }
+  if (cockpitOn) { mountCockpit(); setCockpitContextWindow(settings.contextWindow); setCockpitTrayAlert(settings.trayAlert); setCockpitSidebarCollapsed(settings.cockpitSidebarCollapsed); setCockpitSessionSummary(settings.sessionSummary); setCockpitAiSummary(settings.aiSessionSummary); setCockpitQuickReplies(settings.quickReplies); }
   const nav = mountNav((view) => {
     if (view === 'usage') showUsage(); if (view === 'settings') showSettings(); if (view === 'next') showNext(); if (view === 'cockpit') showCockpit();
     shellController?.setActiveProject(null);
diff --git a/src/renderer/quickReplyMenu.ts b/src/renderer/quickReplyMenu.ts
new file mode 100644
index 0000000..bb19f2a
--- /dev/null
+++ b/src/renderer/quickReplyMenu.ts
@@ -0,0 +1,62 @@
+// src/renderer/quickReplyMenu.ts
+// The cockpit's quick replies: the phrases the person keeps typing, sent with one click from a menu
+// in the session header or with Ctrl+Shift+<n> in the terminal. Edited in Settings.
+import { MAX_QUICK_REPLIES } from '../shared/quickReplies';
+import { tr } from './i18n-runtime';
+
+const DEFAULT_KEYS = ['cockpit.quick_default_1', 'cockpit.quick_default_2', 'cockpit.quick_default_3', 'cockpit.quick_default_4'];
+
+let custom: string[] | null = null;
+let menu: HTMLElement | null = null;
+let closeMenu: (() => void) | null = null;
+
+/** The person's own list; null or empty means the defaults for the current language. */
+export function setQuickReplies(list: string[] | null): void { custom = list; }
+
+export function quickReplies(): string[] {
+  return (custom && custom.length ? custom : DEFAULT_KEYS.map((k) => tr(k))).slice(0, MAX_QUICK_REPLIES);
+}
+
+export function isQuickReplyMenuOpen(): boolean { return menu !== null; }
+
+/** A menu under `anchor`; picking a phrase hands it to `send`. A second call closes it. */
+export function toggleQuickReplyMenu(anchor: HTMLElement, send: (text: string) => void): void {
+  if (closeMenu) { closeMenu(); return; }
+  const list = quickReplies();
+  const el = document.createElement('div'); el.className = 'ck-qr-menu'; el.setAttribute('role', 'menu');
+  el.setAttribute('aria-label', tr('cockpit.quick_replies'));
+  const items: HTMLButtonElement[] = list.map((text, i) => {
+    const b = document.createElement('button'); b.type = 'button'; b.className = 'ck-qr-item'; b.setAttribute('role', 'menuitem');
+    const t = document.createElement('span'); t.className = 'ck-qr-text'; t.textContent = text;
+    const k = document.createElement('kbd'); k.className = 'ck-qr-key'; k.textContent = `Ctrl+Shift+${i + 1}`;
+    b.append(t, k); b.title = text;
+    b.addEventListener('click', () => { done(); send(text); });
+    return b;
+  });
+  const hint = document.createElement('div'); hint.className = 'ck-qr-hint'; hint.textContent = tr('cockpit.quick_replies_hint');
+  el.append(...items, hint);
+  const r = anchor.getBoundingClientRect();
+  el.style.top = `${Math.round(r.bottom + 4)}px`;
+  el.style.right = `${Math.max(8, Math.round(window.innerWidth - r.right))}px`;
+  const onKey = (e: KeyboardEvent): void => {
+    if (e.key === 'Escape') { e.preventDefault(); e.stopPropagation(); done(); anchor.focus(); return; }
+    if (e.key !== 'ArrowDown' && e.key !== 'ArrowUp') return;
+    e.preventDefault();
+    const at = items.indexOf(document.activeElement as HTMLButtonElement);
+    const to = e.key === 'ArrowDown' ? (at + 1) % items.length : (at - 1 + items.length) % items.length;
+    items[to]?.focus();
+  };
+  const onDown = (e: PointerEvent): void => { if (!el.contains(e.target as Node) && e.target !== anchor && !anchor.contains(e.target as Node)) done(); };
+  const done = (): void => {
+    document.removeEventListener('keydown', onKey, true);
+    document.removeEventListener('pointerdown', onDown, true);
+    el.remove(); menu = null; closeMenu = null;
+    anchor.setAttribute('aria-expanded', 'false');
+  };
+  document.addEventListener('keydown', onKey, true);
+  document.addEventListener('pointerdown', onDown, true);
+  document.body.appendChild(el);
+  menu = el; closeMenu = done;
+  anchor.setAttribute('aria-expanded', 'true');
+  items[0]?.focus();
+}
diff --git a/src/renderer/settingsSave.ts b/src/renderer/settingsSave.ts
index ba7d147..7af182a 100644
--- a/src/renderer/settingsSave.ts
+++ b/src/renderer/settingsSave.ts
@@ -1,7 +1,7 @@
 import { tr } from './i18n-runtime';
 import { reportSaveError } from './loadError';
 
-type Control = HTMLInputElement | HTMLSelectElement;
+type Control = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
 interface Setting<T> {
   read(): T;
   restore(value: T): void;
diff --git a/src/renderer/settingsView.ts b/src/renderer/settingsView.ts
index 4964841..d2a058d 100644
--- a/src/renderer/settingsView.ts
+++ b/src/renderer/settingsView.ts
@@ -1,5 +1,7 @@
 import { tr, SUPPORTED, languageName, setLanguage as setRuntimeLang } from './i18n-runtime';
-import { setCockpitContextWindow, setCockpitTrayAlert, setCockpitSessionSummary, setCockpitAiSummary } from './cockpitView';
+import { setCockpitContextWindow, setCockpitTrayAlert, setCockpitSessionSummary, setCockpitAiSummary, setCockpitQuickReplies } from './cockpitView';
+import { quickReplies } from './quickReplyMenu';
+import { parseQuickReplyText } from '../shared/quickReplies';
 import type { Folder } from '../shared/types';
 import { IDLE_HOLD_CHOICES } from '../shared/shutdownIdle';
 import { basename, parentLabel } from '../shared/paths';
@@ -153,6 +155,22 @@ async function render(): Promise<void> {
       await renderHistory(); content.appendChild(field('shutdown.history', hist));
     }
 
+    if (s.ptyAvailable) {
+      // One phrase per line, saved when the field loses focus. Empty means the language's defaults.
+      const ta = document.createElement('textarea'); ta.className = 'set-input set-quick-replies'; ta.rows = 5;
+      ta.value = (s.quickReplies?.length ? s.quickReplies : quickReplies()).join('\n'); ta.placeholder = tr('cockpit.quick_default_1');
+      bindSetting([ta], {
+        read: () => parseQuickReplyText(ta.value),
+        restore: (v) => { ta.value = v.join('\n'); },
+        write: (v) => window.devdeck.setQuickReplies(v),
+        apply: (v) => { setCockpitQuickReplies(v); if (!v.length) ta.value = quickReplies().join('\n'); },
+      });
+      const qrWrap = document.createElement('div');
+      const qrHint = document.createElement('p'); qrHint.className = 'set-hint'; qrHint.textContent = tr('set.quick_replies_hint');
+      qrWrap.append(ta, qrHint);
+      content.appendChild(field('set.quick_replies', qrWrap, ta));
+    }
+
     const linkSection = await withTimeout(renderLinkSettings(() => { void render(); }), 15_000, 'link settings');
     if (linkSection) content.appendChild(field('link.section', linkSection));
     const about = document.createElement('div'); about.className = 'about';
diff --git a/src/renderer/termMarks.ts b/src/renderer/termMarks.ts
index c4064da..1643f33 100644
--- a/src/renderer/termMarks.ts
+++ b/src/renderer/termMarks.ts
@@ -9,6 +9,7 @@
 import type { IDecoration, IMarker, Terminal } from '@xterm/xterm';
 import type { SessionImageRef } from '../shared/sessionImages';
 import { findImagePlaceholders, findPromptRows, nextPromptRow, pairPlaceholders, type PromptRowInput } from '../shared/terminalMarks';
+import type { PromptRow } from '../shared/timeline';
 
 const MARK_BG = '#1f3352';
 const MARK_FG = '#a8cdff';
@@ -99,9 +100,8 @@ export function flashRow(term: Terminal, row: number): void {
  * Scroll to the previous (-1) or next (+1) prompt the person sent, from the top of the viewport.
  * Past the last one is the bottom. Returns false when the screen holds no prompt to go to.
  */
-export function jumpToPrompt(term: Terminal, dir: -1 | 1): boolean {
+function readPromptInputs(term: Terminal): PromptRowInput[] {
   const buf = term.buffer.active;
-  if (buf.type !== 'normal') return false;
   const rows: PromptRowInput[] = new Array(buf.length);
   for (let i = 0; i < buf.length; i++) {
     const line = buf.getLine(i);
@@ -111,7 +111,26 @@ export function jumpToPrompt(term: Terminal, dir: -1 | 1): boolean {
     const cell = at >= 0 ? line?.getCell(at) : undefined;
     rows[i] = { text, shaded: !!cell && !cell.isBgDefault() };
   }
-  const prompts = findPromptRows(rows);
+  return rows;
+}
+
+/** The person's earlier prompts on screen, with their text, top to bottom. */
+export function promptRows(term: Terminal): PromptRow[] {
+  if (term.buffer.active.type !== 'normal') return [];
+  const rows = readPromptInputs(term);
+  return findPromptRows(rows).map((row) => ({ row, text: rows[row].text }));
+}
+
+/** Scroll so `row` is at the top of the viewport, and highlight it for a moment. */
+export function revealRow(term: Terminal, row: number): void {
+  term.scrollToLine(Math.max(0, row));
+  flashRow(term, row);
+}
+
+export function jumpToPrompt(term: Terminal, dir: -1 | 1): boolean {
+  const buf = term.buffer.active;
+  if (buf.type !== 'normal') return false;
+  const prompts = findPromptRows(readPromptInputs(term));
   if (prompts.length === 0) return false;
   // At the bottom, the newest prompt may be on screen already — going back starts from it, not above it.
   const from = dir < 0 && buf.viewportY >= buf.baseY ? buf.length : buf.viewportY;
diff --git a/src/renderer/timeline.ts b/src/renderer/timeline.ts
new file mode 100644
index 0000000..01e1818
--- /dev/null
+++ b/src/renderer/timeline.ts
@@ -0,0 +1,157 @@
+// src/renderer/timeline.ts
+// The selected session's timeline: every prompt the person sent, when, what came back and which
+// images that turn produced — a panel over the right edge of the terminal. Clicking a turn scrolls
+// the terminal to where that prompt is drawn.
+//
+// The turns come from the transcript (the same incremental read as the images), so the panel is
+// right about when and what even for turns the scrollback no longer holds; those are shown but
+// cannot be jumped to.
+import type { SessionImageRef, SessionTurn } from '../shared/sessionImages';
+import { imagesByTurn } from '../shared/timeline';
+import { tr } from './i18n-runtime';
+import { createIcon } from './icons';
+import { toast } from './loadError';
+
+export interface TimelineSource {
+  /** Stable per session, like the image strip's. */
+  key: string;
+  turns(): Promise<SessionTurn[]>;
+  /** The session's images as the strip knows them. */
+  images(): readonly SessionImageRef[];
+  /** Where each turn's prompt is drawn in the terminal now: turn id → buffer row. */
+  locate(turns: readonly SessionTurn[]): Map<string, number>;
+  reveal(row: number): void;
+  openImage(id: string): void;
+}
+
+const OPEN_PREF = 'devdeck.timeline.open';
+
+let host: HTMLElement | null = null;
+let panel: HTMLElement | null = null;
+let source: TimelineSource | null = null;
+let turns: SessionTurn[] = [];
+let open = readOpenPref();
+let seq = 0;
+let onToggle: () => void = () => {};
+
+function readOpenPref(): boolean {
+  try { return localStorage.getItem(OPEN_PREF) === '1'; } catch { return false; }
+}
+function writeOpenPref(v: boolean): void {
+  try { localStorage.setItem(OPEN_PREF, v ? '1' : '0'); } catch { /* a private window simply forgets */ }
+}
+
+/** `into` is the terminal pane the panel floats over; `toggled` fires when it opens or closes. */
+export function initTimeline(into: HTMLElement, toggled: () => void): void {
+  host = into;
+  onToggle = toggled;
+  render();
+}
+
+export function isTimelineOpen(): boolean { return open; }
+
+export function toggleTimeline(force?: boolean): void {
+  const next = force ?? !open;
+  if (next === open) return;
+  open = next;
+  writeOpenPref(open);
+  render();
+  if (open) void refreshTimeline();
+  onToggle();
+}
+
+/** Point the panel at a session (or none). Cheap to call on every selection change. */
+export function showTimelineFor(next: TimelineSource | null): void {
+  if (next?.key === source?.key) { source = next; return; }
+  source = next;
+  turns = [];
+  render();
+  if (open) void refreshTimeline();
+}
+
+/** Re-read the turns, while the panel is open. */
+export async function refreshTimeline(): Promise<void> {
+  const src = source;
+  if (!src || !open) return;
+  const my = ++seq;
+  let list: SessionTurn[];
+  try { list = await src.turns(); } catch { return; }
+  if (my !== seq || src.key !== source?.key) return;
+  turns = list;
+  render();
+}
+
+function render(): void {
+  if (!host) return;
+  if (!open || !source) { panel?.remove(); panel = null; return; }
+  const src = source;
+  if (!panel) {
+    panel = document.createElement('aside'); panel.className = 'ck-timeline';
+    panel.setAttribute('aria-label', tr('cockpit.timeline'));
+    panel.addEventListener('keydown', (e) => { if (e.key === 'Escape') { e.preventDefault(); toggleTimeline(false); } });
+    host.appendChild(panel);
+  }
+  const wasAtBottom = !panel.lastElementChild || isScrolledToEnd(panel.querySelector('.ck-tl-list'));
+  const head = document.createElement('div'); head.className = 'ck-tl-head';
+  const title = document.createElement('span'); title.className = 'ck-tl-title';
+  title.textContent = turns.length ? tr('cockpit.timeline_count', { count: String(turns.length) }) : tr('cockpit.timeline');
+  const close = document.createElement('button'); close.type = 'button'; close.className = 'ck-act';
+  close.title = tr('cockpit.timeline_hide'); close.setAttribute('aria-label', close.title);
+  close.appendChild(createIcon('close')); close.addEventListener('click', () => toggleTimeline(false));
+  head.append(title, close);
+  const list = document.createElement('ol'); list.className = 'ck-tl-list';
+  if (turns.length === 0) {
+    const empty = document.createElement('li'); empty.className = 'ck-tl-empty'; empty.textContent = tr('cockpit.timeline_empty');
+    list.appendChild(empty);
+  }
+  const rows = turns.length ? src.locate(turns) : new Map<string, number>();
+  const images = imagesByTurn(turns, src.images());
+  let lastDay = '';
+  for (const t of turns) {
+    const day = t.ts ? new Date(t.ts).toLocaleDateString() : '';
+    if (day && day !== lastDay) {
+      lastDay = day;
+      const sep = document.createElement('li'); sep.className = 'ck-tl-day'; sep.textContent = day;
+      list.appendChild(sep);
+    }
+    list.appendChild(turnItem(src, t, rows.has(t.id), images.get(t.id) ?? []));
+  }
+  panel.replaceChildren(head, list);
+  // Opened or grown at the end: the newest turn is what is looked for.
+  if (wasAtBottom) list.scrollTop = list.scrollHeight;
+}
+
+function isScrolledToEnd(el: Element | null): boolean {
+  return !el || el.scrollTop + el.clientHeight >= el.scrollHeight - 8;
+}
+
+function turnItem(src: TimelineSource, t: SessionTurn, onScreen: boolean, imageIds: string[]): HTMLElement {
+  const li = document.createElement('li'); li.className = `ck-tl-item${onScreen ? '' : ' gone'}`;
+  const b = document.createElement('button'); b.type = 'button'; b.className = 'ck-tl-jump';
+  const when = document.createElement('span'); when.className = 'ck-tl-time';
+  when.textContent = t.ts ? new Date(t.ts).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }) : '';
+  const text = document.createElement('span'); text.className = 'ck-tl-text';
+  text.textContent = t.text || tr('cockpit.timeline_image_only');
+  b.append(when, text);
+  if (t.reply) {
+    const reply = document.createElement('span'); reply.className = 'ck-tl-reply'; reply.textContent = t.reply;
+    b.appendChild(reply);
+  }
+  b.title = [t.text, t.reply ? `→ ${t.reply}` : '', onScreen ? '' : tr('cockpit.timeline_gone')].filter(Boolean).join('\n');
+  const id = t.id;
+  b.addEventListener('click', () => {
+    // Looked up again now: rows move as output scrolls and the scrollback drops its oldest.
+    const row = src.locate(turns).get(id);
+    if (row === undefined) { toast(tr('cockpit.timeline_gone')); return; }
+    src.reveal(row);
+  });
+  li.appendChild(b);
+  if (imageIds.length) {
+    const img = document.createElement('button'); img.type = 'button'; img.className = 'ck-tl-images';
+    img.append(createIcon('image'), String(imageIds.length));
+    img.title = tr('cockpit.timeline_images', { count: String(imageIds.length) }); img.setAttribute('aria-label', img.title);
+    img.addEventListener('click', () => src.openImage(imageIds[0]));
+    li.appendChild(img);
+  }
+  return li;
+}

From 3e8f97567e88b83ec90278075fb9f2f1c4545628 Mon Sep 17 00:00:00 2001
From: Si Hyeong Lee <writingdeveloper@users.noreply.github.com>
Date: Tue, 20 Oct 2026 20:32:49 -0700
Subject: [PATCH 3/6] qa: quick replies, timeline, markup and documents sent
 over the link

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016NLGwiBY5uEivJqERQzcoY
---
 .github/workflows/ci.yml |   4 +
 docs/quality.md          |   2 +-
 package.json             |   3 +-
 qa/cockpit-tools.mjs     | 198 +++++++++++++++++++++++++++++++++++++++
 qa/images-remote.mjs     |  17 +++-
 5 files changed, 220 insertions(+), 4 deletions(-)
 create mode 100644 qa/cockpit-tools.mjs

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c834a79..2f20b35 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -133,6 +133,9 @@ jobs:
       - name: Images tied to their terminal rows
         if: runner.os == 'Windows'
         run: node qa/image-rows.mjs
+      - name: Quick replies, timeline, image markup and sent documents
+        if: runner.os == 'Windows'
+        run: node qa/cockpit-tools.mjs
       - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
         if: always()
         with:
@@ -145,4 +148,5 @@ jobs:
             qa/shots/images/
             qa/shots/images-remote/
             qa/shots/image-rows/
+            qa/shots/cockpit-tools/
             qa/shots/claude-update/
diff --git a/docs/quality.md b/docs/quality.md
index dc6e995..d525d12 100644
--- a/docs/quality.md
+++ b/docs/quality.md
@@ -32,7 +32,7 @@ Results and screenshots are written to `qa/shots/maintenance/` and `qa/shots/res
 
 The CI performance gate is `qa:perf-gate` (Windows, every push): a fixture agent instead of a real one, and units that do not depend on the runner's speed — running CSS animations and DOM mutation records on an idle deck (both must be ~0), DOM mutations outside the terminals while two tiles repaint at 10fps (a per-chunk sidebar rebuild is ~8,000 against a limit of 400), and the main process's longest event-loop stall while working and while 20,000 lines stream. Each limit was checked by injecting the regression it guards against: an infinite CSS animation, a sidebar render per PTY chunk, and a 700ms synchronous block in the main process all fail it. Results go to `qa/shots/perf-gate/results.json`.
 
-`qa:images` (Windows) drives the cockpit image strip, full-size viewer and 📎 attach against an isolated home holding a transcript with a tool screenshot, a pasted image and a written image file; its fixture `claude` echoes what it is sent, so an attached path is read back off the terminal. `qa:update` (Windows) checks "Update all": a fixture `claude` prints Claude Code's failed-update footer, and the harness asserts that `claude update` ran with no session process alive and that every conversation was resumed by id. `qa:images-remote` (Windows) pairs a host and a viewer over real TLS and checks the same from the viewer: thumbnails and the full view cross the link, an attached JPEG lands on the host as PNG with the host path typed, and a non-image named `.png` or an unindexed id is refused over the link. `qa:restore-pacing` (Windows) checks that restored agents start one at a time: a fixture that draws for 2s while booting must not see the next one launched before it finished (measured before the fix: 26–49ms apart). `qa:image-rows` (Windows) ties images to the terminal: a fixture `claude` draws a screen the way Claude Code does (`● server - tool (MCP)` calls, `⎿  [Image]` results, shaded `❯` prompts, a composer between rules) over a transcript holding the same screenshots, and the harness checks that each placeholder is marked and opens its own image, that the viewer shows what led to an image and scrolls the terminal to its row, that copying puts an image on the clipboard (the person's clipboard is restored afterwards), that a new screenshot is previewed while the strip is closed, and that Ctrl+Up/Down steps between sent prompts without entering the composer. None of these starts a real agent.
+`qa:images` (Windows) drives the cockpit image strip, full-size viewer and 📎 attach against an isolated home holding a transcript with a tool screenshot, a pasted image and a written image file; its fixture `claude` echoes what it is sent, so an attached path is read back off the terminal. `qa:update` (Windows) checks "Update all": a fixture `claude` prints Claude Code's failed-update footer, and the harness asserts that `claude update` ran with no session process alive and that every conversation was resumed by id. `qa:images-remote` (Windows) pairs a host and a viewer over real TLS and checks the same from the viewer: thumbnails and the full view cross the link, an attached JPEG lands on the host as PNG with the host path typed, and a non-image named `.png` or an unindexed id is refused over the link. `qa:restore-pacing` (Windows) checks that restored agents start one at a time: a fixture that draws for 2s while booting must not see the next one launched before it finished (measured before the fix: 26–49ms apart). `qa:image-rows` (Windows) ties images to the terminal: a fixture `claude` draws a screen the way Claude Code does (`● server - tool (MCP)` calls, `⎿  [Image]` results, shaded `❯` prompts, a composer between rules) over a transcript holding the same screenshots, and the harness checks that each placeholder is marked and opens its own image, that the viewer shows what led to an image and scrolls the terminal to its row, that copying puts an image on the clipboard (the person's clipboard is restored afterwards), that a new screenshot is previewed while the strip is closed, and that Ctrl+Up/Down steps between sent prompts without entering the composer. `qa:cockpit-tools` (Windows) uses a fixture `claude` that records every byte typed into it: a quick reply from the header menu and from Ctrl+Shift+<n> arrives as the phrase followed by Enter, phrases edited in Settings are saved and offered, the timeline lists each prompt with its time, reply and image count and scrolls the terminal to it without resizing it, and a screenshot marked up in the viewer reaches the session as a PNG that has the red marks in it. `qa:images-remote` also sends a log file from the viewer and checks it lands on the host under its own name. None of these starts a real agent.
 
 Do not run these against a live development conversation. Do not equate a short loopback test with sleep/resume, VPN changes or multi-day field validation.
 
diff --git a/package.json b/package.json
index 6e53ae1..f3e9747 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "devdeck",
-  "version": "1.40.0",
+  "version": "1.41.0",
   "description": "Project command deck — at-a-glance state + Claude Code, Codex, and Antigravity resume",
   "main": "dist/main/main.js",
   "type": "commonjs",
@@ -43,6 +43,7 @@
     "qa:session-sync": "npm run build && node qa/session-sync.mjs",
     "qa:images": "npm run build && node qa/images.mjs",
     "qa:image-rows": "npm run build && node qa/image-rows.mjs",
+    "qa:cockpit-tools": "npm run build && node qa/cockpit-tools.mjs",
     "qa:images-remote": "npm run build && node qa/images-remote.mjs",
     "qa:update": "npm run build && node qa/claude-update.mjs",
     "qa:restore-pacing": "npm run build && node qa/restore-pacing.mjs"
diff --git a/qa/cockpit-tools.mjs b/qa/cockpit-tools.mjs
new file mode 100644
index 0000000..4f0472f
--- /dev/null
+++ b/qa/cockpit-tools.mjs
@@ -0,0 +1,198 @@
+// Windows harness: the cockpit's quick replies, session timeline, image markup sent back to the
+// session, and documents received for a session from another machine. A fixture `claude` draws a
+// Claude-shaped screen and records every byte typed into it, over an isolated HOME whose transcript
+// holds the matching prompts, replies and screenshots. Never starts a real agent.
+// Run with npm run qa:cockpit-tools.
+import { _electron as electron } from 'playwright';
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = resolve(process.argv[2] ?? dirname(dirname(fileURLToPath(import.meta.url))));
+if (process.platform !== 'win32') { console.log('SKIP: Windows native PTY required'); process.exit(0); }
+const shots = resolve(process.argv[3] ?? join(root, 'qa', 'shots', 'cockpit-tools'));
+mkdirSync(shots, { recursive: true });
+const { closeElectron } = await import('file:///' + join(root, 'qa', 'electron-lifecycle.mjs').replace(/\\/g, '/'));
+
+const sandbox = mkdtempSync(join(tmpdir(), 'devdeck-cockpit-tools-'));
+const repo = join(sandbox, 'tools-workspace');
+const bin = join(sandbox, 'bin');
+const profile = join(sandbox, 'profile');
+const home = join(profile, 'home');
+for (const p of [repo, bin, home]) mkdirSync(p, { recursive: true });
+execFileSync('git', ['init', '-q', '-b', 'qa-tools'], { cwd: repo });
+
+const sid = '7a1c2b3d-2222-4333-8444-955566667777';
+const tdir = join(home, '.claude', 'projects', repo.replace(/[^a-zA-Z0-9]/g, '-'));
+mkdirSync(tdir, { recursive: true });
+const transcript = join(tdir, sid + '.jsonl');
+const typedLog = join(bin, 'typed.log');
+const png = (f) => readFileSync(join(root, f)).toString('base64');
+const at = (min) => new Date(Date.now() - min * 60_000).toISOString();
+const said = (text, min) => ({ type: 'assistant', timestamp: at(min), message: { role: 'assistant', content: [{ type: 'text', text }] } });
+const call = (id, name, min, input = {}) => ({ type: 'assistant', timestamp: at(min), message: { role: 'assistant', content: [{ type: 'tool_use', id, name, input }] } });
+const shot = (id, data, min) => ({ type: 'user', timestamp: at(min), message: { role: 'user', content: [{ tool_use_id: id, type: 'tool_result', content: [{ type: 'image', source: { type: 'base64', media_type: 'image/png', data } }] }] } });
+const prompt = (text, min) => ({ type: 'user', timestamp: at(min), cwd: repo, sessionId: sid, message: { role: 'user', content: text } });
+writeFileSync(transcript, [
+  prompt('로그인 화면 확인해줘', 30),
+  said('로그인 페이지를 열어 보겠습니다.', 29),
+  call('s1', 'mcp__playwright__browser_take_screenshot', 29, { element: 'Submit button' }),
+  shot('s1', png('docs/demo/poster.png'), 29),
+  said('제출 버튼이 비활성 상태입니다.', 28),
+  prompt('다음 단계', 10),
+  said('바탕화면도 확인했습니다.', 9),
+].map((l) => JSON.stringify(l)).join('\n') + '\n');
+
+const SHADE = '\x1b[48;5;237m';
+const RESET = '\x1b[0m';
+writeFileSync(join(bin, 'agent.js'), `
+const fs = require('fs');
+const out = (s) => process.stdout.write(s.replace(/\\n/g, '\\r\\n'));
+const filler = (tag, n) => Array.from({ length: n }, (_, i) => '  ' + tag + ' output line ' + i).join('\\n') + '\\n';
+out(${JSON.stringify(SHADE)} + '❯ 로그인 화면 확인해줘' + ${JSON.stringify(RESET)} + '\\n');
+out('● playwright - browser_take_screenshot (MCP)(element: "Submit button")\\n  ⎿  [Image]\\n');
+out(filler('first', 70));
+out(${JSON.stringify(SHADE)} + '❯ 다음 단계' + ${JSON.stringify(RESET)} + '\\n');
+out(filler('second', 70));
+out('────────────────────────────────\\n❯ \\n────────────────────────────────\\n');
+out('FIXTURE_READY\\n');
+if (process.stdin.isTTY) process.stdin.setRawMode(true);
+process.stdin.on('data', (d) => fs.appendFileSync(${JSON.stringify(typedLog)}, d));
+setInterval(() => {}, 1 << 30);
+`);
+writeFileSync(join(bin, 'claude.cmd'), '@echo off\r\nnode "%~dp0agent.js" %*\r\n');
+
+writeFileSync(join(profile, 'state.json'), JSON.stringify({ projects: {}, settings: {
+  language: 'ko', folders: [{ path: repo, kind: 'repo' }], viewMode: 'list',
+  cockpitSessions: [{ tileId: 'tile-tools-1', projectPath: repo, name: 'tools-workspace', sessionId: sid, agentId: 'claude', label: 'Tools QA', lastActiveMs: Date.now() }],
+} }));
+const env = { ...process.env, HOME: home, USERPROFILE: home, CLAUDECODE: '', CLAUDE_CODE_SSE_PORT: '', CLAUDE_CODE_ENTRYPOINT: '' };
+const pathKey = Object.keys(env).find((k) => k.toLowerCase() === 'path') || 'PATH';
+env[pathKey] = bin + ';' + env[pathKey];
+
+const app = await electron.launch({ args: ['.', '--user-data-dir=' + profile, '--no-sandbox', '--disable-gpu'], cwd: root, env });
+const errors = [];
+let failed = false;
+const check = async (name, fn) => { await fn(); console.log('PASS ' + name); };
+const typed = () => (existsSync(typedLog) ? readFileSync(typedLog, 'utf8') : '');
+const waitTyped = async (needle, ms = 8000) => {
+  for (const until = Date.now() + ms; Date.now() < until; await new Promise((r) => setTimeout(r, 100))) if (typed().includes(needle)) return;
+  assert.fail(`the session never received ${JSON.stringify(needle)}; got ${JSON.stringify(typed().slice(-200))}`);
+};
+try {
+  const win = await app.firstWindow();
+  win.setDefaultTimeout(15000);
+  win.on('pageerror', (e) => errors.push(String(e)));
+  win.on('console', (m) => { if (m.type() === 'error') errors.push(m.text()); });
+  const topRow = () => win.evaluate(() => document.querySelector('.ck-term.show .xterm-rows > div')?.textContent ?? '');
+
+  await check('session opens with the fixture screen', async () => {
+    await win.waitForSelector('#shell-session-groups .shell-session', { timeout: 30000 });
+    await win.locator('#shell-session-groups .shell-session').first().click();
+    await win.waitForFunction(() => [...document.querySelectorAll('.ck-term.show .xterm-rows')].some((r) => r.textContent.includes('FIXTURE_READY')), null, { timeout: 20000 });
+    await win.waitForFunction(() => document.querySelector('#ck-header .ck-img-count')?.textContent === '1');
+  });
+
+  await check('a quick reply from the menu is typed and sent', async () => {
+    const button = win.locator('#ck-header button[aria-label="빠른 답장"]');
+    // Waiting for the person: the button says so.
+    await win.waitForFunction(() => document.querySelector('#ck-header .ck-qr-btn')?.classList.contains('ready'), null, { timeout: 20000 });
+    await button.click();
+    await win.waitForSelector('.ck-qr-menu .ck-qr-item');
+    assert.deepEqual(await win.locator('.ck-qr-item .ck-qr-text').allTextContents(), ['네 계속 진행해줘', '커밋해줘', '테스트 돌려서 결과 확인해줘', '변경한 내용 요약해줘']);
+    await win.screenshot({ path: join(shots, '1-quick-replies.png') });
+    await win.locator('.ck-qr-item').first().click();
+    await waitTyped('네 계속 진행해줘\r');
+    assert.equal(await win.locator('.ck-qr-menu').count(), 0, 'the menu closed');
+  });
+
+  await check('Ctrl+Shift+<n> sends the n-th quick reply from the terminal', async () => {
+    await win.locator('.ck-term.show .xterm-screen').click();
+    await win.keyboard.press('Control+Shift+Digit2');
+    await waitTyped('커밋해줘\r');
+    assert.ok(!typed().includes('@'), 'Shift+2 itself never reached the agent');
+  });
+
+  await check('quick replies edited in Settings are the ones offered', async () => {
+    await win.click('.rail-item[data-view="settings"]');
+    const field = win.locator('#settings-form .set-quick-replies');
+    await field.fill('배포 전 체크리스트 확인해줘\n로그 다시 봐줘');
+    await field.blur();
+    await win.waitForFunction(() => document.querySelector('#settings-form .set-quick-replies')?.closest('.set-row')?.querySelector('.set-save-status')?.textContent === '저장됨');
+    const saved = JSON.parse(readFileSync(join(profile, 'state.json'), 'utf8')).settings.quickReplies;
+    assert.deepEqual(saved, ['배포 전 체크리스트 확인해줘', '로그 다시 봐줘']);
+    await win.locator('#shell-session-groups .shell-session').first().click();
+    await win.locator('#ck-header button[aria-label="빠른 답장"]').click();
+    assert.deepEqual(await win.locator('.ck-qr-item .ck-qr-text').allTextContents(), ['배포 전 체크리스트 확인해줘', '로그 다시 봐줘']);
+    await win.keyboard.press('Escape');
+    await win.waitForSelector('.ck-qr-menu', { state: 'detached' });
+  });
+
+  await check('the timeline lists each prompt with when, the reply and its images, and jumps to it', async () => {
+    await win.locator('#ck-header button[aria-label="타임라인 보기"]').click();
+    await win.waitForFunction(() => document.querySelectorAll('.ck-timeline .ck-tl-item').length === 2);
+    const items = await win.locator('.ck-tl-item .ck-tl-text').allTextContents();
+    assert.deepEqual(items, ['로그인 화면 확인해줘', '다음 단계']);
+    const replies = await win.locator('.ck-tl-item .ck-tl-reply').allTextContents();
+    assert.deepEqual(replies, ['제출 버튼이 비활성 상태입니다.', '바탕화면도 확인했습니다.']);
+    assert.equal(await win.locator('.ck-tl-item').first().locator('.ck-tl-images').textContent(), '1');
+    assert.equal(await win.locator('.ck-tl-item.gone').count(), 0, 'both prompts are still on screen');
+    // The terminal underneath kept its size: the panel floats over it.
+    const cols = await win.evaluate(() => document.querySelector('.ck-term.show .xterm-rows > div')?.textContent.length ?? 0);
+    await win.screenshot({ path: join(shots, '2-timeline.png') });
+    await win.locator('.ck-tl-item .ck-tl-jump').first().click();
+    await win.waitForFunction(() => document.querySelector('.ck-term.show .xterm-rows > div')?.textContent.includes('로그인 화면 확인해줘'));
+    assert.ok((await topRow()).includes('로그인 화면 확인해줘'));
+    assert.ok(cols > 0);
+    await win.locator('.ck-tl-item .ck-tl-images').first().click();
+    await win.waitForFunction(() => document.querySelector('.ck-img-context')?.textContent.includes('Submit button'));
+  });
+
+  await check('a screenshot marked up in the viewer goes back to the session with the marks on it', async () => {
+    await win.locator('.ck-img-bar button[aria-label="표시하기"]').click();
+    await win.waitForSelector('.ck-img-markup.on');
+    const box = await win.locator('.ck-img-stage img').boundingBox();
+    const from = { x: box.x + box.width * 0.3, y: box.y + box.height * 0.3 };
+    const to = { x: box.x + box.width * 0.6, y: box.y + box.height * 0.6 };
+    await win.mouse.move(from.x, from.y); await win.mouse.down();
+    await win.mouse.move(to.x, to.y, { steps: 6 }); await win.mouse.up();
+    await win.locator('.ck-img-tools button[aria-label="화살표"]').click();
+    await win.mouse.move(to.x + 60, to.y + 40); await win.mouse.down();
+    await win.mouse.move(to.x + 5, to.y + 5, { steps: 6 }); await win.mouse.up();
+    assert.equal(await win.locator('.ck-img-tools button[aria-label="되돌리기 (Ctrl+Z)"]').isDisabled(), false);
+    await win.screenshot({ path: join(shots, '3-markup.png') });
+    await win.locator('.ck-img-bar button[aria-label="표시한 이미지를 세션에 첨부"]').click();
+    await win.waitForSelector('.ck-img-viewer', { state: 'detached' });
+    await waitTyped('.png ');
+    const path = /(\S+devdeck-paste-[0-9a-f-]+\.png)/.exec(typed())?.[1];
+    assert.ok(path && existsSync(path), 'the marked-up image was written where the session can read it');
+    // Red marks in the sent picture: count strongly red pixels (the bitmap is BGRA).
+    const red = await app.evaluate(({ nativeImage }, p) => {
+      const img = nativeImage.createFromPath(p); const b = img.toBitmap(); let n = 0;
+      for (let i = 0; i < b.length; i += 4) if (b[i + 2] > 220 && b[i + 1] < 90 && b[i] < 90) n++;
+      return n;
+    }, path);
+    assert.ok(red > 200, `the marks are in the sent image (${red} red pixels)`);
+    rmSync(path, { force: true });
+  });
+
+  await check('a document sent from another machine lands in the temp directory under its own name', async () => {
+    const landed = await win.evaluate(() => window.devdeck.cockpit.receiveFile('build.log', btoa('step 1 ok\nstep 2 failed\n')));
+    assert.match(landed, /devdeck-file-[0-9a-f-]{36}-build\.log$/);
+    assert.equal(readFileSync(landed, 'utf8'), 'step 1 ok\nstep 2 failed\n');
+    assert.equal(await win.evaluate(() => window.devdeck.cockpit.receiveFile('run.ps1', btoa('Remove-Item'))), null);
+    rmSync(landed, { force: true });
+  });
+
+  assert.deepEqual(errors, [], 'no renderer errors');
+} catch (e) {
+  console.log('FAIL', e?.message ?? e);
+  failed = true;
+  try { const w = await app.firstWindow(); await w.screenshot({ path: join(shots, 'failure.png') }); } catch { /* window gone */ }
+} finally {
+  await closeElectron(app).catch(() => {});
+}
+if (failed) process.exitCode = 1;
diff --git a/qa/images-remote.mjs b/qa/images-remote.mjs
index 4a14c7c..83f54d7 100644
--- a/qa/images-remote.mjs
+++ b/qa/images-remote.mjs
@@ -88,7 +88,7 @@ try {
   });
 
   await check('thumbnails and the full view travel over the link', async () => {
-    await viewer.win.locator('#ck-header button[aria-pressed]').click();
+    await viewer.win.locator('#ck-header button.ck-img-toggle').click();
     await viewer.win.waitForFunction(() => document.querySelectorAll('#ck-images .ck-img-thumb img[src^="data:image"]').length === 2);
     await viewer.win.locator('#ck-images .ck-img-thumb.kind-screenshot').click();
     await viewer.win.waitForFunction(() => document.querySelector('.ck-img-viewer .ck-img-stage img')?.getAttribute('src')?.startsWith('data:image'));
@@ -108,7 +108,7 @@ try {
       }, [join(root, 'build', 'icon.png'), jpg]);
     });
     const chooser = viewer.win.waitForEvent('filechooser');
-    await viewer.win.locator('#ck-header .ck-act').filter({ has: viewer.win.locator('svg') }).and(viewer.win.locator('[title*="이미지 첨부"]')).click();
+    await viewer.win.locator('#ck-header .ck-act').filter({ has: viewer.win.locator('svg') }).and(viewer.win.locator('[title*="이미지·문서 첨부"]')).click();
     await (await chooser).setFiles(jpg);
     await rowsInclude(viewer.win, 'devdeck-paste-');
     const typed = await host.win.evaluate(() => [...document.querySelectorAll('.ck-term.show .xterm-rows')].map((r) => r.textContent).join('\n'));
@@ -119,6 +119,19 @@ try {
     await viewer.win.screenshot({ path: join(shots, 'viewer-attached.png') });
   });
 
+  await check('a log file attached on the viewer lands on the host under its own name and its host path is typed', async () => {
+    const log = join(sandbox, 'build.log');
+    writeFileSync(log, 'step 1 ok\nstep 2 failed\n');
+    const chooser = viewer.win.waitForEvent('filechooser');
+    await viewer.win.locator('#ck-header .ck-act[title*="이미지·문서 첨부"]').click();
+    await (await chooser).setFiles(log);
+    await rowsInclude(viewer.win, 'build.log');
+    const typed = await host.win.evaluate(() => [...document.querySelectorAll('.ck-term.show .xterm-rows')].map((r) => r.textContent).join('\n'));
+    const m = /GOT:(\S*devdeck-file-[0-9a-f-]{36}-build\.log)/.exec(typed.replace(/\n/g, ''));
+    assert.ok(m, 'host typed the sent file path:\n' + typed);
+    assert.equal(readFileSync(m[1], 'utf8'), 'step 1 ok\nstep 2 failed\n');
+  });
+
   await check('over the link, a real image is served and a fake .png or unindexed id is refused', async () => {
     const r = await viewer.win.evaluate(async ([id, path]) => {
       const m = window.devdeck.machine(id).cockpit;

From 9005fc507ed2f38f02f5069ba786efb1dc14ad99 Mon Sep 17 00:00:00 2001
From: Si Hyeong Lee <writingdeveloper@users.noreply.github.com>
Date: Tue, 20 Oct 2026 20:32:49 -0700
Subject: [PATCH 4/6] chore: 1.41.0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016NLGwiBY5uEivJqERQzcoY
---
 README.md               |  2 +-
 docs/releases/1.41.0.md | 40 ++++++++++++++++++++++++++++++++++++++++
 package-lock.json       |  4 ++--
 3 files changed, 43 insertions(+), 3 deletions(-)
 create mode 100644 docs/releases/1.41.0.md

diff --git a/README.md b/README.md
index 04d712f..cc4cd14 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,7 @@ See what needs attention, resume the right conversation, and work on a paired PC
 
 </div>
 
-> **1.40.0** ties each screenshot to the terminal row it appeared on — hover a highlighted `[Image]` for a thumbnail, click for the full view, and jump from the viewer back to the row — says what led to each image, previews new screenshots, copies images, and adds Ctrl+↑/↓ between your prompts ([release notes](docs/releases/1.40.0.md)). 1.39.0 shows the screenshots and images a Claude session worked with — Claude Desktop shows them inline; DevDeck puts them in a strip beside the terminal, also for sessions on another PC — adds 📎 / drag-and-drop attachments (images travel to a remote PC), **Update all** for Claude Code on Windows, staggered session restores that no longer stall a PC, and ends the daily false "Login expired" ([release notes](docs/releases/1.39.0.md)). 1.38.0 made closing a session reliable across paired PCs ([notes](docs/releases/1.38.0.md)). See [the maintenance review](docs/quality-review-2026-09-08.md) and [session synchronization review](docs/session-sync-review-2026-09-08.md).
+> **1.41.0** adds quick replies (one click or Ctrl+Shift+1…9 for the phrases you keep typing), a session timeline of your prompts with their times, replies and images, red boxes and arrows drawn on a screenshot and sent straight back to the session, and text, log and PDF attachments for sessions on another PC ([release notes](docs/releases/1.41.0.md)). 1.40.0 ties each screenshot to the terminal row it appeared on — hover a highlighted `[Image]` for a thumbnail, click for the full view, and jump from the viewer back to the row — says what led to each image, previews new screenshots, copies images, and adds Ctrl+↑/↓ between your prompts ([release notes](docs/releases/1.40.0.md)). 1.39.0 shows the screenshots and images a Claude session worked with — Claude Desktop shows them inline; DevDeck puts them in a strip beside the terminal, also for sessions on another PC — adds 📎 / drag-and-drop attachments (images travel to a remote PC), **Update all** for Claude Code on Windows, staggered session restores that no longer stall a PC, and ends the daily false "Login expired" ([release notes](docs/releases/1.39.0.md)). 1.38.0 made closing a session reliable across paired PCs ([notes](docs/releases/1.38.0.md)). See [the maintenance review](docs/quality-review-2026-09-08.md) and [session synchronization review](docs/session-sync-review-2026-09-08.md).
 
 <div align="center">
 <img src="docs/screenshots/projects.png" width="820" alt="DevDeck project overview with repository and session navigation" />
diff --git a/docs/releases/1.41.0.md b/docs/releases/1.41.0.md
new file mode 100644
index 0000000..bda57ec
--- /dev/null
+++ b/docs/releases/1.41.0.md
@@ -0,0 +1,40 @@
+# DevDeck 1.41.0
+
+## Quick replies
+
+- **One click for what you keep typing.** A 💬 button in a session's header opens your phrases: "Yes, go ahead", "Commit it", "Run the tests and check the result", "Summarize what you changed". Picking one types it and presses Enter. A green dot on the button means the session is waiting for you.
+- **Ctrl+Shift+1…9** in the terminal sends phrase 1 to 9 without opening the menu. The digit is never typed into the agent.
+- **Your own phrases.** Settings → Quick replies takes one phrase per line, up to nine. Leave it empty for the defaults in your language.
+
+## Session timeline
+
+- A panel over the right edge of the terminal lists every prompt you sent in the session. Each entry shows when you sent it, its first line, the agent's last words in reply, and how many images that turn produced.
+- Click a prompt to scroll the terminal to it, briefly highlighted. Click the image count to open that turn's screenshot.
+- The list comes from the session's own record, so it is complete even when the terminal's scrollback no longer reaches back. Prompts that have scrolled out are shown dimmed and cannot be jumped to.
+- The panel floats over the terminal and never resizes it.
+
+## Mark up a screenshot and send it back
+
+- In the full-size viewer, **Mark up** gives you a box, an arrow and a pen in red. Undo is Ctrl+Z, and Esc stops drawing.
+- **Attach to the session** sends the image, with your marks, to the session it came from. The image is written where the session runs and its path is typed into the prompt, the same way a pasted screenshot is. This works for sessions on another PC too.
+- The marks are drawn in the image's own pixels and sent at full resolution, then scaled down only if the picture would exceed the 5MB attachment limit.
+- **Copy image** copies the marked-up version when there are marks.
+
+## Documents for a session on another PC
+
+- 📎 and drag-and-drop for a session on another PC now take text, log, data and PDF files as well as images: `.txt .log .md .json .jsonl .csv .tsv .yaml .xml .toml .ini .cfg .conf .diff .patch .sql .pdf`, up to 5MB each.
+- The other PC writes the file into its temp folder under its own name and types that path. Old files are cleaned up after a day, like pasted images.
+- That PC checks every file before writing it:
+  - only the kinds listed above are accepted, never scripts, executables or HTML
+  - a PDF must start like a PDF, and a text file must contain no binary bytes
+  - it needs the same "type in sessions" permission as an image, and shares the same hourly limit
+- A PC still on an older DevDeck cannot receive documents. You are told how many files it could not take and that the PC needs updating; nothing is typed into the session for them.
+
+## Under the hood
+
+- A new automated check (`qa:cockpit-tools`) runs on every change on Windows. A fixture agent records every byte typed into it, and the check covers:
+  - both ways of sending a quick reply, and phrases edited in Settings
+  - the timeline's contents, and that clicking a prompt jumps to it
+  - that a marked-up screenshot reaches the session with its red marks in the pixels
+- The remote-image check (`qa:images-remote`) now also sends a log file from one PC to another over the real link.
+- Turns are read in the same incremental pass over the session record as the images. The timeline costs no second read of a transcript that can reach hundreds of megabytes. The performance gate is unchanged.
diff --git a/package-lock.json b/package-lock.json
index d98bfce..eea1436 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "devdeck",
-  "version": "1.40.0",
+  "version": "1.41.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "devdeck",
-      "version": "1.40.0",
+      "version": "1.41.0",
       "license": "MIT",
       "dependencies": {
         "@fontsource-variable/geist": "5.3.0",

From 96fca1573616a513c9d7ca3f493c175102468465 Mon Sep 17 00:00:00 2001
From: Si Hyeong Lee <writingdeveloper@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:04:57 -0700
Subject: [PATCH 5/6] fix(timeline,quick-replies): leave out compaction
 summaries, unwrap pasted text, pass unused Ctrl+Shift digits through

Checked against 12 real transcripts: the compaction summary is filed as a user line
(isCompactSummary) and pasted text arrives wrapped in <pasted_content>; both showed
up as prompts. A Ctrl+Shift+<n> with no phrase behind it was swallowed with a toast;
it now reaches the terminal as it did before quick replies.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016NLGwiBY5uEivJqERQzcoY
---
 docs/releases/1.41.0.md        | 3 ++-
 src/main/sessionImages.test.ts | 3 +++
 src/renderer/cockpitView.ts    | 8 ++++----
 src/renderer/locales/en.json   | 1 -
 src/renderer/locales/ja.json   | 1 -
 src/renderer/locales/ko.json   | 1 -
 src/renderer/locales/zh.json   | 1 -
 src/shared/sessionImages.ts    | 6 +++++-
 8 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/docs/releases/1.41.0.md b/docs/releases/1.41.0.md
index bda57ec..9941481 100644
--- a/docs/releases/1.41.0.md
+++ b/docs/releases/1.41.0.md
@@ -3,13 +3,14 @@
 ## Quick replies
 
 - **One click for what you keep typing.** A 💬 button in a session's header opens your phrases: "Yes, go ahead", "Commit it", "Run the tests and check the result", "Summarize what you changed". Picking one types it and presses Enter. A green dot on the button means the session is waiting for you.
-- **Ctrl+Shift+1…9** in the terminal sends phrase 1 to 9 without opening the menu. The digit is never typed into the agent.
+- **Ctrl+Shift+1…9** in the terminal sends phrase 1 to 9 without opening the menu. The digit is never typed into the agent. A number with no phrase behind it reaches the terminal as before.
 - **Your own phrases.** Settings → Quick replies takes one phrase per line, up to nine. Leave it empty for the defaults in your language.
 
 ## Session timeline
 
 - A panel over the right edge of the terminal lists every prompt you sent in the session. Each entry shows when you sent it, its first line, the agent's last words in reply, and how many images that turn produced.
 - Click a prompt to scroll the terminal to it, briefly highlighted. Click the image count to open that turn's screenshot.
+- Only what you typed is listed: the summary Claude Code writes when it compacts a conversation is left out, and pasted text shows its own first line.
 - The list comes from the session's own record, so it is complete even when the terminal's scrollback no longer reaches back. Prompts that have scrolled out are shown dimmed and cannot be jumped to.
 - The panel floats over the terminal and never resizes it.
 
diff --git a/src/main/sessionImages.test.ts b/src/main/sessionImages.test.ts
index a1dbfcc..a0db06d 100644
--- a/src/main/sessionImages.test.ts
+++ b/src/main/sessionImages.test.ts
@@ -147,11 +147,14 @@ describe('session turns', () => {
       plain('<command-name>/clear</command-name>'),
       JSON.stringify({ type: 'user', isMeta: true, timestamp: TS, message: { role: 'user', content: 'Caveat: hidden' } }),
       plain('[Request interrupted by user]'),
+      JSON.stringify({ type: 'user', isCompactSummary: true, isVisibleInTranscriptOnly: true, timestamp: TS, message: { role: 'user', content: 'This session is being continued from a previous conversation' } }),
+      plain('\n\n<pasted_content id="3a1d">\nRead CLAUDE.md first.\nThen continue.\n</pasted_content id="3a1d">\n'),
     ];
     lines.forEach((l, i) => c.add(l, i * 100));
     expect(c.turns).toEqual([
       { id: 't0', ts: Date.parse(TS), text: 'fix the login page', pasted: 0, reply: 'Fixed: the handler was not awaited.' },
       { id: 't500', ts: Date.parse(TS), text: 'look', pasted: 1, reply: null },
+      { id: 't1000', ts: Date.parse(TS), text: 'Read CLAUDE.md first.', pasted: 0, reply: null },
     ]);
   });
 
diff --git a/src/renderer/cockpitView.ts b/src/renderer/cockpitView.ts
index c45df50..6e09c95 100644
--- a/src/renderer/cockpitView.ts
+++ b/src/renderer/cockpitView.ts
@@ -1044,14 +1044,14 @@ async function buildTile(p: OpenReq): Promise<boolean> {
       return false;
     }
     if (action === 'find') { e.preventDefault(); openFindBar(); return false; } // Ctrl+F searches scrollback, never reaches the PTY
+    // A slot with no phrase is left to the terminal, as the chord was before quick replies existed.
     const slot = quickReplySlot(e);
-    if (slot !== null) {
+    const phrase = slot === null ? undefined : quickReplies()[slot];
+    if (phrase) {
       e.preventDefault();
-      const text = quickReplies()[slot];
       // By terminal, not by the session declared below: a key can arrive while the tile is still opening.
       const owner = [...live.values()].find((x) => x.term === term);
-      if (!text) toast(tr('cockpit.quick_reply_none', { n: String(slot + 1) }));
-      else if (owner) sendQuickReply(owner.session.id, text);
+      if (owner) sendQuickReply(owner.session.id, phrase);
       return false;
     }
     if (action === 'prompt-prev' || action === 'prompt-next') {
diff --git a/src/renderer/locales/en.json b/src/renderer/locales/en.json
index feb315b..7bcc52e 100644
--- a/src/renderer/locales/en.json
+++ b/src/renderer/locales/en.json
@@ -538,7 +538,6 @@
   "cockpit.attach_host_too_old": "{count} skipped — DevDeck on {machine} is too old to receive documents (update it to 1.41.0)",
   "cockpit.quick_replies": "Quick replies",
   "cockpit.quick_replies_hint": "Edit these in Settings → Quick replies",
-  "cockpit.quick_reply_none": "No quick reply {n} — add one in Settings",
   "cockpit.quick_default_1": "Yes, go ahead",
   "cockpit.quick_default_2": "Commit it",
   "cockpit.quick_default_3": "Run the tests and check the result",
diff --git a/src/renderer/locales/ja.json b/src/renderer/locales/ja.json
index ba093e1..3859bb7 100644
--- a/src/renderer/locales/ja.json
+++ b/src/renderer/locales/ja.json
@@ -538,7 +538,6 @@
   "cockpit.attach_host_too_old": "{count} 件をスキップ — {machine} の DevDeck はドキュメントを受け取れないバージョンです (1.41.0 に更新してください)",
   "cockpit.quick_replies": "クイック返信",
   "cockpit.quick_replies_hint": "設定 → クイック返信 で変更できます",
-  "cockpit.quick_reply_none": "クイック返信 {n} がありません — 設定で追加してください",
   "cockpit.quick_default_1": "はい、続けてください",
   "cockpit.quick_default_2": "コミットしてください",
   "cockpit.quick_default_3": "テストを実行して結果を確認してください",
diff --git a/src/renderer/locales/ko.json b/src/renderer/locales/ko.json
index 974ea3c..d271ac5 100644
--- a/src/renderer/locales/ko.json
+++ b/src/renderer/locales/ko.json
@@ -538,7 +538,6 @@
   "cockpit.attach_host_too_old": "{count}개 건너뜀 — {machine}의 DevDeck이 문서를 받을 수 없는 버전입니다 (1.41.0으로 업데이트하세요)",
   "cockpit.quick_replies": "빠른 답장",
   "cockpit.quick_replies_hint": "설정 → 빠른 답장에서 바꿀 수 있습니다",
-  "cockpit.quick_reply_none": "빠른 답장 {n}번이 없습니다 — 설정에서 추가하세요",
   "cockpit.quick_default_1": "네 계속 진행해줘",
   "cockpit.quick_default_2": "커밋해줘",
   "cockpit.quick_default_3": "테스트 돌려서 결과 확인해줘",
diff --git a/src/renderer/locales/zh.json b/src/renderer/locales/zh.json
index b894191..a6969f7 100644
--- a/src/renderer/locales/zh.json
+++ b/src/renderer/locales/zh.json
@@ -538,7 +538,6 @@
   "cockpit.attach_host_too_old": "跳过 {count} 个 — {machine} 上的 DevDeck 版本过旧，无法接收文档 (请更新到 1.41.0)",
   "cockpit.quick_replies": "快捷回复",
   "cockpit.quick_replies_hint": "可在 设置 → 快捷回复 中修改",
-  "cockpit.quick_reply_none": "没有第 {n} 条快捷回复 — 请在设置中添加",
   "cockpit.quick_default_1": "好的，继续",
   "cockpit.quick_default_2": "提交一下",
   "cockpit.quick_default_3": "运行测试并检查结果",
diff --git a/src/shared/sessionImages.ts b/src/shared/sessionImages.ts
index f287f8d..06d6e17 100644
--- a/src/shared/sessionImages.ts
+++ b/src/shared/sessionImages.ts
@@ -217,8 +217,10 @@ export class SessionImageCollector {
 
   /** A user line that is something the person typed — not a tool result, a command or a reminder. */
   private noteTurn(entry: unknown, content: unknown, offset: number, ts: number | null): void {
-    const e = entry as { type?: unknown; isMeta?: unknown; isSidechain?: unknown };
+    const e = entry as { type?: unknown; isMeta?: unknown; isSidechain?: unknown; isCompactSummary?: unknown; isVisibleInTranscriptOnly?: unknown };
     if (e.type !== 'user' || e.isMeta === true || e.isSidechain === true) return;
+    // The summary Claude Code writes when it compacts a conversation is filed as a user line.
+    if (e.isCompactSummary === true || e.isVisibleInTranscriptOnly === true) return;
     let raw = '';
     let pasted = 0;
     if (typeof content === 'string') raw = content;
@@ -232,6 +234,8 @@ export class SessionImageCollector {
     } else return;
     if (raw && isWrapper(raw)) return;
     if (/^\s*\[Request interrupted/.test(raw)) return;
+    // Pasted text is recorded inside a <pasted_content> wrapper; what matters is what was pasted.
+    raw = raw.replace(/<\/?pasted_content\b[^>]*>/g, '');
     const text = oneLine(stripImageNoise(raw)) ?? '';
     if (!text && pasted === 0) return;
     this.turns.push({ id: `t${offset}`, ts, text, pasted, reply: null });

From 66ec4de9d382f6d21d3ef8202e98499f63438a74 Mon Sep 17 00:00:00 2001
From: Si Hyeong Lee <writingdeveloper@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:06:16 -0700
Subject: [PATCH 6/6] fix(timeline): say a paired PC needs updating instead of
 showing an empty timeline

While one PC is on 1.41.0 and the other is not, the newer one asked the older host for
turns, got 'no such method', and showed 'no prompts yet'. Tests cover an older host for
the timeline, documents and images, and the document-sending paths in attachments.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016NLGwiBY5uEivJqERQzcoY
---
 src/renderer/attachments.test.ts | 32 ++++++++++++++++++++++++++++++++
 src/renderer/locales/en.json     |  3 ++-
 src/renderer/locales/ja.json     |  3 ++-
 src/renderer/locales/ko.json     |  3 ++-
 src/renderer/locales/zh.json     |  3 ++-
 src/renderer/machineDeck.test.ts | 29 +++++++++++++++++++++++++++++
 src/renderer/machineDeck.ts      |  9 ++++++++-
 src/renderer/timeline.ts         | 15 +++++++++++++--
 8 files changed, 90 insertions(+), 7 deletions(-)
 create mode 100644 src/renderer/attachments.test.ts

diff --git a/src/renderer/attachments.test.ts b/src/renderer/attachments.test.ts
new file mode 100644
index 0000000..8b23fab
--- /dev/null
+++ b/src/renderer/attachments.test.ts
@@ -0,0 +1,32 @@
+import { describe, expect, it, vi } from 'vitest';
+import { attachFiles, type AttachTarget } from './attachments';
+import { MAX_SENT_FILE_BYTES } from '../shared/sentFiles';
+
+const remote = (over: Partial<AttachTarget> = {}): AttachTarget => ({
+  local: false,
+  receiveImage: vi.fn().mockResolvedValue(null),
+  receiveFile: vi.fn().mockResolvedValue('C:\\Temp\\devdeck-file-x-build.log'),
+  pathForFile: () => '',
+  ...over,
+});
+
+describe('attaching documents to a session on another PC', () => {
+  it('sends a document the host can take and types the path it landed at', async () => {
+    const target = remote();
+    const out = await attachFiles([new File(['step 1 ok\n'], 'build.log')], target);
+    expect(out.paths).toEqual(['C:\\Temp\\devdeck-file-x-build.log']);
+    expect(target.receiveFile).toHaveBeenCalledWith('build.log', btoa('step 1 ok\n'));
+  });
+
+  it('counts a host too old to receive documents apart from a failure', async () => {
+    const out = await attachFiles([new File(['x'], 'a.log')], remote({ receiveFile: vi.fn().mockRejectedValue(new Error('no such method: cockpit:receiveFile')) }));
+    expect([out.paths.length, out.hostTooOld, out.failed]).toEqual([0, 1, 0]);
+  });
+
+  it('never sends a kind that could run, or one over the limit', async () => {
+    const target = remote();
+    const out = await attachFiles([new File(['MZ'], 'setup.exe'), new File([new Uint8Array(MAX_SENT_FILE_BYTES + 1)], 'huge.log')], target);
+    expect([out.skippedNonImage, out.tooLarge]).toEqual([1, 1]);
+    expect(target.receiveFile).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/renderer/locales/en.json b/src/renderer/locales/en.json
index 7bcc52e..50d73fc 100644
--- a/src/renderer/locales/en.json
+++ b/src/renderer/locales/en.json
@@ -562,5 +562,6 @@
   "cockpit.image_attached_marked": "Marked-up image attached to the session",
   "cockpit.image_attach_failed": "Could not attach the image — nothing was typed into the session.",
   "set.quick_replies": "Quick replies",
-  "set.quick_replies_hint": "One per line, up to 9. Sent with the 💬 button in a session's header, or Ctrl+Shift+1…9 in its terminal. Leave empty for the defaults."
+  "set.quick_replies_hint": "One per line, up to 9. Sent with the 💬 button in a session's header, or Ctrl+Shift+1…9 in its terminal. Leave empty for the defaults.",
+  "cockpit.timeline_host_too_old": "The DevDeck on that PC is too old to show a timeline — update it to 1.41.0."
 }
diff --git a/src/renderer/locales/ja.json b/src/renderer/locales/ja.json
index 3859bb7..4c20779 100644
--- a/src/renderer/locales/ja.json
+++ b/src/renderer/locales/ja.json
@@ -562,5 +562,6 @@
   "cockpit.image_attached_marked": "マークした画像をセッションに添付しました",
   "cockpit.image_attach_failed": "画像を添付できませんでした — セッションには何も入力していません。",
   "set.quick_replies": "クイック返信",
-  "set.quick_replies_hint": "1 行に 1 つ、最大 9 個。セッション上部の 💬 ボタン、またはターミナルで Ctrl+Shift+1…9 で送信します。空欄なら既定の文言を使います。"
+  "set.quick_replies_hint": "1 行に 1 つ、最大 9 個。セッション上部の 💬 ボタン、またはターミナルで Ctrl+Shift+1…9 で送信します。空欄なら既定の文言を使います。",
+  "cockpit.timeline_host_too_old": "その PC の DevDeck はタイムラインに対応していないバージョンです — 1.41.0 に更新してください。"
 }
diff --git a/src/renderer/locales/ko.json b/src/renderer/locales/ko.json
index d271ac5..0f15746 100644
--- a/src/renderer/locales/ko.json
+++ b/src/renderer/locales/ko.json
@@ -562,5 +562,6 @@
   "cockpit.image_attached_marked": "표시한 이미지를 세션에 첨부했습니다",
   "cockpit.image_attach_failed": "이미지를 첨부하지 못했습니다 — 세션에는 아무것도 입력하지 않았습니다.",
   "set.quick_replies": "빠른 답장",
-  "set.quick_replies_hint": "한 줄에 하나씩, 최대 9개. 세션 상단의 💬 버튼이나 터미널에서 Ctrl+Shift+1…9로 보냅니다. 비워 두면 기본 문구를 씁니다."
+  "set.quick_replies_hint": "한 줄에 하나씩, 최대 9개. 세션 상단의 💬 버튼이나 터미널에서 Ctrl+Shift+1…9로 보냅니다. 비워 두면 기본 문구를 씁니다.",
+  "cockpit.timeline_host_too_old": "그 PC의 DevDeck이 타임라인을 지원하지 않는 버전입니다 — 1.41.0으로 업데이트하세요."
 }
diff --git a/src/renderer/locales/zh.json b/src/renderer/locales/zh.json
index a6969f7..2ceec0d 100644
--- a/src/renderer/locales/zh.json
+++ b/src/renderer/locales/zh.json
@@ -562,5 +562,6 @@
   "cockpit.image_attached_marked": "已将标注后的图片附加到会话",
   "cockpit.image_attach_failed": "无法附加图片 — 没有向会话输入任何内容。",
   "set.quick_replies": "快捷回复",
-  "set.quick_replies_hint": "每行一条，最多 9 条。用会话顶部的 💬 按钮或在终端中按 Ctrl+Shift+1…9 发送。留空则使用默认文案。"
+  "set.quick_replies_hint": "每行一条，最多 9 条。用会话顶部的 💬 按钮或在终端中按 Ctrl+Shift+1…9 发送。留空则使用默认文案。",
+  "cockpit.timeline_host_too_old": "该电脑上的 DevDeck 版本过旧，无法显示时间线 — 请更新到 1.41.0。"
 }
diff --git a/src/renderer/machineDeck.test.ts b/src/renderer/machineDeck.test.ts
index a8af8ae..9933f30 100644
--- a/src/renderer/machineDeck.test.ts
+++ b/src/renderer/machineDeck.test.ts
@@ -54,3 +54,32 @@ describe('machine selection lifecycle', () => {
     expect(listener).toHaveBeenCalledOnce();
   });
 });
+
+describe('a paired PC on an older DevDeck', () => {
+  const olderHost = () => {
+    const missing = (name: string) => vi.fn().mockRejectedValue(new Error(`no such method: ${name}`));
+    vi.stubGlobal('window', { devdeck: { machine: () => ({ cockpit: {
+      sessionTurns: missing('cockpit:sessionTurns'),
+      receiveFile: missing('cockpit:receiveFile'),
+      sessionImages: missing('cockpit:sessionImages'),
+    } }) } });
+  };
+
+  it('says the timeline needs that PC updated, rather than showing an empty one', async () => {
+    olderHost();
+    const deck = await import('./machineDeck.js');
+    await expect(deck.deckFor('remote').cockpit.sessionTurns('/p', 's', 'claude')).rejects.toThrow(deck.HOST_TOO_OLD);
+  });
+
+  it('passes a missing receiveFile on, so the sender can say why a document did not go', async () => {
+    olderHost();
+    const deck = await import('./machineDeck.js');
+    await expect(deck.deckFor('remote').cockpit.receiveFile('a.log', 'eA==')).rejects.toThrow(/no such method/);
+  });
+
+  it('keeps an older host\'s missing image methods quiet, as before', async () => {
+    olderHost();
+    const deck = await import('./machineDeck.js');
+    await expect(deck.deckFor('remote').cockpit.sessionImages('/p', 's', 'claude')).resolves.toEqual([]);
+  });
+});
diff --git a/src/renderer/machineDeck.ts b/src/renderer/machineDeck.ts
index b63982d..eee4512 100644
--- a/src/renderer/machineDeck.ts
+++ b/src/renderer/machineDeck.ts
@@ -15,6 +15,8 @@ import { LOCAL_MACHINE_ID, parseRemoteId } from '../shared/link/machine';
 import type { MachineStatus } from '../main/link/linkService';
 
 export { LOCAL_MACHINE_ID };
+/** The error a call to another machine fails with when that machine's DevDeck predates the method. */
+export const HOST_TOO_OLD = 'host-too-old';
 
 /** The subset of the deck API the views actually call. Local and remote both satisfy it. */
 export interface DeckFacade {
@@ -107,7 +109,12 @@ export function deckFor(machineId: string): DeckFacade {
       receiveImage: (base64) => remote.cockpit.receiveImage(base64),
       // An older host has no receiveFile: its 'no such method' is passed on, so the sender can say why.
       receiveFile: (name, base64) => remote.cockpit.receiveFile(name, base64),
-      sessionTurns: (projectPath, sessionId, agentId) => remote.cockpit.sessionTurns(projectPath, sessionId, agentId).catch(() => []),
+      // A host older than the timeline is said so (the panel tells the person to update it); any other
+      // failure is an empty list for now, read again on the next turn.
+      sessionTurns: (projectPath, sessionId, agentId) => remote.cockpit.sessionTurns(projectPath, sessionId, agentId).catch((error: unknown) => {
+        if (/no such method/.test(error instanceof Error ? error.message : String(error))) throw new Error(HOST_TOO_OLD);
+        return [];
+      }),
       // A host older than the image panel has no such method; it simply has no images to show.
       sessionImages: (projectPath, sessionId, agentId) => remote.cockpit.sessionImages(projectPath, sessionId, agentId).catch(() => []),
       sessionImage: (projectPath, sessionId, imageId, size) => remote.cockpit.sessionImage(projectPath, sessionId, imageId, size).catch(() => null),
diff --git a/src/renderer/timeline.ts b/src/renderer/timeline.ts
index 01e1818..5ca07bc 100644
--- a/src/renderer/timeline.ts
+++ b/src/renderer/timeline.ts
@@ -11,6 +11,7 @@ import { imagesByTurn } from '../shared/timeline';
 import { tr } from './i18n-runtime';
 import { createIcon } from './icons';
 import { toast } from './loadError';
+import { HOST_TOO_OLD } from './machineDeck';
 
 export interface TimelineSource {
   /** Stable per session, like the image strip's. */
@@ -30,6 +31,8 @@ let host: HTMLElement | null = null;
 let panel: HTMLElement | null = null;
 let source: TimelineSource | null = null;
 let turns: SessionTurn[] = [];
+/** The session's machine runs a DevDeck older than the timeline. */
+let hostTooOld = false;
 let open = readOpenPref();
 let seq = 0;
 let onToggle: () => void = () => {};
@@ -65,6 +68,7 @@ export function showTimelineFor(next: TimelineSource | null): void {
   if (next?.key === source?.key) { source = next; return; }
   source = next;
   turns = [];
+  hostTooOld = false;
   render();
   if (open) void refreshTimeline();
 }
@@ -75,8 +79,14 @@ export async function refreshTimeline(): Promise<void> {
   if (!src || !open) return;
   const my = ++seq;
   let list: SessionTurn[];
-  try { list = await src.turns(); } catch { return; }
+  try { list = await src.turns(); }
+  catch (error) {
+    if (my !== seq || src.key !== source?.key) return;
+    if (error instanceof Error && error.message === HOST_TOO_OLD) { hostTooOld = true; render(); }
+    return;
+  }
   if (my !== seq || src.key !== source?.key) return;
+  hostTooOld = false;
   turns = list;
   render();
 }
@@ -101,7 +111,8 @@ function render(): void {
   head.append(title, close);
   const list = document.createElement('ol'); list.className = 'ck-tl-list';
   if (turns.length === 0) {
-    const empty = document.createElement('li'); empty.className = 'ck-tl-empty'; empty.textContent = tr('cockpit.timeline_empty');
+    const empty = document.createElement('li'); empty.className = 'ck-tl-empty';
+    empty.textContent = tr(hostTooOld ? 'cockpit.timeline_host_too_old' : 'cockpit.timeline_empty');
     list.appendChild(empty);
   }
   const rows = turns.length ? src.locate(turns) : new Map<string, number>();