clawt 2.11.0 → 2.11.1

package/.claude/agent-memory/docs-sync-updater/MEMORY.md

@@ -35,7 +35,9 @@
 - remove 批量操作时收集错误继续处理，最后汇总报告
 - 文档中文风格，技术术语保留英文（worktree, merge, branch, SIGINT 等）
 - cleanupWorktrees 是 merge 和 run 共用的公共清理函数（在 src/utils/worktree.ts）
-- `launchInteractiveClaude` 是 run（交互式模式）和 resume 共用的公共函数（在 src/utils/claude.ts）
+- `launchInteractiveClaude` 是 run（交互式模式）和 resume 共用的公共函数（在 src/utils/claude.ts），启动前自动检测会话历史并追加 `--continue`
+- `hasClaudeSessionHistory` 检测 `~/.claude/projects/<encoded-path>/` 下是否有 `.jsonl` 文件（在 src/utils/claude.ts）
+- `CLAUDE_PROJECTS_DIR` 常量（`~/.claude/projects/`）定义在 `src/constants/paths.ts`
 - killAllChildProcesses 是 run 专用的子进程终止函数（在 src/utils/shell.ts）
 - validate 快照管理函数在 `src/utils/validate-snapshot.ts`，被 validate、merge、remove 和 status 四个命令使用
 - `confirmDestructiveAction` 在 `src/utils/formatter.ts`，被 reset、validate --clean 和 config reset 使用

package/README.md

@@ -83,6 +83,8 @@ clawt resume -b <branch>   # 指定分支
 clawt resume                # 交互式选择
 ```
 
+如果目标 worktree 存在历史会话，会自动继续上次对话（`--continue`）。
+
 ### `clawt create` — 仅创建 worktree（不执行任务）
 
 ```bash

package/dist/index.js

@@ -14,6 +14,7 @@ var CONFIG_PATH = join(CLAWT_HOME, "config.json");
 var LOGS_DIR = join(CLAWT_HOME, "logs");
 var WORKTREES_DIR = join(CLAWT_HOME, "worktrees");
 var VALIDATE_SNAPSHOTS_DIR = join(CLAWT_HOME, "validate-snapshots");
+var CLAUDE_PROJECTS_DIR = join(homedir(), ".claude", "projects");
 
 // src/constants/branch.ts
 var INVALID_BRANCH_CHARS = /[\/\\.\s~:*?[\]^]+/g;
@@ -904,7 +905,21 @@ import Enquirer from "enquirer";
 
 // src/utils/claude.ts
 import { spawnSync } from "child_process";
