cli-link 0.0.6 → 0.0.8

package/dist/server/index.js

@@ -3,11 +3,12 @@ import { createServer as createHttpsServer } from 'https';
 import { WebSocketServer, WebSocket } from 'ws';
 import { CLIManager } from './cli-manager.js';
 import { renderTerminalQr } from './terminal-qr.js';
+import { syncCodexHistory } from './codex-history.js';
 import * as store from './store.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import { timingSafeEqual } from 'crypto';
+import { createHash, randomUUID, timingSafeEqual } from 'crypto';
 import { execFileSync } from 'child_process';
 import { fileURLToPath } from 'url';
 const PORT = parseInt(process.env.PORT || '3101', 10);
@@ -104,6 +105,119 @@ server.on('upgrade', (req, socket, head) => {
 });
 const cliManager = new CLIManager();
 const clients = new Set();
+let promptQueue = [];
+let promptQueuePaused = false;
+let promptQueueIdCounter = 0;
+let promptQueueDispatching = false;
+let promptQueueHoldUntil = 0;
+let promptQueueDrainTimer = null;
+const PROMPT_QUEUE_IDLE_SETTLE_MS = 800;
+function getPromptQueuePayload() {
+    return {
+        promptQueue: promptQueue.map(item => ({ ...item })),
+        promptQueuePaused,
+    };
+}
+function broadcastPromptQueueChanged() {
+    broadcast({
+        type: 'prompt_queue_changed',
+        ...getPromptQueuePayload(),
+        time: now(),
+    });
+}
+function clearPromptQueue() {
+    promptQueue = [];
+    promptQueuePaused = false;
+    promptQueueDispatching = false;
+    promptQueueHoldUntil = 0;
+    if (promptQueueDrainTimer) {
+        clearTimeout(promptQueueDrainTimer);
+        promptQueueDrainTimer = null;
+    }
+    broadcastPromptQueueChanged();
+}
+function hasPromptPayload(prompt) {
+    return !!prompt.content.trim() || prompt.attachments.length > 0;
+}
+function dispatchPromptToCli(prompt) {
+    if (!hasPromptPayload(prompt))
+        return;
+    cliManager.sendInput({
+        content: prompt.content,
+        attachments: prompt.attachments,
+    });
+    broadcast({
+        type: 'user_message',
+        content: prompt.content,
+        attachments: prompt.attachments,
+        details: prompt.attachments.length > 0 ? { attachments: prompt.attachments } : undefined,
+        time: now(),
+    });
+}
+function maybeDrainPromptQueue() {
+    const holdMs = promptQueueHoldUntil - Date.now();
+    if (holdMs > 0) {
+        schedulePromptQueueDrain(holdMs);
+        return;
+    }
+    if (promptQueueDispatching ||
+        promptQueuePaused ||
+        cliManager.status !== 'idle' ||
+        promptQueue.length === 0) {
+        return;
+    }
+    const nextPrompt = promptQueue.shift();
+    if (!nextPrompt)
+        return;
+    promptQueueDispatching = true;
+    broadcastPromptQueueChanged();
+    dispatchPromptToCli(nextPrompt);
+}
+function schedulePromptQueueDrain(delayMs) {
+    if (promptQueueDrainTimer)
+        clearTimeout(promptQueueDrainTimer);
+    promptQueueDrainTimer = setTimeout(() => {
+        promptQueueDrainTimer = null;
+        maybeDrainPromptQueue();
+    }, Math.max(0, delayMs));
+}
+function shouldQueueIncomingPrompt() {
+    return (promptQueue.length > 0 ||
+        promptQueuePaused ||
+        promptQueueDispatching ||
+        promptQueueHoldUntil > Date.now() ||
+        cliManager.status !== 'idle');
+}
+function enqueuePrompt(prompt) {
+    if (!hasPromptPayload(prompt))
+        return;
+    promptQueueIdCounter += 1;
+    promptQueue.push({
+        id: `queued-${Date.now()}-${promptQueueIdCounter}`,
+        content: prompt.content,
+        attachments: prompt.attachments,
+    });
+    broadcastPromptQueueChanged();
+    maybeDrainPromptQueue();
+}
+function removePromptFromQueue(id) {
+    const nextQueue = promptQueue.filter(item => item.id !== id);
+    if (nextQueue.length === promptQueue.length)
+        return;
+    promptQueue = nextQueue;
+    if (promptQueue.length === 0) {
+        promptQueuePaused = false;
+        promptQueueDispatching = false;
+    }
+    broadcastPromptQueueChanged();
+}
+function resumePromptQueue() {
+    if (!promptQueuePaused)
+        return;
+    promptQueuePaused = false;
+    broadcastPromptQueueChanged();
+    maybeDrainPromptQueue();
+}
 function unquoteMetaValue(value) {
     const trimmed = value.trim();
     if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
@@ -238,6 +352,17 @@ function parseJsonField(raw) {
         return undefined;
     }
 }
