Worktree 隔离：多 Agent 并行不踩踏

// EnterWorktreeTool.ts — call() 核心逻辑（简化）

async call(input) {
  // 1. 防止嵌套：已经在 worktree 里就拒绝
  if (getCurrentWorktreeSession()) {
    throw new Error('Already in a worktree session')
  }

  // 2. 回到规范 git 根目录（即使从 worktree 内部调用也不会嵌套）
  const mainRepoRoot = findCanonicalGitRoot(getCwd())
  if (mainRepoRoot && mainRepoRoot !== getCwd()) {
    process.chdir(mainRepoRoot)
    setCwd(mainRepoRoot)
  }

  // 3. 创建 worktree（路径：.claude/worktrees/<slug>）
  const slug = input.name ?? getPlanSlug()
  const worktreeSession = await createWorktreeForSession(getSessionId(), slug)

  // 4. 切换 CWD 到 worktree
  process.chdir(worktreeSession.worktreePath)
  setCwd(worktreeSession.worktreePath)
  setOriginalCwd(getCwd())

  // 5. 关键：清空所有依赖 CWD 的缓存
  clearSystemPromptSections()   // 系统 prompt 重新生成
  clearMemoryFileCaches()       // CLAUDE.md 等记忆文件重新读取
  getPlansDirectory.cache.clear?.()

  // 6. 持久化 worktree 状态（崩溃恢复用）
  saveWorktreeState(worktreeSession)

  return {
    data: {
      worktreePath: worktreeSession.worktreePath,
      worktreeBranch: worktreeSession.worktreeBranch,
      message: `Created worktree at ${worktreeSession.worktreePath}...`,
    },
  }
}

const inputSchema = z.strictObject({
  name: z.string()
    .superRefine((s, ctx) => {
      try { validateWorktreeSlug(s) }
      catch (e) { ctx.addIssue({ code: 'custom', message: (e as Error).message }) }
    })
    .optional()
    .describe('Optional name for the worktree...'),
})

const inputSchema = z.strictObject({
  action: z.enum(['keep', 'remove']),        // 保留还是删除 worktree
  discard_changes: z.boolean().optional(),   // remove 时如果有未提交变更，必须显式确认
})

async validateInput(input) {
  // 1. 作用域守卫：只操作当前 session 的 EnterWorktree 创建的 worktree
  const session = getCurrentWorktreeSession()
  if (!session) {
    return { result: false, message: 'No-op: there is no active EnterWorktree session...' }
  }

  // 2. remove 时检查未提交变更
  if (input.action === 'remove' && !input.discard_changes) {
    const summary = await countWorktreeChanges(session.worktreePath, session.originalHeadCommit)
    // null = 无法确定状态 → fail-closed，拒绝删除
    if (summary === null) {
      return { result: false, message: 'Could not verify worktree state...' }
    }
    if (summary.changedFiles > 0 || summary.commits > 0) {
      return { result: false, message: `Worktree has ${changedFiles} uncommitted files and ${commits} commits...` }
    }
  }
  return { result: true }
}

// 返回 null 代表"无法确定"，调用方必须将 null 视为"不安全"
async function countWorktreeChanges(
  worktreePath: string,
  originalHeadCommit: string | undefined,
): Promise<ChangeSummary | null> {
  const status = await execFileNoThrow('git', ['-C', worktreePath, 'status', '--porcelain'])
  if (status.code !== 0) return null       // git 失败 → null

  if (!originalHeadCommit) return null     // 没有基线 commit → null（hook-based worktree 场景）

  const revList = await execFileNoThrow('git', ['-C', worktreePath, 'rev-list', '--count', `${originalHeadCommit}..HEAD`])
  if (revList.code !== 0) return null      // rev-list 失败 → null

  return { changedFiles, commits }
}

function restoreSessionToOriginalCwd(originalCwd: string, projectRootIsWorktree: boolean): void {
  setCwd(originalCwd)
  setOriginalCwd(originalCwd)
  if (projectRootIsWorktree) {
    setProjectRoot(originalCwd)
    updateHooksConfigSnapshot()  // 恢复 hooks 配置快照
  }
  saveWorktreeState(null)        // 清除持久化状态
  clearSystemPromptSections()    // 与 Enter 时对称
  clearMemoryFileCaches()
  getPlansDirectory.cache.clear?.()
}

// AgentTool.tsx — inputSchema
isolation: z.enum(['worktree'])
  .optional()
  .describe('Isolation mode. "worktree" creates a temporary git worktree '
    + 'so the agent works on an isolated copy of the repo.')

// AgentTool.tsx — call() 中的 worktree 设置（简化）

// 用 agent ID 的前 8 位生成 slug
const earlyAgentId = createAgentId()
let worktreeInfo = null
if (effectiveIsolation === 'worktree') {
  const slug = `agent-${earlyAgentId.slice(0, 8)}`
  worktreeInfo = await createAgentWorktree(slug)
}

// CWD 覆盖：worktree 路径覆盖 agent 的工作目录
const cwdOverridePath = cwd ?? worktreeInfo?.worktreePath
const wrapWithCwd = <T,>(fn: () => T): T =>
  cwdOverridePath ? runWithCwdOverride(cwdOverridePath, fn) : fn()

// worktree.ts — createAgentWorktree（简化）
export async function createAgentWorktree(slug: string): Promise<{
  worktreePath: string
  worktreeBranch?: string
  headCommit?: string
  gitRoot?: string
  hookBased?: boolean
}> {
  validateWorktreeSlug(slug)
  // 始终从 canonicalGitRoot 创建，防止 worktree 嵌套
  const gitRoot = findCanonicalGitRoot(getCwd())
  // ... 创建 worktree 但不修改全局状态
  return { worktreePath, worktreeBranch, headCommit, gitRoot }
}

// forkSubagent.ts — buildWorktreeNotice
export function buildWorktreeNotice(parentCwd: string, worktreeCwd: string): string {
  return `You've inherited the conversation context above from a parent agent ` +
    `working in ${parentCwd}. You are operating in an isolated git worktree ` +
    `at ${worktreeCwd} — same repository, same relative file structure, ` +
    `separate working copy. Paths in the inherited context refer to the ` +
    `parent's working directory; translate them to your worktree root. ` +
    `Re-read files before editing if the parent may have modified them...`
}

const cleanupWorktreeIfNeeded = async () => {
  if (!worktreeInfo) return {}
  const { worktreePath, worktreeBranch, headCommit, gitRoot, hookBased } = worktreeInfo
  worktreeInfo = null  // 幂等：防止 try/catch 双重调用

  if (hookBased) return { worktreePath }  // hook-based 始终保留

  if (headCommit) {
    const changed = await hasWorktreeChanges(worktreePath, headCommit)
    if (!changed) {
      await removeAgentWorktree(worktreePath, worktreeBranch, gitRoot)
      return {}  // 无变更 → 自动删除，不返回路径
    }
  }
  return { worktreePath, worktreeBranch }  // 有变更 → 保留，返回路径
}