-function launchInteractiveClaude(worktree) {
+import { existsSync as existsSync5, readdirSync as readdirSync3 } from "fs";
+import { join as join3 } from "path";
+function encodeClaudeProjectPath(absolutePath) {
+  return absolutePath.replace(/[^a-zA-Z0-9]/g, "-");
+}
+function hasClaudeSessionHistory(worktreePath) {
+  const encodedName = encodeClaudeProjectPath(worktreePath);
+  const projectDir = join3(CLAUDE_PROJECTS_DIR, encodedName);
+  if (!existsSync5(projectDir)) {
+    return false;
+  }
+  const entries = readdirSync3(projectDir);
+  return entries.some((entry) => entry.endsWith(".jsonl"));
+}
+function launchInteractiveClaude(worktree, options = {}) {
   const commandStr = getConfigValue("claudeCodeCommand");
   const parts = commandStr.split(/\s+/).filter(Boolean);
   const cmd = parts[0];
@@ -913,10 +928,17 @@ function launchInteractiveClaude(worktree) {
     "--append-system-prompt",
     APPEND_SYSTEM_PROMPT
   ];
+  const hasPreviousSession = options.autoContinue === true && hasClaudeSessionHistory(worktree.path);
+  if (hasPreviousSession) {
+    args.push("--continue");
+  }
   printInfo(`\u6B63\u5728 worktree \u4E2D\u542F\u52A8 Claude Code \u4EA4\u4E92\u5F0F\u754C\u9762...`);
   printInfo(`  \u5206\u652F: ${worktree.branch}`);
   printInfo(`  \u8DEF\u5F84: ${worktree.path}`);
   printInfo(`  \u6307\u4EE4: ${commandStr}`);
+  if (options.autoContinue) {
+    printInfo(`  \u6A21\u5F0F: ${hasPreviousSession ? "\u7EE7\u7EED\u4E0A\u6B21\u5BF9\u8BDD" : "\u65B0\u5BF9\u8BDD"}`);
+  }
   printInfo("");
   const result = spawnSync(cmd, args, {
     cwd: worktree.path,
@@ -931,29 +953,29 @@ function launchInteractiveClaude(worktree) {
 }
 
 // src/utils/validate-snapshot.ts
-import { join as join3 } from "path";
-import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, readdirSync as readdirSync3, rmdirSync as rmdirSync2 } from "fs";
+import { join as join4 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, readdirSync as readdirSync4, rmdirSync as rmdirSync2 } from "fs";
 function getSnapshotPath(projectName, branchName) {
-  return join3(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.tree`);
+  return join4(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.tree`);
 }
 function getSnapshotHeadPath(projectName, branchName) {
-  return join3(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.head`);
+  return join4(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.head`);
 }
 function hasSnapshot(projectName, branchName) {
-  return existsSync5(getSnapshotPath(projectName, branchName));
+  return existsSync6(getSnapshotPath(projectName, branchName));
 }
 function readSnapshot(projectName, branchName) {
   const snapshotPath = getSnapshotPath(projectName, branchName);
   const headPath = getSnapshotHeadPath(projectName, branchName);
   logger.debug(`\u8BFB\u53D6 validate \u5FEB\u7167: ${snapshotPath}`);
-  const treeHash = existsSync5(snapshotPath) ? readFileSync2(snapshotPath, "utf-8").trim() : "";
-  const headCommitHash = existsSync5(headPath) ? readFileSync2(headPath, "utf-8").trim() : "";
+  const treeHash = existsSync6(snapshotPath) ? readFileSync2(snapshotPath, "utf-8").trim() : "";
+  const headCommitHash = existsSync6(headPath) ? readFileSync2(headPath, "utf-8").trim() : "";
   return { treeHash, headCommitHash };
 }
 function writeSnapshot(projectName, branchName, treeHash, headCommitHash) {
   const snapshotPath = getSnapshotPath(projectName, branchName);
   const headPath = getSnapshotHeadPath(projectName, branchName);
-  const snapshotDir = join3(VALIDATE_SNAPSHOTS_DIR, projectName);
+  const snapshotDir = join4(VALIDATE_SNAPSHOTS_DIR, projectName);
   ensureDir(snapshotDir);
   writeFileSync2(snapshotPath, treeHash, "utf-8");
   writeFileSync2(headPath, headCommitHash, "utf-8");
@@ -962,31 +984,31 @@ function writeSnapshot(projectName, branchName, treeHash, headCommitHash) {
 function removeSnapshot(projectName, branchName) {
   const snapshotPath = getSnapshotPath(projectName, branchName);
   const headPath = getSnapshotHeadPath(projectName, branchName);
-  if (existsSync5(snapshotPath)) {
+  if (existsSync6(snapshotPath)) {
     unlinkSync(snapshotPath);
     logger.info(`\u5DF2\u5220\u9664 validate \u5FEB\u7167: ${snapshotPath}`);
   }
-  if (existsSync5(headPath)) {
+  if (existsSync6(headPath)) {
     unlinkSync(headPath);
     logger.info(`\u5DF2\u5220\u9664 validate \u5FEB\u7167: ${headPath}`);
   }
 }
 function getProjectSnapshotBranches(projectName) {
-  const projectDir = join3(VALIDATE_SNAPSHOTS_DIR, projectName);
-  if (!existsSync5(projectDir)) {
+  const projectDir = join4(VALIDATE_SNAPSHOTS_DIR, projectName);
+  if (!existsSync6(projectDir)) {
     return [];
   }
-  const files = readdirSync3(projectDir);
+  const files = readdirSync4(projectDir);
   return files.filter((f) => f.endsWith(".tree")).map((f) => f.replace(/\.tree$/, ""));
 }
 function removeProjectSnapshots(projectName) {
-  const projectDir = join3(VALIDATE_SNAPSHOTS_DIR, projectName);
-  if (!existsSync5(projectDir)) {
+  const projectDir = join4(VALIDATE_SNAPSHOTS_DIR, projectName);
+  if (!existsSync6(projectDir)) {
     return;
   }
-  const files = readdirSync3(projectDir);
+  const files = readdirSync4(projectDir);
   for (const file of files) {
-    unlinkSync(join3(projectDir, file));
+    unlinkSync(join4(projectDir, file));
   }
   try {
     rmdirSync2(projectDir);
@@ -1283,7 +1305,7 @@ var ProgressRenderer = class {
 
 // src/utils/task-file.ts
 import { resolve } from "path";
-import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync3 } from "fs";
 var TASK_BLOCK_REGEX = /<!-- CLAWT-TASKS:START -->([\s\S]*?)<!-- CLAWT-TASKS:END -->/g;
 var BRANCH_LINE_REGEX = /^#\s*branch:\s*(.+)$/;
 function parseTaskFile(content, options) {
@@ -1321,7 +1343,7 @@ function parseTaskFile(content, options) {
 }
 function loadTaskFile(filePath, options) {
   const absolutePath = resolve(filePath);
-  if (!existsSync6(absolutePath)) {
+  if (!existsSync7(absolutePath)) {
     throw new ClawtError(MESSAGES.TASK_FILE_NOT_FOUND(absolutePath));
   }
   const content = readFileSync3(absolutePath, "utf-8");
@@ -1764,7 +1786,7 @@ async function handleResume(options) {
   logger.info(`resume \u547D\u4EE4\u6267\u884C\uFF0C\u5206\u652F: ${options.branch ?? "(\u672A\u6307\u5B9A)"}`);
   const worktrees = getProjectWorktrees();
   const worktree = await resolveTargetWorktree(worktrees, RESUME_RESOLVE_MESSAGES, options.branch);
-  launchInteractiveClaude(worktree);
+  launchInteractiveClaude(worktree, { autoContinue: true });
 }
 
 // src/commands/validate.ts

package/dist/postinstall.js

@@ -9,6 +9,7 @@ var CONFIG_PATH = join(CLAWT_HOME, "config.json");
 var LOGS_DIR = join(CLAWT_HOME, "logs");
 var WORKTREES_DIR = join(CLAWT_HOME, "worktrees");
 var VALIDATE_SNAPSHOTS_DIR = join(CLAWT_HOME, "validate-snapshots");
+var CLAUDE_PROJECTS_DIR = join(homedir(), ".claude", "projects");
 
 // src/constants/messages/common.ts
 var COMMON_MESSAGES = {

package/docs/spec.md

@@ -1088,6 +1088,8 @@ clawt resume
 
 启动命令通过配置项 `claudeCodeCommand`（默认值 `claude`）指定，与 `clawt run` 不传 `--tasks` 时的交互式界面行为一致。
 
+**会话自动续接：** 启动前会自动检测该 worktree 是否存在 Claude Code 历史会话（通过检查 `~/.claude/projects/<encoded-path>/` 下是否有 `.jsonl` 文件判断），如果存在则自动追加 `--continue` 参数继续上次对话，否则打开新对话。启动信息中会显示当前模式（"继续上次对话"或"新对话"）。路径编码规则：将绝对路径中所有非字母数字字符替换为 `-`（与 Claude Code 源码的编码逻辑一致）。
+
 ---
 
 ### 5.12 将主分支代码同步到目标 Worktree

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawt",
-  "version": "2.11.0",
+  "version": "2.11.1",
   "description": "本地并行执行多个Claude Code Agent任务，融合 Git Worktree 与 Claude Code CLI 的命令行工具",
   "type": "module",
   "main": "dist/index.js",

package/src/commands/resume.ts

@@ -48,6 +48,6 @@ async function handleResume(options: ResumeOptions): Promise<void> {
   const worktrees = getProjectWorktrees();
   const worktree = await resolveTargetWorktree(worktrees, RESUME_RESOLVE_MESSAGES, options.branch);
 
-  // 启动 Claude Code 交互式界面
-  launchInteractiveClaude(worktree);
+  // 启动 Claude Code 交互式界面（resume 自动续接历史会话）
+  launchInteractiveClaude(worktree, { autoContinue: true });
 }

package/src/constants/index.ts

@@ -1,4 +1,4 @@
-export { CLAWT_HOME, CONFIG_PATH, LOGS_DIR, WORKTREES_DIR, VALIDATE_SNAPSHOTS_DIR } from './paths.js';
+export { CLAWT_HOME, CONFIG_PATH, LOGS_DIR, WORKTREES_DIR, VALIDATE_SNAPSHOTS_DIR, CLAUDE_PROJECTS_DIR } from './paths.js';
 export { INVALID_BRANCH_CHARS } from './branch.js';
 export { MESSAGES } from './messages/index.js';
 export { EXIT_CODES } from './exitCodes.js';

package/src/constants/paths.ts

@@ -15,3 +15,6 @@ export const WORKTREES_DIR = join(CLAWT_HOME, 'worktrees');
 
 /** validate 快照目录 ~/.clawt/validate-snapshots/ */
 export const VALIDATE_SNAPSHOTS_DIR = join(CLAWT_HOME, 'validate-snapshots');
+
+/** Claude Code 项目会话目录 ~/.claude/projects/ */
+export const CLAUDE_PROJECTS_DIR = join(homedir(), '.claude', 'projects');

package/src/utils/claude.ts

@@ -1,16 +1,55 @@
 import { spawnSync } from 'node:child_process';
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
 import { ClawtError } from '../errors/index.js';
-import { APPEND_SYSTEM_PROMPT } from '../constants/index.js';
+import { APPEND_SYSTEM_PROMPT, CLAUDE_PROJECTS_DIR } from '../constants/index.js';
 import { getConfigValue } from './config.js';
 import { printInfo, printWarning } from './formatter.js';
 import type { WorktreeInfo } from '../types/index.js';
 
+/**
+ * 将路径编码为 Claude Code 项目目录名
+ * 规则：将所有非字母数字字符替换为 -（与 Claude Code 源码中的编码逻辑一致）
+ * @param {string} absolutePath - 绝对路径
+ * @returns {string} 编码后的目录名
+ */
+function encodeClaudeProjectPath(absolutePath: string): string {
+  return absolutePath.replace(/[^a-zA-Z0-9]/g, '-');
+}
+
+/**
+ * 检测指定 worktree 路径是否存在 Claude Code 会话历史
+ * 通过检查 ~/.claude/projects/<encoded-path>/ 下是否有 .jsonl 文件来判断
+ * @param {string} worktreePath - worktree 的绝对路径
+ * @returns {boolean} 是否存在会话历史
+ */
+export function hasClaudeSessionHistory(worktreePath: string): boolean {
+  const encodedName = encodeClaudeProjectPath(worktreePath);
+  const projectDir = join(CLAUDE_PROJECTS_DIR, encodedName);
+
+  if (!existsSync(projectDir)) {
+    return false;
+  }
+
+  const entries = readdirSync(projectDir);
+  return entries.some((entry) => entry.endsWith('.jsonl'));
+}
+
 /**
  * 在指定 worktree 中启动 Claude Code CLI 交互式界面
  * 使用 spawnSync + inherit stdio，让用户直接与 Claude Code 交互
  * @param {WorktreeInfo} worktree - worktree 信息
  */
-export function launchInteractiveClaude(worktree: WorktreeInfo): void {
+/**
+ * @typedef {Object} LaunchClaudeOptions
+ * @property {boolean} [autoContinue] - 是否自动检测历史会话并续接
+ */
+interface LaunchClaudeOptions {
+  /** 是否自动检测历史会话并追加 --continue 参数 */
+  autoContinue?: boolean;
+}
+
+export function launchInteractiveClaude(worktree: WorktreeInfo, options: LaunchClaudeOptions = {}): void {
   const commandStr = getConfigValue('claudeCodeCommand');
   const parts = commandStr.split(/\s+/).filter(Boolean);
   const cmd = parts[0];
@@ -20,10 +59,19 @@ export function launchInteractiveClaude(worktree: WorktreeInfo): void {
     APPEND_SYSTEM_PROMPT,
   ];
 
+  // 仅在启用 autoContinue 时检测历史会话并追加 --continue
+  const hasPreviousSession = options.autoContinue === true && hasClaudeSessionHistory(worktree.path);
+  if (hasPreviousSession) {
+    args.push('--continue');
+  }
+
   printInfo(`正在 worktree 中启动 Claude Code 交互式界面...`);
   printInfo(`  分支: ${worktree.branch}`);
   printInfo(`  路径: ${worktree.path}`);
   printInfo(`  指令: ${commandStr}`);
+  if (options.autoContinue) {
+    printInfo(`  模式: ${hasPreviousSession ? '继续上次对话' : '新对话'}`);
+  }
   printInfo('');
 
   const result = spawnSync(cmd, args, {

package/src/utils/index.ts

@@ -52,7 +52,7 @@ export { loadConfig, writeDefaultConfig, getConfigValue, ensureClawtDirs } from
 export { printSuccess, printError, printWarning, printInfo, printSeparator, printDoubleSeparator, confirmAction, confirmDestructiveAction, formatWorktreeStatus, isWorktreeIdle, formatDuration } from './formatter.js';
 export { ensureDir, removeEmptyDir } from './fs.js';
 export { multilineInput } from './prompt.js';
-export { launchInteractiveClaude } from './claude.js';
+export { launchInteractiveClaude, hasClaudeSessionHistory } from './claude.js';
 export { getSnapshotPath, hasSnapshot, readSnapshotTreeHash, readSnapshot, writeSnapshot, removeSnapshot, removeProjectSnapshots, getProjectSnapshotBranches } from './validate-snapshot.js';
 export { findExactMatch, findFuzzyMatches, promptSelectBranch, promptMultiSelectBranches, resolveTargetWorktree, resolveTargetWorktrees } from './worktree-matcher.js';
 export type { WorktreeResolveMessages, WorktreeMultiResolveMessages } from './worktree-matcher.js';

package/tests/unit/commands/resume.test.ts

@@ -68,7 +68,7 @@ describe('handleResume', () => {
     expect(mockedValidateMainWorktree).toHaveBeenCalled();
     expect(mockedValidateClaudeCodeInstalled).toHaveBeenCalled();
     expect(mockedResolveTargetWorktree).toHaveBeenCalled();
-    expect(mockedLaunchInteractiveClaude).toHaveBeenCalledWith(worktree);
+    expect(mockedLaunchInteractiveClaude).toHaveBeenCalledWith(worktree, { autoContinue: true });
   });
 
   it('不传 -b 时也能调用 resolveTargetWorktree', async () => {

package/tests/unit/utils/claude.test.ts

@@ -10,6 +10,12 @@ vi.mock('node:child_process', () => ({
   spawnSync: vi.fn(),
 }));
 
+// mock node:fs
+vi.mock('node:fs', () => ({
+  existsSync: vi.fn(),
+  readdirSync: vi.fn(),
+}));
+
 // mock config
 vi.mock('../../../src/utils/config.js', () => ({
   getConfigValue: vi.fn(),
@@ -22,7 +28,8 @@ vi.mock('../../../src/utils/formatter.js', () => ({
 }));
 
 import { spawnSync } from 'node:child_process';
-import { launchInteractiveClaude } from '../../../src/utils/claude.js';
+import { existsSync, readdirSync } from 'node:fs';
+import { launchInteractiveClaude, hasClaudeSessionHistory } from '../../../src/utils/claude.js';
 import { getConfigValue } from '../../../src/utils/config.js';
 import { printInfo, printWarning } from '../../../src/utils/formatter.js';
 import { ClawtError } from '../../../src/errors/index.js';
@@ -32,6 +39,45 @@ const mockedSpawnSync = vi.mocked(spawnSync);
 const mockedGetConfigValue = vi.mocked(getConfigValue);
 const mockedPrintInfo = vi.mocked(printInfo);
 const mockedPrintWarning = vi.mocked(printWarning);
+const mockedExistsSync = vi.mocked(existsSync);
+const mockedReaddirSync = vi.mocked(readdirSync);
+
+describe('hasClaudeSessionHistory', () => {
+  it('项目目录不存在时返回 false', () => {
+    mockedExistsSync.mockReturnValue(false);
+
+    expect(hasClaudeSessionHistory('/Users/test/project')).toBe(false);
+    expect(mockedExistsSync).toHaveBeenCalled();
+  });
+
+  it('项目目录存在但无 .jsonl 文件时返回 false', () => {
+    mockedExistsSync.mockReturnValue(true);
+    mockedReaddirSync.mockReturnValue(['memory', 'CLAUDE.md'] as unknown as ReturnType<typeof readdirSync>);
+
+    expect(hasClaudeSessionHistory('/Users/test/project')).toBe(false);
+  });
+
+  it('项目目录存在且有 .jsonl 文件时返回 true', () => {
+    mockedExistsSync.mockReturnValue(true);
+    mockedReaddirSync.mockReturnValue([
+      'abc-123.jsonl',
+      'memory',
+    ] as unknown as ReturnType<typeof readdirSync>);
+
+    expect(hasClaudeSessionHistory('/Users/test/project')).toBe(true);
+  });
+
+  it('路径编码规则正确（非字母数字字符替换为 -）', () => {
+    mockedExistsSync.mockReturnValue(false);
+
+    hasClaudeSessionHistory('/Users/qihoo/.clawt/worktrees/clawt/resume');
+
+    // 验证 existsSync 被调用时路径包含编码后的目录名
+    // /Users/qihoo/.clawt/worktrees/clawt/resume → -Users-qihoo--clawt-worktrees-clawt-resume
+    const calledPath = mockedExistsSync.mock.calls[0][0] as string;
+    expect(calledPath).toContain('-Users-qihoo--clawt-worktrees-clawt-resume');
+  });
+});
 
 describe('launchInteractiveClaude', () => {
   const worktree = createWorktreeInfo({
@@ -41,6 +87,7 @@ describe('launchInteractiveClaude', () => {
 
   it('正常启动 Claude Code（退出码为 0）', () => {
     mockedGetConfigValue.mockReturnValue('claude');
+    mockedExistsSync.mockReturnValue(false);
     mockedSpawnSync.mockReturnValue({
       status: 0,
       error: undefined,
@@ -66,6 +113,7 @@ describe('launchInteractiveClaude', () => {
 
   it('输出分支和路径信息', () => {
     mockedGetConfigValue.mockReturnValue('claude');
+    mockedExistsSync.mockReturnValue(false);
     mockedSpawnSync.mockReturnValue({
       status: 0,
       error: undefined,
@@ -84,6 +132,7 @@ describe('launchInteractiveClaude', () => {
 
   it('支持带参数的命令（如 npx claude）', () => {
     mockedGetConfigValue.mockReturnValue('npx claude');
+    mockedExistsSync.mockReturnValue(false);
     mockedSpawnSync.mockReturnValue({
       status: 0,
       error: undefined,
@@ -105,6 +154,7 @@ describe('launchInteractiveClaude', () => {
 
   it('spawnSync 返回 error 时抛出 ClawtError', () => {
     mockedGetConfigValue.mockReturnValue('claude');
+    mockedExistsSync.mockReturnValue(false);
     mockedSpawnSync.mockReturnValue({
       status: null,
       error: new Error('命令未找到'),
@@ -121,6 +171,7 @@ describe('launchInteractiveClaude', () => {
 
   it('非零退出码时调用 printWarning', () => {
     mockedGetConfigValue.mockReturnValue('claude');
+    mockedExistsSync.mockReturnValue(false);
     mockedSpawnSync.mockReturnValue({
       status: 1,
       error: undefined,
@@ -138,6 +189,7 @@ describe('launchInteractiveClaude', () => {
 
   it('退出码为 null 时不调用 printWarning', () => {
     mockedGetConfigValue.mockReturnValue('claude');
+    mockedExistsSync.mockReturnValue(false);
     mockedSpawnSync.mockReturnValue({
       status: null,
       error: undefined,
@@ -155,6 +207,7 @@ describe('launchInteractiveClaude', () => {
 
   it('退出码为 0 时不调用 printWarning', () => {
     mockedGetConfigValue.mockReturnValue('claude');
+    mockedExistsSync.mockReturnValue(false);
     mockedSpawnSync.mockReturnValue({
       status: 0,
       error: undefined,
@@ -169,4 +222,65 @@ describe('launchInteractiveClaude', () => {
 
     expect(mockedPrintWarning).not.toHaveBeenCalled();
   });
+
+  it('autoContinue 启用且有会话历史时追加 --continue 参数', () => {
+    mockedGetConfigValue.mockReturnValue('claude');
+    mockedExistsSync.mockReturnValue(true);
+    mockedReaddirSync.mockReturnValue(['session-abc.jsonl'] as unknown as ReturnType<typeof readdirSync>);
+    mockedSpawnSync.mockReturnValue({
+      status: 0,
+      error: undefined,
+      stdout: '',
+      stderr: '',
+      pid: 1234,
+      output: [],
+      signal: null,
+    });
+
+    launchInteractiveClaude(worktree, { autoContinue: true });
+
+    const callArgs = mockedSpawnSync.mock.calls[0][1] as string[];
+    expect(callArgs).toContain('--continue');
+    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('继续上次对话'));
+  });
+
+  it('autoContinue 启用但无会话历史时不追加 --continue 参数', () => {
+    mockedGetConfigValue.mockReturnValue('claude');
+    mockedExistsSync.mockReturnValue(false);
+    mockedSpawnSync.mockReturnValue({
+      status: 0,
+      error: undefined,
+      stdout: '',
+      stderr: '',
+      pid: 1234,
+      output: [],
+      signal: null,
+    });
+
+    launchInteractiveClaude(worktree, { autoContinue: true });
+
+    const callArgs = mockedSpawnSync.mock.calls[0][1] as string[];
+    expect(callArgs).not.toContain('--continue');
+    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('新对话'));
+  });
+
+  it('不传 autoContinue 时即使有会话历史也不追加 --continue', () => {
+    mockedGetConfigValue.mockReturnValue('claude');
+    mockedExistsSync.mockReturnValue(true);
+    mockedReaddirSync.mockReturnValue(['session-abc.jsonl'] as unknown as ReturnType<typeof readdirSync>);
+    mockedSpawnSync.mockReturnValue({
+      status: 0,
+      error: undefined,
+      stdout: '',
+      stderr: '',
+      pid: 1234,
+      output: [],
+      signal: null,
+    });
+
+    launchInteractiveClaude(worktree);
+
+    const callArgs = mockedSpawnSync.mock.calls[0][1] as string[];
+    expect(callArgs).not.toContain('--continue');
+  });
 });