+function toClientAttachments(raw) {
+    try {
+        return normalizePromptAttachments(raw, {
+            maxBytes: MAX_GENERATED_IMAGE_ATTACHMENT_BYTES,
+            maxCount: MAX_GENERATED_IMAGE_ATTACHMENTS_PER_TURN,
+        });
+    }
+    catch {
+        return [];
+    }
+}
 function getSessionConfig(session) {
     const parsed = parseJsonField(session?.cli_config);
     return parsed && typeof parsed === 'object' ? parsed : {};
@@ -271,6 +396,7 @@ function toClientMessage(m) {
         return null;
     const parsedDetails = parseJsonField(m.details);
     const isQuestion = mappedType === 'question' && m.type === 'ask_question';
+    const attachments = toClientAttachments(parsedDetails?.attachments);
     return {
         seq: m.seq,
         id: m.id,
@@ -284,12 +410,64 @@ function toClientMessage(m) {
         toolResult: m.toolResult || undefined,
         permission: parseJsonField(m.permission),
         details: parsedDetails,
+        attachments: attachments.length > 0 ? attachments : undefined,
         question: isQuestion && parsedDetails ? { questions: parsedDetails.questions || [], toolUseId: parsedDetails.toolUseId } : undefined,
     };
 }
 function toClientMessages(messages) {
     return messages.map(toClientMessage).filter((m) => m !== null);
 }
+function cleanHistoryPreview(content, maxLength = 96) {
+    const normalized = content
+        .replace(/```[\s\S]*?```/g, ' 代码片段 ')
+        .replace(/`([^`]+)`/g, '$1')
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+        .replace(/^#+\s*/gm, '')
+        .replace(/[>*_~]/g, ' ')
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(Boolean)
+        .join(' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!normalized)
+        return '';
+    return normalized.length > maxLength ? `${normalized.slice(0, maxLength).trimEnd()}...` : normalized;
+}
+function buildHistoryPreview(messages) {
+    const recentFirst = [...messages].sort((a, b) => b.seq - a.seq);
+    const preferredTypes = new Set(['user', 'ai', 'question', 'confirm', 'error']);
+    const fallbackTypes = new Set(['tool', 'system', 'thinking']);
+    const labels = {
+        user: '你',
+        ai: 'AI',
+        question: '问题',
+        confirm: '确认',
+        error: '错误',
+        tool: '工具',
+        system: '系统',
+        thinking: '思考',
+    };
+    const pick = (allowedTypes) => {
+        for (const raw of recentFirst) {
+            const msg = toClientMessage(raw);
+            if (!msg || !allowedTypes.has(msg.type))
+                continue;
+            const attachmentCount = Array.isArray(msg.attachments) ? msg.attachments.length : 0;
+            const snippet = cleanHistoryPreview(msg.content) || (attachmentCount > 0 ? `图片附件 ${attachmentCount} 张` : '');
+            if (!snippet)
+                continue;
+            const label = labels[msg.type] || '消息';
+            return {
+                preview: `${label}：${snippet}`,
+                lastMessageType: msg.type,
+            };
+        }
+        return {};
+    };
+    const preferred = pick(preferredTypes);
+    return preferred.preview ? preferred : pick(fallbackTypes);
+}
 function readPositiveInt(value, fallback = 0) {
     const parsed = Number(value || 0);
     if (!Number.isFinite(parsed) || parsed <= 0)
@@ -389,11 +567,16 @@ function buildEditPrompt(prefixMessages, editedContent) {
 }
 function toClientHistoryTask(t, includeMessages = false) {
     const cliSessionId = getRestorableCliSessionId(t.session_id, t.messages);
+    const summaryMessages = t.messages || (t.session_id ? store.getRecentSessionMessages(t.session_id, 32) : []);
+    const summary = buildHistoryPreview(summaryMessages);
     const response = {
         id: t.id,
         workDir: t.work_dir || undefined,
         status: t.status,
         title: t.title,
+        preview: summary.preview,
+        lastMessageType: summary.lastMessageType,
+        messageCount: t.messages ? t.messages.length : (t.session_id ? store.getMessageCount(t.session_id) : 0),
         confirmCount: t.confirm_count,
         toolCount: t.tool_count,
         duration: t.duration || undefined,
@@ -414,6 +597,26 @@ function toClientWorkDir(item) {
         createdAt: item.created_at,
     };
 }
+function toClientPromptHistoryItem(item) {
+    return {
+        id: item.id,
+        workDir: item.work_dir || undefined,
+        text: item.text,
+        useCount: item.use_count,
+        lastUsedAt: item.last_used_at,
+        createdAt: item.created_at,
+    };
+}
+function normalizeHistoryScope(value, fallback = 'global') {
+    return value === 'current' || value === 'project' ? 'current' : fallback;
+}
+function getHistoryWorkDirForScope(scope) {
+    return scope === 'current' ? getCurrentWorkDir() : null;
+}
+function getCurrentHistoryWorkDir() {
+    const workDir = getCurrentWorkDir();
+    return typeof workDir === 'string' && workDir.trim() ? workDir : null;
+}
 function getCurrentWorkDir() {
     return cliManager.getConfig().workDir;
 }
@@ -436,7 +639,15 @@ const WORKSPACE_SKIP_NAMES = new Set([
 ]);
 const MAX_FILE_BYTES = 512 * 1024;
 const MAX_DIFF_BYTES = 1024 * 1024;
-const MAX_COMMIT_CONTEXT_BYTES = 160 * 1024;
+const MAX_COMMIT_CONTEXT_BYTES = 96 * 1024;
+const MAX_COMMIT_DIFF_BYTES = 64 * 1024;
+const COMMIT_MESSAGE_CACHE_TTL_MS = 5 * 60 * 1000;
+const MAX_IMAGE_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+const MAX_GENERATED_IMAGE_ATTACHMENT_BYTES = 30 * 1024 * 1024;
+const MAX_GENERATED_IMAGE_ATTACHMENTS_PER_TURN = 8;
+const MAX_IMAGE_ATTACHMENTS_PER_PROMPT = 4;
+const ATTACHMENT_ROOT = path.join(os.homedir(), '.agentpilot', 'attachments');
+const CODEX_GENERATED_IMAGES_ROOT = path.join(resolveEnvPath(process.env.CODEX_HOME || '~/.codex'), 'generated_images');
 const PREVIEW_IMAGE_MIME_BY_EXTENSION = {
     '.avif': 'image/avif',
     '.bmp': 'image/bmp',
@@ -448,6 +659,281 @@ const PREVIEW_IMAGE_MIME_BY_EXTENSION = {
     '.svg': 'image/svg+xml',
     '.webp': 'image/webp',
 };
+const ATTACHMENT_EXTENSION_BY_MIME = {
+    'image/avif': 'avif',
+    'image/bmp': 'bmp',
+    'image/gif': 'gif',
+    'image/jpeg': 'jpg',
+    'image/png': 'png',
+    'image/webp': 'webp',
+};
+let generatedImageCapture = null;
+function normalizeImageMime(raw) {
+    const mime = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
+    return ATTACHMENT_EXTENSION_BY_MIME[mime] ? mime : '';
+}
+function sanitizeAttachmentName(raw, fallback = 'image') {
+    const base = path.basename(typeof raw === 'string' && raw.trim() ? raw.trim() : fallback);
+    return base.replace(/[\r\n"\\/:*?<>|\x00-\x1F]+/g, '_').slice(0, 120) || fallback;
+}
+function ensureAttachmentRoot() {
+    fs.mkdirSync(ATTACHMENT_ROOT, { recursive: true });
+}
+function assertAttachmentPath(rawPath) {
+    if (typeof rawPath !== 'string' || !rawPath.trim()) {
+        throw new Error('附件路径无效');
+    }
+    ensureAttachmentRoot();
+    const resolvedRoot = fs.realpathSync(ATTACHMENT_ROOT);
+    const resolvedPath = path.resolve(rawPath);
+    const realPath = fs.realpathSync(resolvedPath);
+    if (realPath !== resolvedRoot && !realPath.startsWith(`${resolvedRoot}${path.sep}`)) {
+        throw new Error('附件路径不在允许目录内');
+    }
+    return realPath;
+}
+function normalizePromptAttachments(rawAttachments, options = {}) {
+    if (!Array.isArray(rawAttachments))
+        return [];
+    const maxBytes = options.maxBytes ?? MAX_IMAGE_ATTACHMENT_BYTES;
+    const maxCount = options.maxCount ?? MAX_IMAGE_ATTACHMENTS_PER_PROMPT;
+    return rawAttachments.slice(0, maxCount).map((raw, index) => {
+        if (!raw || typeof raw !== 'object') {
+            throw new Error('附件格式无效');
+        }
+        const item = raw;
+        const filePath = assertAttachmentPath(item.path);
+        const stat = fs.statSync(filePath);
+        if (!stat.isFile())
+            throw new Error('附件不是文件');
+        if (stat.size > maxBytes)
+            throw new Error('图片附件过大');
+        const mimeType = normalizeImageMime(item.mimeType) || getPreviewImageMime(filePath) || '';
+        if (!mimeType || !ATTACHMENT_EXTENSION_BY_MIME[mimeType]) {
+            throw new Error('仅支持图片附件');
+        }
+        return {
+            id: typeof item.id === 'string' && item.id ? item.id : `attachment-${index + 1}`,
+            type: 'image',
+            name: sanitizeAttachmentName(item.name, path.basename(filePath)),
+            mimeType,
+            size: stat.size,
+            path: filePath,
+            createdAt: typeof item.createdAt === 'number' && Number.isFinite(item.createdAt) ? item.createdAt : stat.mtimeMs,
+        };
+    });
+}
+function normalizePromptPayload(raw) {
+    const content = typeof raw === 'string'
+        ? raw
+        : typeof raw?.content === 'string'
+            ? raw.content
+            : '';
+    const attachments = normalizePromptAttachments(typeof raw === 'object' && raw ? raw.attachments : undefined);
+    return { content, attachments };
+}
+function parseImageUploadBody(body) {
+    const dataUrl = typeof body?.dataUrl === 'string' ? body.dataUrl : '';
+    const dataUrlMatch = dataUrl.match(/^data:([^;,]+);base64,(.*)$/s);
+    const name = sanitizeAttachmentName(body?.name, 'image');
+    const mimeType = normalizeImageMime(body?.mimeType || body?.type || dataUrlMatch?.[1])
+        || normalizeImageMime(getPreviewImageMime(name));
+    const base64 = typeof body?.data === 'string' ? body.data : dataUrlMatch?.[2] || '';
+    if (!mimeType)
+        throw new Error('仅支持图片附件');
+    if (!base64)
+        throw new Error('图片数据为空');
+    const buffer = Buffer.from(base64, 'base64');
+    if (buffer.length === 0)
+        throw new Error('图片数据为空');
+    if (buffer.length > MAX_IMAGE_ATTACHMENT_BYTES)
+        throw new Error('图片不能超过 10MB');
+    return {
+        buffer,
+        mimeType,
+        name,
+    };
+}
+function saveImageAttachment(body) {
+    const { buffer, mimeType, name } = parseImageUploadBody(body);
+    const sessionDir = currentSessionId || 'draft';
+    const dir = path.join(ATTACHMENT_ROOT, sessionDir);
+    fs.mkdirSync(dir, { recursive: true });
+    const id = randomUUID();
+    const ext = ATTACHMENT_EXTENSION_BY_MIME[mimeType];
+    const filePath = path.join(dir, `${Date.now()}-${id}.${ext}`);
+    fs.writeFileSync(filePath, buffer, { flag: 'wx' });
+    return {
+        id,
+        type: 'image',
+        name,
+        mimeType,
+        size: buffer.length,
+        path: filePath,
+        createdAt: Date.now(),
+    };
+}
+function listGeneratedImageFiles() {
+    const files = [];
+    function walk(dir, depth) {
+        if (depth > 4)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const entryPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(entryPath, depth + 1);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const mimeType = getPreviewImageMime(entryPath);
+            if (mimeType && ATTACHMENT_EXTENSION_BY_MIME[mimeType]) {
+                files.push(path.resolve(entryPath));
+            }
+        }
+    }
+    walk(CODEX_GENERATED_IMAGES_ROOT, 0);
+    return files;
+}
+function maybeStartGeneratedImageCapture() {
+    if (generatedImageCapture)
+        return;
+    if (cliManager.getConfig().cliType !== 'codex')
+        return;
+    generatedImageCapture = {
+        startedAt: Date.now(),
+        baseline: new Set(listGeneratedImageFiles()),
+    };
+}
+function copyGeneratedImageToAttachment(sourcePath, index) {
+    const mimeType = getPreviewImageMime(sourcePath);
+    if (!mimeType || !ATTACHMENT_EXTENSION_BY_MIME[mimeType])
+        return null;
+    let sourceStat;
+    try {
+        sourceStat = fs.statSync(sourcePath);
+    }
+    catch {
+        return null;
+    }
+    if (!sourceStat.isFile() || sourceStat.size <= 0 || sourceStat.size > MAX_GENERATED_IMAGE_ATTACHMENT_BYTES) {
+        return null;
+    }
+    const id = randomUUID();
+    const ext = ATTACHMENT_EXTENSION_BY_MIME[mimeType];
+    const dir = path.join(ATTACHMENT_ROOT, currentSessionId || 'generated', 'generated');
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = path.join(dir, `${Date.now()}-${id}.${ext}`);
+    try {
+        fs.copyFileSync(sourcePath, filePath, fs.constants.COPYFILE_EXCL);
+    }
+    catch (err) {
+        console.warn(`[Attachments] Failed to copy generated image ${sourcePath}: ${err?.message || err}`);
+        return null;
+    }
+    const stat = fs.statSync(filePath);
+    return {
+        id,
+        type: 'image',
+        name: `generated-image-${index + 1}.${ext}`,
+        mimeType,
+        size: stat.size,
+        path: filePath,
+        createdAt: Date.now(),
+    };
+}
+function collectGeneratedImageAttachments(finish) {
+    const capture = generatedImageCapture;
+    if (!capture)
+        return [];
+    const minMtime = capture.startedAt - 5000;
+    const candidates = listGeneratedImageFiles()
+        .map((filePath) => {
+        try {
+            return { filePath, stat: fs.statSync(filePath) };
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((item) => !!item &&
+        item.stat.isFile() &&
+        item.stat.size > 0 &&
+        item.stat.size <= MAX_GENERATED_IMAGE_ATTACHMENT_BYTES &&
+        !capture.baseline.has(item.filePath) &&
+        item.stat.mtimeMs >= minMtime)
+        .sort((a, b) => a.stat.mtimeMs - b.stat.mtimeMs)
+        .slice(-MAX_GENERATED_IMAGE_ATTACHMENTS_PER_TURN);
+    const attachments = candidates
+        .map((candidate, index) => copyGeneratedImageToAttachment(candidate.filePath, index))
+        .filter((item) => item !== null);
+    if (attachments.length > 0 || finish) {
+        generatedImageCapture = null;
+    }
+    return attachments;
+}
+function attachGeneratedImagesToEvent(event) {
+    if (event.type !== 'system' || event.details?.subtype !== 'result')
+        return [];
+    const attachments = collectGeneratedImageAttachments(false);
+    if (attachments.length === 0)
+        return [];
+    event.details = {
+        ...(event.details || {}),
+        attachments: [
+            ...toClientAttachments(event.details?.attachments),
+            ...attachments,
+        ],
+    };
+    event.attachments = event.details.attachments;
+    return attachments;
+}
+function emitGeneratedImagesFallback() {
+    const attachments = collectGeneratedImageAttachments(true);
+    if (attachments.length === 0)
+        return;
+    broadcast({
+        type: 'system',
+        content: '生成图片',
+        time: now(),
+        details: {
+            subtype: 'result',
+            attachments,
+        },
+        attachments,
+    });
+}
+function sendAttachmentFile(req, res, rawPath) {
+    const filePath = assertAttachmentPath(rawPath);
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile()) {
+        sendJson(res, 404, { error: '附件不存在' });
+        return;
+    }
+    const mimeType = getPreviewImageMime(filePath);
+    if (!mimeType || !ATTACHMENT_EXTENSION_BY_MIME[mimeType]) {
+        sendJson(res, 415, { error: '仅支持图片附件预览' });
+        return;
+    }
+    setCorsHeaders(res);
+    res.writeHead(200, {
+        'Content-Type': mimeType,
+        'Content-Length': String(stat.size),
+        'Cache-Control': 'private, max-age=3600',
+    });
+    if (req.method === 'HEAD') {
+        res.end();
+        return;
+    }
+    fs.createReadStream(filePath).pipe(res);
+}
 function decodeGitOctalPath(raw) {
     return raw.replace(/(?:\\[0-7]{3})+/g, (sequence) => {
         const bytes = sequence.match(/\\([0-7]{3})/g)?.map(item => parseInt(item.slice(1), 8)) || [];
@@ -621,6 +1107,28 @@ function runGit(args, allowExitCodes = [0]) {
         throw new Error(stderr || err?.message || 'Git 命令执行失败');
     }
 }
+function getCurrentGitInfo() {
+    try {
+        const insideWorkTree = runGit(['rev-parse', '--is-inside-work-tree'], [0, 128]).trim() === 'true';
+        if (!insideWorkTree)
+            return { isGitRepo: false, gitBranch: '' };
+        const branch = runGit(['rev-parse', '--abbrev-ref', 'HEAD'], [0, 128]).trim();
+        if (branch && branch !== 'HEAD') {
+            return { isGitRepo: true, gitBranch: branch };
+        }
+        const shortHash = runGit(['rev-parse', '--short', 'HEAD'], [0, 128]).trim();
+        return { isGitRepo: true, gitBranch: shortHash ? `HEAD ${shortHash}` : branch || 'HEAD' };
+    }
+    catch {
+        return { isGitRepo: false, gitBranch: '' };
+    }
+}
+function getClientConfig() {
+    return {
+        ...cliManager.getConfig(),
+        ...getCurrentGitInfo(),
+    };
+}
 function unquoteGitPath(raw) {
     const trimmed = raw.trim();
     if (!trimmed.startsWith('"') || !trimmed.endsWith('"'))
@@ -663,6 +1171,8 @@ function parseGitStatus(output, nulTerminated = false) {
             const indexStatus = line[0] || ' ';
             const worktreeStatus = line[1] || ' ';
             const filePath = line.slice(3);
+            const isMoved = indexStatus === 'R' || indexStatus === 'C' || worktreeStatus === 'R' || worktreeStatus === 'C';
+            const oldPath = isMoved ? records[index + 1] : undefined;
             files.push({
                 path: filePath,
                 name: path.basename(filePath),
@@ -670,8 +1180,9 @@ function parseGitStatus(output, nulTerminated = false) {
                 indexStatus,
                 worktreeStatus,
                 label: describeGitStatus(indexStatus, worktreeStatus),
+                oldPath,
             });
-            if (indexStatus === 'R' || indexStatus === 'C' || worktreeStatus === 'R' || worktreeStatus === 'C') {
+            if (isMoved) {
                 index += 1;
             }
         }
@@ -683,7 +1194,9 @@ function parseGitStatus(output, nulTerminated = false) {
         const indexStatus = line[0] || ' ';
         const worktreeStatus = line[1] || ' ';
         const rawPath = line.slice(3);
-        const displayPath = rawPath.includes(' -> ') ? rawPath.split(' -> ').pop() || rawPath : rawPath;
+        const movedParts = rawPath.includes(' -> ') ? rawPath.split(' -> ') : [];
+        const displayPath = movedParts.length > 0 ? movedParts[movedParts.length - 1] || rawPath : rawPath;
+        const oldPath = movedParts.length > 1 ? unquoteGitPath(movedParts[0] || '') : undefined;
         const filePath = unquoteGitPath(displayPath);
         return {
             path: filePath,
@@ -692,9 +1205,88 @@ function parseGitStatus(output, nulTerminated = false) {
             indexStatus,
             worktreeStatus,
             label: describeGitStatus(indexStatus, worktreeStatus),
+            oldPath,
         };
     }).filter((item) => item !== null);
 }
+function emptyChangeStats() {
+    return { additions: 0, deletions: 0 };
+}
+function normalizeGitDiffPath(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed === '/dev/null')
+        return '';
+    return unquoteGitPath(trimmed.replace(/^[ab]\//, ''));
+}
+function rememberDiffStats(map, filePath) {
+    const normalized = normalizeGitDiffPath(filePath);
+    if (!normalized)
+        return null;
+    let stats = map.get(normalized);
+    if (!stats) {
+        stats = emptyChangeStats();
+        map.set(normalized, stats);
+    }
+    return stats;
+}
+function parseDiffStats(diff) {
+    const statsByPath = new Map();
+    let currentStats = null;
+    for (const line of diff.split('\n')) {
+        if (line.startsWith('diff --git ')) {
+            const parts = line.split(' ');
+            currentStats = rememberDiffStats(statsByPath, parts[3] || parts[2] || '');
+            continue;
+        }
+        if (line.startsWith('+++ ')) {
+            const nextPath = normalizeGitDiffPath(line.slice(4));
+            if (nextPath)
+                currentStats = rememberDiffStats(statsByPath, nextPath);
+            continue;
+        }
+        if (!currentStats)
+            continue;
+        if (line.startsWith('--- '))
+            continue;
+        if (line.startsWith('+')) {
+            currentStats.additions += 1;
+        }
+        else if (line.startsWith('-')) {
+            currentStats.deletions += 1;
+        }
+    }
+    return statsByPath;
+}
+function mergeStats(left, right) {
+    return {
+        additions: left.additions + right.additions,
+        deletions: left.deletions + right.deletions,
+    };
+}
+function countSmallTextFileLines(rawPath) {
+    try {
+        const { target } = resolveWorkspacePath(rawPath, true);
+        const stat = fs.statSync(target);
+        if (!stat.isFile() || stat.size > MAX_FILE_BYTES)
+            return null;
+        const buffer = fs.readFileSync(target);
+        if (buffer.includes(0))
+            return null;
+        const text = buffer.toString('utf8');
+        if (!text)
+            return 0;
+        const normalized = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        return normalized.endsWith('\n')
+            ? normalized.split('\n').length - 1
+            : normalized.split('\n').length;
+    }
+    catch {
+        return null;
+    }
+}
+function sumStats(values) {
+    return values.reduce((sum, stats) => mergeStats(sum, stats), emptyChangeStats());
+}
 function truncateText(text, maxBytes) {
     const buffer = Buffer.from(text, 'utf8');
     if (buffer.length <= maxBytes) {
@@ -855,8 +1447,23 @@ function getWorkspaceChanges(rawPath) {
             isGitRepo: false,
             branch: '',
             files: [],
+            summary: {
+                fileCount: 0,
+                stagedFileCount: 0,
+                unstagedFileCount: 0,
+                additions: 0,
+                deletions: 0,
+                stagedAdditions: 0,
+                stagedDeletions: 0,
+                unstagedAdditions: 0,
+                unstagedDeletions: 0,
+            },
             diff: '',
+            stagedDiff: '',
+            unstagedDiff: '',
             truncated: false,
+            stagedTruncated: false,
+            unstagedTruncated: false,
         };
     }
     const selectedPath = normalizeWorkspacePath(rawPath);
@@ -865,36 +1472,84 @@ function getWorkspaceChanges(rawPath) {
     }
     const branch = runGit(['rev-parse', '--abbrev-ref', 'HEAD']).trim();
     const statusOutput = runGit(['status', '--porcelain=v1', '-z', '--untracked-files=all', '--', '.']);
-    const files = parseGitStatus(statusOutput, true);
+    const rawFiles = parseGitStatus(statusOutput, true);
     const diffTarget = selectedPath || '.';
     const staged = runGit(['diff', '--cached', '--', diffTarget]);
-    const unstaged = runGit(['diff', '--', diffTarget]);
+    let unstaged = runGit(['diff', '--', diffTarget]);
     const parts = [];
     if (staged.trim())
         parts.push(`--- 已暂存变更 ---\n${staged}`);
     if (unstaged.trim())
         parts.push(`--- 未暂存变更 ---\n${unstaged}`);
     if (selectedPath && parts.length === 0) {
-        const selected = files.find(file => file.path === selectedPath);
+        const selected = rawFiles.find(file => file.path === selectedPath);
         if (selected?.status === '??') {
             const { target } = resolveWorkspacePath(selectedPath, true);
             const stat = fs.statSync(target);
             if (stat.isFile() && stat.size <= MAX_FILE_BYTES) {
                 const untrackedDiff = runGit(['diff', '--no-index', '--', '/dev/null', target], [0, 1]);
-                if (untrackedDiff.trim())
-                    parts.push(untrackedDiff);
+                if (untrackedDiff.trim()) {
+                    unstaged = untrackedDiff;
+                    parts.push(`--- 未暂存变更 ---\n${untrackedDiff}`);
+                }
             }
         }
     }
+    const stagedDiffResult = truncateText(staged, MAX_DIFF_BYTES);
+    const unstagedDiffResult = truncateText(unstaged, MAX_DIFF_BYTES);
+    const stagedStatsByPath = parseDiffStats(staged);
+    const unstagedStatsByPath = parseDiffStats(unstaged);
+    const files = rawFiles.map((file) => {
+        const stagedStats = stagedStatsByPath.get(file.path) || emptyChangeStats();
+        let unstagedStats = unstagedStatsByPath.get(file.path) || emptyChangeStats();
+        if (file.status === '??' && unstagedStats.additions === 0 && unstagedStats.deletions === 0) {
+            const additions = countSmallTextFileLines(file.path);
+            if (additions != null) {
+                unstagedStats = { additions, deletions: 0 };
+            }
+        }
+        const totalStats = mergeStats(stagedStats, unstagedStats);
+        const hasStaged = file.indexStatus !== ' ' && file.indexStatus !== '?' && file.indexStatus !== '!';
+        const hasUnstaged = file.status === '??' || (file.worktreeStatus !== ' ' && file.worktreeStatus !== '?' && file.worktreeStatus !== '!');
+        return {
+            ...file,
+            additions: totalStats.additions,
+            deletions: totalStats.deletions,
+            stagedAdditions: stagedStats.additions,
+            stagedDeletions: stagedStats.deletions,
+            unstagedAdditions: unstagedStats.additions,
+            unstagedDeletions: unstagedStats.deletions,
+            hasStaged,
+            hasUnstaged,
+        };
+    });
+    const stagedTotals = sumStats(files.map(file => ({ additions: file.stagedAdditions, deletions: file.stagedDeletions })));
+    const unstagedTotals = sumStats(files.map(file => ({ additions: file.unstagedAdditions, deletions: file.unstagedDeletions })));
+    const totalStats = mergeStats(stagedTotals, unstagedTotals);
     const diffResult = truncateText(parts.join('\n'), MAX_DIFF_BYTES);
     return {
         workDir: path.resolve(getCurrentWorkDir()),
         isGitRepo: true,
         branch,
         files,
+        summary: {
+            fileCount: files.length,
+            stagedFileCount: files.filter(file => file.hasStaged).length,
+            unstagedFileCount: files.filter(file => file.hasUnstaged).length,
+            additions: totalStats.additions,
+            deletions: totalStats.deletions,
+            stagedAdditions: stagedTotals.additions,
+            stagedDeletions: stagedTotals.deletions,
+            unstagedAdditions: unstagedTotals.additions,
+            unstagedDeletions: unstagedTotals.deletions,
+        },
         diff: diffResult.text,
+        stagedDiff: stagedDiffResult.text,
+        unstagedDiff: unstagedDiffResult.text,
         diffPath: selectedPath || undefined,
         truncated: diffResult.truncated,
+        stagedTruncated: stagedDiffResult.truncated,
+        unstagedTruncated: unstagedDiffResult.truncated,
     };
 }
 function trackWorkspaceFile(rawPath) {
@@ -972,6 +1627,41 @@ function unstageWorkspacePath(rawPath) {
         unstaged: true,
     };
 }
+function isSameOrNestedWorkspacePath(pathname, targetPath) {
+    return !!pathname && (pathname === targetPath || pathname.startsWith(`${targetPath}/`));
+}
+function discardWorkspaceChanges(rawPath) {
+    ensureWorkspaceGitRepo();
+    const selectedPath = normalizeWorkspacePath(rawPath);
+    if (selectedPath) {
+        resolveWorkspacePath(selectedPath, false);
+    }
+    const allStatusOutput = runGit(['status', '--porcelain=v1', '-z', '--untracked-files=all', '--', '.']);
+    const allFiles = parseGitStatus(allStatusOutput, true);
+    const files = selectedPath
+        ? allFiles.filter(file => isSameOrNestedWorkspacePath(file.path, selectedPath) ||
+            isSameOrNestedWorkspacePath(file.oldPath, selectedPath))
+        : allFiles;
+    if (files.length === 0) {
+        throw new Error(selectedPath ? '文件没有可清空的变更' : '没有可清空的代码变更');
+    }
+    const trackedFiles = files.filter(file => file.status !== '??');
+    if (trackedFiles.length > 0) {
+        const targets = selectedPath
+            ? Array.from(new Set(trackedFiles.flatMap(file => [file.path, file.oldPath].filter(Boolean))))
+            : ['.'];
+        runGit(['restore', '--source=HEAD', '--staged', '--worktree', '--', ...targets]);
+    }
+    const hasUntrackedFiles = files.some(file => file.status === '??');
+    if (hasUntrackedFiles) {
+        runGit(['clean', '-fd', '--', selectedPath || '.']);
+    }
+    return {
+        workDir: path.resolve(getCurrentWorkDir()),
+        path: selectedPath || undefined,
+        discarded: true,
+    };
+}
 function ensureWorkspaceGitRepo() {
     resolveWorkspacePath('', true);
     try {
@@ -993,52 +1683,98 @@ function normalizeAICommitMessage(rawMessage) {
     message = message.replace(/^["'“”‘’]+|["'“”‘’]+$/g, '').trim();
     return message.split('\n').map(line => line.replace(/^\s*[-*]\s+/, '').trimEnd()).join('\n').trim();
 }
+const commitMessageCache = new Map();
+function hashText(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function getCommitMessageCacheKey(workDir, diffHash) {
+    return `${workDir}\0${diffHash}`;
+}
+function getCachedCommitMessage(cacheKey) {
+    const entry = commitMessageCache.get(cacheKey);
+    if (!entry)
+        return null;
+    if (Date.now() - entry.createdAt > COMMIT_MESSAGE_CACHE_TTL_MS) {
+        commitMessageCache.delete(cacheKey);
+        return null;
+    }
+    return entry.message;
+}
+function setCachedCommitMessage(cacheKey, message) {
+    commitMessageCache.set(cacheKey, {
+        message,
+        createdAt: Date.now(),
+    });
+}
 function buildCommitMessagePrompt() {
     ensureWorkspaceGitRepo();
-    const statusOutput = runGit(['status', '--porcelain=v1', '-z', '--untracked-files=all', '--', '.']);
-    const files = parseGitStatus(statusOutput, true);
-    const statusText = files.map(file => `${file.status} ${file.path}`).join('\n');
-    if (files.length === 0) {
-        throw new Error('没有可提交的代码变更');
-    }
-    const stagedFiles = runGit(['diff', '--cached', '--name-only']);
-    if (!stagedFiles.trim()) {
+    const workDir = path.resolve(getCurrentWorkDir());
+    const branch = runGit(['rev-parse', '--abbrev-ref', 'HEAD']).trim();
+    const stagedNameStatus = runGit(['diff', '--cached', '--name-status', '--find-renames']).trim();
+    if (!stagedNameStatus) {
         throw new Error('没有已暂存的代码变更，请先暂存要提交的文件');
     }
-    const recentCommits = runGit(['log', '--oneline', '-8'], [0, 128]).trim();
-    const stagedStat = runGit(['diff', '--cached', '--stat']);
-    const stagedDiff = runGit(['diff', '--cached']);
+    const recentCommits = runGit(['log', '--oneline', '-5'], [0, 128]).trim();
+    const stagedNumstat = runGit(['diff', '--cached', '--numstat', '--find-renames']).trim();
+    const stagedStat = runGit(['diff', '--cached', '--stat']).trim();
+    const stagedSummary = runGit(['diff', '--cached', '--summary', '--find-renames']).trim();
+    const stagedDiffForHash = runGit(['diff', '--cached', '--full-index', '--binary']);
+    const stagedDiff = runGit(['diff', '--cached', '--find-renames', '--unified=3']);
+    const diffHash = hashText(stagedDiffForHash || stagedDiff || stagedNameStatus);
+    const diffContext = truncateText(stagedDiff.trim(), MAX_COMMIT_DIFF_BYTES);
     const context = truncateText([
-        `当前分支：${runGit(['rev-parse', '--abbrev-ref', 'HEAD']).trim()}`,
-        recentCommits ? `最近提交：\n${recentCommits}` : '',
-        `状态：\n${statusText}`,
-        stagedStat.trim() ? `已暂存统计：\n${stagedStat.trim()}` : '',
-        stagedDiff.trim() ? `已暂存 diff：\n${stagedDiff}` : '',
+        `当前分支：${branch}`,
+        recentCommits ? `最近提交风格：\n${recentCommits}` : '',
+        `已暂存文件：\n${stagedNameStatus}`,
+        stagedNumstat ? `已暂存增删行：\n${stagedNumstat}` : '',
+        stagedStat ? `已暂存统计：\n${stagedStat}` : '',
+        stagedSummary ? `已暂存摘要：\n${stagedSummary}` : '',
+        diffContext.text ? `已暂存 diff${diffContext.truncated ? ' 片段' : ''}：\n${diffContext.text}` : '',
     ].filter(Boolean).join('\n\n'), MAX_COMMIT_CONTEXT_BYTES);
-    return [
-        '请基于下面的 Git 变更生成一条提交信息。',
+    const prompt = [
+        '你是 commit message 生成器。只基于下面的“已暂存”Git 上下文生成一条提交信息。',
         '要求：',
+        '- 不要调用命令或工具，不要读取文件。',
         '- 只输出 commit message，不要解释，不要 Markdown 代码块。',
+        '- 只描述已暂存变更，不要描述未暂存或未跟踪内容。',
         '- 使用 Conventional Commits：<type>(<scope>): <subject> 或 <type>: <subject>。',
         '- type 优先使用 feat/fix/docs/refactor/test/chore/style/build/ci/perf。',
-        '- subject 简短、具体、动词开头，使用英文小写；必要时可以补充简短 body。',
+        '- scope 优先从文件路径、模块名和最近提交风格判断。',
+        '- subject 简短、具体、英文小写，尽量不超过 72 个字符；必要时可以补充 1-3 行 body。',
         '- 不要提到 AI、不要提到你无法验证的内容。',
         '',
-        context.truncated ? '注意：变更上下文已截断。' : '',
+        context.truncated || diffContext.truncated ? '注意：变更上下文已截断，请优先依据文件列表、统计和可见 diff。' : '',
         '已暂存 Git 变更上下文：',
         context.text,
     ].filter(Boolean).join('\n');
+    return {
+        prompt,
+        cacheKey: getCommitMessageCacheKey(workDir, diffHash),
+        diffHash,
+    };
 }
 async function generateWorkspaceCommitMessage() {
-    const prompt = buildCommitMessagePrompt();
-    const output = await cliManager.runOneShot(prompt, 120000);
+    const payload = buildCommitMessagePrompt();
+    const cachedMessage = getCachedCommitMessage(payload.cacheKey);
+    if (cachedMessage) {
+        return {
+            workDir: path.resolve(getCurrentWorkDir()),
+            message: cachedMessage,
+            cached: true,
+            diffHash: payload.diffHash,
+        };
+    }
+    const output = await cliManager.runOneShot(payload.prompt, 60000);
     const message = normalizeAICommitMessage(output);
     if (!message) {
         throw new Error('AI 未生成有效提交信息');
     }
+    setCachedCommitMessage(payload.cacheKey, message);
     return {
         workDir: path.resolve(getCurrentWorkDir()),
         message,
+        cached: false,
+        diffHash: payload.diffHash,
     };
 }
 function commitWorkspaceChanges(rawMessage) {
@@ -1394,6 +2130,10 @@ function getHistoryIdFromPath(pathname) {
     const match = pathname.match(/^\/api\/history\/([^/]+)$/);
     return match ? decodeURIComponent(match[1]) : null;
 }
+function getPromptHistoryIdFromPath(pathname) {
+    const match = pathname.match(/^\/api\/prompt-history\/([^/]+)$/);
+    return match ? decodeURIComponent(match[1]) : null;
+}
 function listSystemDir(rawDir, includeFiles) {
     const baseDir = typeof rawDir === 'string' && rawDir ? rawDir : '~';
     const dir = baseDir.startsWith('~') ? baseDir.replace('~', os.homedir()) : baseDir;
@@ -1476,7 +2216,7 @@ async function handleHttpRequest(req, res) {
     try {
         if (req.method === 'GET' && pathname === '/api/config') {
             sendJson(res, 200, {
-                config: cliManager.getConfig(),
+                config: getClientConfig(),
                 status: cliManager.status,
                 sessionId: currentSessionId,
                 time: now(),
@@ -1516,24 +2256,58 @@ async function handleHttpRequest(req, res) {
             return;
         }
         if (req.method === 'GET' && pathname === '/api/history') {
-            const tasks = store.getHistoryTasks({ workDir: getCurrentWorkDir() });
+            const workDir = getCurrentHistoryWorkDir();
+            const tasks = workDir ? store.getHistoryTasks({ workDir }) : [];
             sendJson(res, 200, { tasks: tasks.map(task => toClientHistoryTask(task)) });
             return;
         }
+        if (req.method === 'GET' && pathname === '/api/prompt-history') {
+            const scope = normalizeHistoryScope(url.searchParams.get('scope'), 'current');
+            const prompts = store.getPromptHistory({
+                workDir: getHistoryWorkDirForScope(scope),
+                query: url.searchParams.get('query') || undefined,
+                limit: url.searchParams.get('limit') ? Number(url.searchParams.get('limit')) : undefined,
+            });
+            sendJson(res, 200, { prompts: prompts.map(toClientPromptHistoryItem) });
+            return;
+        }
+        if (req.method === 'POST' && pathname === '/api/codex-history/sync') {
+            const body = await readJsonBody(req);
+            const result = syncCodexHistory({
+                codexHome: process.env.AGENTPILOT_CODEX_HOME,
+                limit: body.limit,
+                workDir: getCurrentWorkDir(),
+            });
+            sendJson(res, 200, { result });
+            broadcast({ type: 'history_changed', time: now() });
+            return;
+        }
+        const promptHistoryId = getPromptHistoryIdFromPath(pathname);
+        if (promptHistoryId && req.method === 'DELETE') {
+            const scope = normalizeHistoryScope(url.searchParams.get('scope'), 'current');
+            store.deletePromptHistory(promptHistoryId, getHistoryWorkDirForScope(scope));
+            sendJson(res, 200, { id: promptHistoryId });
+            return;
+        }
         const historyId = getHistoryIdFromPath(pathname);
         if (historyId && req.method === 'GET') {
-            const task = store.getHistoryTask(historyId, getCurrentWorkDir());
+            const workDir = getCurrentHistoryWorkDir();
+            const task = workDir ? store.getHistoryTask(historyId, workDir) : null;
             sendJson(res, 200, { task: task ? toClientHistoryTask(task, true) : null });
             return;
         }
         if (historyId && req.method === 'DELETE') {
-            store.deleteHistoryTask(historyId, getCurrentWorkDir());
+            const workDir = getCurrentHistoryWorkDir();
+            if (workDir)
+                store.deleteHistoryTask(historyId, workDir);
             sendJson(res, 200, { id: historyId });
             broadcast({ type: 'history_changed', time: now() });
             return;
         }
         if (req.method === 'DELETE' && pathname === '/api/history') {
-            store.clearHistory(getCurrentWorkDir());
+            const workDir = getCurrentHistoryWorkDir();
+            if (workDir)
+                store.clearHistory(workDir);
             sendJson(res, 200, { success: true });
             broadcast({ type: 'history_changed', time: now() });
             return;
@@ -1549,6 +2323,15 @@ async function handleHttpRequest(req, res) {
             sendJson(res, 200, listSystemDir(url.searchParams.get('dir'), includeFiles));
             return;
         }
+        if (req.method === 'POST' && pathname === '/api/attachments/image') {
+            const body = await readJsonBody(req, MAX_IMAGE_ATTACHMENT_BYTES * 2);
+            sendJson(res, 200, { attachment: saveImageAttachment(body) });
+            return;
+        }
+        if ((req.method === 'GET' || req.method === 'HEAD') && pathname === '/api/attachments/file') {
+            sendAttachmentFile(req, res, url.searchParams.get('path') || '');
+            return;
+        }
         if (req.method === 'GET' && pathname === '/api/workdir/tree') {
             sendJson(res, 200, listWorkspaceDir(url.searchParams.get('path') || ''));
             return;
@@ -1588,6 +2371,11 @@ async function handleHttpRequest(req, res) {
             sendJson(res, 200, unstageWorkspacePath(body.path));
             return;
         }
+        if (req.method === 'POST' && pathname === '/api/workdir/discard') {
+            const body = await readJsonBody(req);
+            sendJson(res, 200, discardWorkspaceChanges(body.path));
+            return;
+        }
         if (req.method === 'POST' && pathname === '/api/workdir/commit-message') {
             sendJson(res, 200, await generateWorkspaceCommitMessage());
             return;
@@ -1677,6 +2465,14 @@ const PERSISTABLE_TYPES = new Set([
     'status',
 ]);
 function broadcast(event) {
+    if (event.type === 'status' && event.status === 'running') {
+        maybeStartGeneratedImageCapture();
+    }
+    attachGeneratedImagesToEvent(event);
+    if (event.type === 'status' && event.status !== 'idle') {
+        promptQueueDispatching = false;
+        promptQueueHoldUntil = 0;
+    }
     // Persist CLI session ID when we get it from system init or result
     if (currentSessionId && event.type === 'system' && event.details?.session_id) {
         try {
@@ -1757,6 +2553,14 @@ function broadcast(event) {
                 if (!event.id)
                     event.id = persisted.id;
                 event.seq = persisted.seq;
+                if (event.type === 'user_message') {
+                    store.recordPromptHistory({
+                        text: event.content || '',
+                        workDir: getCurrentWorkDir(),
+                        sessionId: currentSessionId,
+                        messageId: persisted.id,
+                    });
+                }
             }
         }
         catch (err) {
@@ -1773,16 +2577,25 @@ function broadcast(event) {
             catch { }
         }
     }
+    if (event.type === 'status' && event.status === 'idle') {
+        emitGeneratedImagesFallback();
+        promptQueueHoldUntil = Date.now() + PROMPT_QUEUE_IDLE_SETTLE_MS;
+        schedulePromptQueueDrain(PROMPT_QUEUE_IDLE_SETTLE_MS);
+    }
 }
 cliManager.setEventHandler(broadcast);
+if (cliManager.status === 'disconnected') {
+    cliManager.restoreReady();
+}
 wss.on('connection', (ws) => {
     clients.add(ws);
     console.log(`[WS] Client connected (total: ${clients.size})`);
     ws.send(JSON.stringify({
         type: 'connected',
-        config: cliManager.getConfig(),
+        config: getClientConfig(),
         status: cliManager.status,
         sessionId: currentSessionId,
+        ...getPromptQueuePayload(),
     }));
     ws.on('message', (data) => {
         let msg;
@@ -1813,6 +2626,7 @@ wss.on('connection', (ws) => {
 function handleMessage(ws, msg) {
     switch (msg.type) {
         case 'start_cli': {
+            clearPromptQueue();
             // Archive current session
             if (currentSessionId) {
                 store.archiveSession(currentSessionId, 'completed');
@@ -1836,20 +2650,40 @@ function handleMessage(ws, msg) {
             broadcast({
                 type: 'session_reset',
                 sessionId: currentSessionId,
-                config: cliManager.getConfig(),
+                config: getClientConfig(),
                 time: now(),
             });
             broadcast({ type: 'history_changed', time: now() });
             broadcast({ type: 'workdirs_changed', current: getCurrentWorkDir(), time: now() });
             break;
         }
-        case 'send_message':
-            cliManager.sendInput(msg.content);
-            broadcast({
-                type: 'user_message',
-                content: msg.content,
-                time: now(),
-            });
+        case 'send_message': {
+            const prompt = normalizePromptPayload(msg);
+            if (cliManager.status === 'disconnected') {
+                broadcast({ type: 'error', content: 'CLI 未连接，无法发送', time: now() });
+            }
+            else if (!hasPromptPayload(prompt)) {
+                broadcast({ type: 'error', content: '消息不能为空', time: now() });
+            }
+            else if (shouldQueueIncomingPrompt()) {
+                enqueuePrompt(prompt);
+            }
+            else {
+                dispatchPromptToCli(prompt);
+            }
+            break;
+        }
+        case 'queue_prompt':
+            enqueuePrompt(normalizePromptPayload(msg));
+            break;
+        case 'remove_queued_prompt':
+            removePromptFromQueue(msg.id);
+            break;
+        case 'clear_prompt_queue':
+            clearPromptQueue();
+            break;
+        case 'resume_prompt_queue':
+            resumePromptQueue();
             break;
         case 'confirm_response':
             cliManager.confirmResponse(msg.approved);
@@ -1858,9 +2692,14 @@ function handleMessage(ws, msg) {
             cliManager.questionResponse(msg.answer, msg.toolUseId);
             break;
         case 'interrupt':
+            if (promptQueue.length > 0) {
+                promptQueuePaused = true;
+                broadcastPromptQueueChanged();
+            }
             cliManager.interrupt();
             break;
         case 'restart_cli': {
+            clearPromptQueue();
             // Archive current session before restarting
             if (currentSessionId) {
                 const taskStatus = cliManager.status === 'running' || cliManager.status === 'confirm' ? 'running' :
@@ -1874,7 +2713,7 @@ function handleMessage(ws, msg) {
             broadcast({
                 type: 'session_reset',
                 sessionId: currentSessionId,
-                config: cliManager.getConfig(),
+                config: getClientConfig(),
                 time: now(),
             });
             broadcast({ type: 'history_changed', time: now() });
@@ -1892,7 +2731,7 @@ function handleMessage(ws, msg) {
         case 'get_config':
             ws.send(JSON.stringify({
                 type: 'config',
-                config: cliManager.getConfig(),
+                config: getClientConfig(),
                 status: cliManager.status,
                 sessionId: currentSessionId,
                 time: now(),
@@ -1935,7 +2774,8 @@ function handleMessage(ws, msg) {
         }
         // --- New protocol: History ---
         case 'get_history': {
-            const tasks = store.getHistoryTasks({ workDir: getCurrentWorkDir() });
+            const workDir = getCurrentHistoryWorkDir();
+            const tasks = workDir ? store.getHistoryTasks({ workDir }) : [];
             ws.send(JSON.stringify({
                 type: 'history_data',
                 requestId: msg.requestId,
@@ -1944,7 +2784,8 @@ function handleMessage(ws, msg) {
             break;
         }
         case 'get_history_task': {
-            const task = store.getHistoryTask(msg.id, getCurrentWorkDir());
+            const workDir = getCurrentHistoryWorkDir();
+            const task = workDir ? store.getHistoryTask(msg.id, workDir) : null;
             ws.send(JSON.stringify({
                 type: 'history_task_data',
                 requestId: msg.requestId,
@@ -1962,7 +2803,8 @@ function handleMessage(ws, msg) {
                 }));
                 break;
             }
-            const task = store.getHistoryTask(msg.id, getCurrentWorkDir());
+            const workDir = getCurrentHistoryWorkDir();
+            const task = workDir ? store.getHistoryTask(msg.id, workDir) : null;
             const cliSessionId = task ? getRestorableCliSessionId(task.session_id, task.messages) : undefined;
             if (!task || !task.session_id || !cliSessionId) {
                 ws.send(JSON.stringify({
@@ -1973,7 +2815,7 @@ function handleMessage(ws, msg) {
                 }));
                 break;
             }
-            const restored = store.resumeHistoryTask(msg.id, currentSessionId, getCurrentWorkDir());
+            const restored = store.resumeHistoryTask(msg.id, currentSessionId, workDir);
             if (!restored) {
                 ws.send(JSON.stringify({
                     type: 'history_resumed',
@@ -1988,6 +2830,9 @@ function handleMessage(ws, msg) {
                 ...getSessionConfig(restored.session),
                 cliSessionId,
             };
+            if (typeof restoredConfig.workDir !== 'string' && typeof restored.work_dir === 'string') {
+                restoredConfig.workDir = restored.work_dir;
+            }
             cliManager.restoreConfig(restoredConfig);
             cliManager.restoreSessionId(cliSessionId);
             if (typeof restoredConfig.workDir === 'string') {
@@ -2003,7 +2848,7 @@ function handleMessage(ws, msg) {
             broadcast({
                 type: 'session_restored',
                 sessionId: currentSessionId,
-                config: cliManager.getConfig(),
+                config: getClientConfig(),
                 status: cliManager.status,
                 messages: sessionMessages,
                 lastSeq,
@@ -2025,7 +2870,7 @@ function handleMessage(ws, msg) {
                 requestId: msg.requestId,
                 success: true,
                 sessionId: currentSessionId,
-                config: cliManager.getConfig(),
+                config: getClientConfig(),
                 messages: sessionMessages,
                 lastSeq,
                 sent: !!followUp,
@@ -2081,7 +2926,7 @@ function handleMessage(ws, msg) {
             broadcast({
                 type: 'session_restored',
                 sessionId: currentSessionId,
-                config: cliManager.getConfig(),
+                config: getClientConfig(),
                 status: cliManager.status,
                 messages: sessionMessages,
                 lastSeq,
@@ -2103,7 +2948,9 @@ function handleMessage(ws, msg) {
             break;
         }
         case 'delete_history': {
-            store.deleteHistoryTask(msg.id, getCurrentWorkDir());
+            const workDir = getCurrentHistoryWorkDir();
+            if (workDir)
+                store.deleteHistoryTask(msg.id, workDir);
             ws.send(JSON.stringify({
                 type: 'history_deleted',
                 requestId: msg.requestId,
@@ -2114,7 +2961,9 @@ function handleMessage(ws, msg) {
             break;
         }
         case 'clear_history': {
-            store.clearHistory(getCurrentWorkDir());
+            const workDir = getCurrentHistoryWorkDir();
+            if (workDir)
+                store.clearHistory(workDir);
             ws.send(JSON.stringify({
                 type: 'history_cleared',
                 requestId: msg.requestId,
@@ -2275,7 +3124,7 @@ function handleMessage(ws, msg) {
     }
 }
 function now() {
-    return new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+    return new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', hourCycle: 'h23' });
 }
 function formatHostForUrl(host) {
     return host.includes(':') && !host.startsWith('[') ? `[${host}]` : host;