@cat-kit/agent-context 1.0.6 → 1.1.0

package/src/adapters/tool-targets.ts

@@ -1,157 +0,0 @@
-import { resolve } from 'node:path'
-import { existsSync } from 'node:fs'
-
-import type { ToolId, ToolTarget, WorkflowCommandName } from '../domain/types'
-
-const TOOL_TARGET_MAP: Record<ToolId, ToolTarget> = {
-  claude: {
-    id: 'claude',
-    name: 'Claude Code',
-    rootDir: '.claude/commands',
-    fileExtension: '.md',
-    supportsFrontmatter: true,
-    commandSeparator: ':',
-    commandPrefix: '/'
-  },
-  codex: {
-    id: 'codex',
-    name: 'Codex',
-    rootDir: '.codex/commands',
-    fileExtension: '.md',
-    supportsFrontmatter: true,
-    commandSeparator: '-',
-    commandPrefix: '/'
-  },
-  cursor: {
-    id: 'cursor',
-    name: 'Cursor',
-    rootDir: '.cursor/commands',
-    fileExtension: '.md',
-    supportsFrontmatter: false,
-    commandSeparator: '-',
-    commandPrefix: '/'
-  },
-  antigravity: {
-    id: 'antigravity',
-    name: 'Antigravity',
-    rootDir: '.agents',
-    fileExtension: '.md',
-    supportsFrontmatter: true,
-    commandSeparator: '-',
-    commandPrefix: '/'
-  },
-  copilot: {
-    id: 'copilot',
-    name: 'GitHub Copilot',
-    rootDir: '.github/prompts',
-    fileExtension: '.prompt.md',
-    supportsFrontmatter: true,
-    commandSeparator: '-',
-    commandPrefix: '#'
-  }
-}
-
-export const DEFAULT_TOOL_ORDER: ToolId[] = [
-  'claude',
-  'codex',
-  'cursor',
-  'antigravity',
-  'copilot'
-]
-
-const WORKFLOW_COMMAND_ORDER: WorkflowCommandName[] = [
-  'init',
-  'plan',
-  'replan',
-  'implement',
-  'patch',
-  'done'
-]
-
-export interface ToolChoice {
-  id: ToolId
-  name: string
-}
-
-export function getToolChoices(): ToolChoice[] {
-  return DEFAULT_TOOL_ORDER.map(id => ({
-    id,
-    name: TOOL_TARGET_MAP[id].name
-  }))
-}
-
-export function parseToolIds(toolsText: string): ToolId[] {
-  const parsed = toolsText
-    .split(',')
-    .map(item => item.trim().toLowerCase())
-    .filter(Boolean)
-
-  if (parsed.length === 0) {
-    return [...DEFAULT_TOOL_ORDER]
-  }
-
-  const uniqueIds: ToolId[] = []
-
-  for (const value of parsed) {
-    if (!isToolId(value)) {
-      throw new Error(
-        `不支持的工具标识: ${value}。可选值: ${DEFAULT_TOOL_ORDER.join(', ')}`
-      )
-    }
-
-    if (!uniqueIds.includes(value)) {
-      uniqueIds.push(value)
-    }
-  }
-
-  return uniqueIds
-}
-
-export function resolveToolTargets(tools?: ToolId[]): ToolTarget[] {
-  const selected = tools && tools.length > 0 ? tools : DEFAULT_TOOL_ORDER
-  return selected.map(id => ({ ...TOOL_TARGET_MAP[id] }))
-}
-
-export function detectConfiguredToolIds(cwd: string): ToolId[] {
-  return DEFAULT_TOOL_ORDER.filter((toolId) => {
-    const target = TOOL_TARGET_MAP[toolId]
-    const workflowPaths = resolveWorkflowPaths(target, cwd)
-
-    return WORKFLOW_COMMAND_ORDER.some(command =>
-      existsSync(workflowPaths.commandFile(command))
-    )
-  })
-}
-
-// ── 工作流路径解析 ────────────────────────────────────
-
-export interface WorkflowPaths {
-  commandFile(name: WorkflowCommandName): string
-}
-
-/**
- * 根据工具约束计算工作流文件输出路径
- *
- * - separator=':' (Claude) → 嵌套: .claude/commands/ac/init.md  → /ac:init
- * - separator='-' (其他)   → 扁平: .cursor/commands/ac-init.md → /ac-init
- */
-export function resolveWorkflowPaths(target: ToolTarget, cwd: string): WorkflowPaths {
-  const root = resolve(cwd, target.rootDir)
-  const ext = target.fileExtension
-  const nested = target.commandSeparator === ':'
-
-  if (nested) {
-    const nsDir = resolve(root, 'ac')
-    return {
-      commandFile: name => resolve(nsDir, `${name}${ext}`)
-    }
-  }
-
-  return {
-    commandFile: name => resolve(root, `ac-${name}${ext}`)
-  }
-}
-
-function isToolId(value: string): value is ToolId {
-  return Object.hasOwn(TOOL_TARGET_MAP, value)
-}

package/src/commands/setup.ts

@@ -1,64 +0,0 @@
-import { checkbox } from '@inquirer/prompts'
-
-import {
-  DEFAULT_TOOL_ORDER,
-  detectConfiguredToolIds,
-  getToolChoices,
-  parseToolIds
-} from '../adapters/tool-targets'
-import type { ToolId } from '../domain/types'
-import { runSetup } from '../runtime/execute'
-import { printCheckResult, printRunSummary } from './shared'
-
-export interface SetupCommandOptions {
-  tools?: string
-  check?: boolean
-  yes?: boolean
-}
-
-export async function setupCommand(options: SetupCommandOptions = {}): Promise<void> {
-  const cwd = process.cwd()
-  const tools = await resolveTools(cwd, options)
-  const check = options.check ?? false
-
-  const result = await runSetup({ cwd, tools, check })
-
-  if (check) {
-    printCheckResult(result, cwd)
-    if (result.changed.length > 0) {
-      process.exitCode = 1
-    }
-    return
-  }
-
-  printRunSummary(result, cwd)
-}
-
-async function resolveTools(cwd: string, options: SetupCommandOptions): Promise<ToolId[] | undefined> {
-  const raw = options.tools
-
-  if (!raw || raw.trim().length === 0) {
-    const configuredTools = detectConfiguredToolIds(cwd)
-
-    if (options.yes) {
-      if (configuredTools.length > 0) {
-        return configuredTools
-      }
-      return [...DEFAULT_TOOL_ORDER]
-    }
-
-    const selectedTools = await checkbox<ToolId>({
-      message: '请选择要生成工作流命令的工具（可多选）：',
-      choices: getToolChoices().map((tool) => ({
-        name: tool.name,
-        value: tool.id,
-        checked: configuredTools.includes(tool.id)
-      })),
-      required: true
-    })
-
-    return selectedTools
-  }
-
-  return parseToolIds(raw)
-}

package/src/commands/update.ts

@@ -1,46 +0,0 @@
-import { detectConfiguredToolIds, parseToolIds } from '../adapters/tool-targets'
-import type { ToolId } from '../domain/types'
-import { runUpdate } from '../runtime/execute'
-import { printCheckResult, printRunSummary } from './shared'
-
-export interface UpdateCommandOptions {
-  tools?: string
-  check?: boolean
-  yes?: boolean
-}
-
-export async function updateCommand(options: UpdateCommandOptions = {}): Promise<void> {
-  const cwd = process.cwd()
-  const tools = resolveTools(cwd, options.tools)
-  const check = options.check ?? false
-
-  const result = await runUpdate({
-    cwd,
-    tools,
-    check
-  })
-
-  if (check) {
-    printCheckResult(result, cwd)
-    if (result.changed.length > 0) {
-      process.exitCode = 1
-    }
-    return
-  }
-
-  printRunSummary(result, cwd)
-}
-
-function resolveTools(cwd: string, raw?: string): ToolId[] | undefined {
-  if (!raw || raw.trim().length === 0) {
-    const configuredTools = detectConfiguredToolIds(cwd)
-
-    if (configuredTools.length === 0) {
-      throw new Error('未检测到已 setup 的工具，请先执行 setup 或通过 --tools 显式指定工具')
-    }
-
-    return configuredTools
-  }
-
-  return parseToolIds(raw)
-}

package/src/domain/types.ts

@@ -1,50 +0,0 @@
-export type ToolId = 'claude' | 'codex' | 'cursor' | 'antigravity' | 'copilot'
-
-export interface ToolTarget {
-  id: ToolId
-  name: string
-  rootDir: string
-  /** 工作流文件扩展名：'.md' | '.prompt.md'（Copilot） */
-  fileExtension: string
-  /** 是否支持 YAML frontmatter（Cursor 不支持） */
-  supportsFrontmatter: boolean
-  /** 命令分隔符：':'（Claude 嵌套目录 ac/init.md → /ac:init）或 '-'（扁平 ac-init.md） */
-  commandSeparator: string
-  /** 命令调用前缀：'/'（Claude/Cursor）或 '#'（Copilot） */
-  commandPrefix: string
-}
-
-export type WorkflowCommandName =
-  | 'init'
-  | 'plan'
-  | 'replan'
-  | 'implement'
-  | 'patch'
-  | 'done'
-
-export interface WorkflowArtifacts {
-  commandFiles: Record<WorkflowCommandName, string>
-}
-
-export interface FileMutation {
-  path: string
-  body: string
-}
-
-export interface ApplyMutationResult {
-  created: string[]
-  updated: string[]
-  unchanged: string[]
-  changed: string[]
-}
-
-export interface RunOptions {
-  cwd?: string
-  tools?: ToolId[]
-  check?: boolean
-}
-
-export interface RunResult extends ApplyMutationResult {
-  mode: 'setup' | 'update'
-  check: boolean
-}

package/src/domain/workflow-content.ts

@@ -1,25 +0,0 @@
-import type { ToolTarget, WorkflowArtifacts } from './types'
-import {
-  createWorkflowContext,
-  renderDone,
-  renderImplement,
-  renderInit,
-  renderPatch,
-  renderPlan,
-  renderReplan
-} from './workflow-templates/index.js'
-
-export function renderWorkflowArtifacts(target: ToolTarget): WorkflowArtifacts {
-  const ctx = createWorkflowContext(target)
-
-  return {
-    commandFiles: {
-      init: renderInit(ctx),
-      plan: renderPlan(ctx),
-      replan: renderReplan(ctx),
-      implement: renderImplement(ctx),
-      patch: renderPatch(ctx),
-      done: renderDone(ctx)
-    }
-  }
-}

package/src/domain/workflow-context.ts

@@ -1,48 +0,0 @@
-import type { ToolTarget } from './types'
-
-export interface WorkflowContext {
-  /** 命令引用: 'ac:init' | 'ac-init' */
-  cmd(name: string): string
-  /** 命令调用: '/ac:init' | '#ac-init' */
-  invoke(name: string): string
-  /** 命令前缀模式: 'ac:' | 'ac-' */
-  cmdPrefix(): string
-  /** 生成 YAML frontmatter 或空字符串 */
-  frontmatter(description: string): string
-}
-
-export function createWorkflowContext(target: ToolTarget): WorkflowContext {
-  const sep = target.commandSeparator
-  const pre = target.commandPrefix
-  return {
-    cmd: (name) => `ac${sep}${name}`,
-    invoke: (name) => `${pre}ac${sep}${name}`,
-    cmdPrefix: () => `ac${sep}`,
-    frontmatter: (desc) => (target.supportsFrontmatter ? `---\ndescription: ${desc}\n---\n\n` : '')
-  }
-}
-
-export const fence = '```'
-export const code = (t: string) => `\`${t}\``
-
-export interface NextStep {
-  command: string
-  description: string
-}
-
-export function renderNextSteps(c: WorkflowContext, steps: NextStep[]): string {
-  const items = steps.map((s) => `${code(c.invoke(s.command))}（${s.description}）`).join(' | ')
-
-  return `> **下一步：** ${items}`
-}
-
-const LIFECYCLE_COMMANDS = ['init', 'plan', 'replan', 'implement', 'patch', 'done'] as const
-
-export function renderPreamble(c: WorkflowContext, current: string, description: string): string {
-  const lifecycle = LIFECYCLE_COMMANDS.map((cmd) => {
-    const ref = code(c.cmd(cmd))
-    return cmd === current ? `**${ref}**` : ref
-  }).join(' → ')
-
-  return `${description}\n\n生命周期: ${lifecycle}。`
-}

package/src/domain/workflow-templates/done.ts

@@ -1,28 +0,0 @@
-import { code, renderNextSteps, renderPreamble, type WorkflowContext } from '../workflow-context'
-
-export function renderDone(c: WorkflowContext): string {
-  return `${c.frontmatter('将当前已执行计划标记为真正完成并归档，必要时晋升 preparing 队列')}\
-# ${c.invoke('done')}
-
-${renderPreamble(c, 'done', `确认当前已执行计划真正完成，归档到 ${code('.agent-context/done/')} 目录，并自动晋升 ${code('preparing/')} 队列中的下一个计划。`)}
-
-## 前置规则
-
-- 带描述 → 拒绝执行。
-- 当前计划不存在 → 拒绝执行，提示先运行 ${code(c.cmd('plan'))}。
-- 当前计划状态为 ${code('未执行')} → 拒绝执行，提示先运行 ${code(c.cmd('implement'))}。
-- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。
-- 必须得到用户确认后才可归档；用户未确认 → 中止。
-
-## 执行步骤
-
-1. **用户确认**：向用户确认当前计划已真正完成，可以归档。
-2. **归档当前计划**：将 ${code('.agent-context/plan-{number}')} 移动到 ${code('.agent-context/done/plan-{number}-{YYYYMMDD}')}（当日日期），包含完整 ${code('plan.md')} 与所有 ${code('patch-{number}.md')}。编号不可被新计划复用。
-3. **晋升 preparing 队列**：若 ${code('.agent-context/preparing/')} 非空，将最小编号计划移至 ${code('.agent-context/')} 作为新当前计划。
-4. **校验**：确认归档完整，晋升后仍满足单当前计划约束；失败则回滚。
-5. **输出反馈**：报告归档路径、是否晋升及晋升编号、是否还有待执行计划。
-
-${renderNextSteps(c, [
-  { command: 'plan', description: '创建新计划' }
-])}`
-}

package/src/domain/workflow-templates/implement.ts

@@ -1,41 +0,0 @@
-import { code, fence, renderNextSteps, renderPreamble, type WorkflowContext } from '../workflow-context'
-
-export function renderImplement(c: WorkflowContext): string {
-  return `${c.frontmatter('实施当前计划并将状态从未执行更新为已执行')}\
-# ${c.invoke('implement')}
-
-${renderPreamble(c, 'implement', `实施当前计划 ${code('.agent-context/plan-{number}/plan.md')} 中的全部步骤，通过验证循环后将状态从「未执行」更新为「已执行」。`)}
-
-## 前置规则
-
-- 带描述 → 拒绝执行。
-- 当前计划不存在 → 拒绝执行，提示先运行 ${code(c.cmd('plan'))}。
-- 当前计划状态为 ${code('已执行')} → 拒绝执行，提示使用 ${code(c.cmd('patch'))} 或 ${code(c.cmd('done'))}。
-- ${code('## 目标')} 或 ${code('## 内容')} 为空 → 拒绝执行，提示补充内容。
-- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。
-- 仅操作当前计划，不直接操作 ${code('preparing/')} 中的计划。
-- 遇到阻塞问题应向用户报告，不可静默跳过。
-
-## 执行步骤
-
-1. 读取当前计划 ${code('plan.md')}，理解 ${code('## 目标')} 与 ${code('## 内容')}。
-2. 依据 ${code('## 内容')} 中的步骤逐项实施。
-3. **验证循环**（全部通过前不可进入步骤 4）：
-   a. 逐项对照 ${code('## 内容')} 确认每个步骤已实施。
-   b. 运行项目验证：类型检查 → lint → 测试。
-   c. 若存在失败项 → 修复后回到 a 重新验证。
-   d. 全部通过 → 进入步骤 4。
-4. 更新 ${code('plan.md')} 状态行：${code('> 状态: 未执行')} → ${code('> 状态: 已执行')}。状态行须唯一，仅在验证通过后更新。
-5. 更新 ${code('## 影响范围')}，记录所有变更文件：
-
-   ${fence}markdown
-   - 新增文件: ${code('/path/to/new-file')}
-   - 修改文件: ${code('/path/to/modified-file')}
-   - 删除文件: ${code('/path/to/deleted-file')}
-   ${fence}
-
-${renderNextSteps(c, [
-  { command: 'done', description: '归档当前计划' },
-  { command: 'patch', description: '补丁修复' }
-])}`
-}

package/src/domain/workflow-templates/index.ts

@@ -1,7 +0,0 @@
-export { createWorkflowContext, type WorkflowContext } from '../workflow-context'
-export { renderInit } from './init'
-export { renderPlan } from './plan'
-export { renderReplan } from './replan'
-export { renderImplement } from './implement'
-export { renderPatch } from './patch'
-export { renderDone } from './done'

package/src/domain/workflow-templates/init.ts

@@ -1,42 +0,0 @@
-import { code, renderNextSteps, renderPreamble, type WorkflowContext } from '../workflow-context'
-
-export function renderInit(c: WorkflowContext): string {
-  return `${c.frontmatter('初始化项目上下文，按新旧项目规则处理 AGENTS.md 与计划入口')}\
-# ${c.invoke('init')} {描述?}
-
-${renderPreamble(c, 'init', `初始化项目的 Agent Context 工作流上下文。根据新旧项目类型处理 ${code('AGENTS.md')}，新项目会自动进入 ${code(c.cmd('plan'))} 计划创建流程。`)}
-
-描述为可选参数，用于补充项目背景、技术栈、特殊约束。
-
-## 执行步骤
-
-1. **判断项目类型**：检测根目录是否存在有效代码文件和目录结构。
-   - 新项目：无实质代码，或用户明确说明是新项目。
-   - 旧项目：已有代码、配置文件和目录结构。
-   - 无法判断 → 向用户提问澄清，不可假设。
-
-2. **处理 AGENTS.md**：
-   - 新项目：
-     1. 通过提问澄清以下要点（已从描述中获取的可跳过）：项目目标与核心功能、技术栈与版本、代码规范与工具链（lint/formatter/测试）、目录结构偏好。
-     2. 生成高质量 ${code('AGENTS.md')}（须满足下方质量标准，不满足则重新优化直至满足）。
-     3. 继续执行 ${code(c.cmd('plan'))} 创建初始计划。
-   - 旧项目：
-     1. 若不存在 ${code('AGENTS.md')}：通过提问与代码阅读收集信息后生成。
-     2. 若已存在 ${code('AGENTS.md')}：按质量标准评估，不足时增补优化。
-     3. 默认不创建计划（除非用户明确要求）。
-
-3. **输出反馈**：向用户报告项目类型判定结果、AGENTS.md 处理结果、是否需要后续 ${code(c.cmd('plan'))}。
-
-## 高质量 AGENTS.md 标准
-
-- [ ] 常用命令与约束前置，降低代理执行歧义。
-- [ ] 明确列出目录结构（至少到第二层）。
-- [ ] 明确标注技术栈及版本。
-- [ ] 明确代码风格约束（命名规范、格式化工具、lint 配置）。
-- [ ] 内容精简，无冗余段落或模板化填充。
-- [ ] 大型单体仓库按子包拆分维护本地 ${code('AGENTS.md')}。
-
-${renderNextSteps(c, [
-  { command: 'plan', description: '创建新计划' }
-])}`
-}

package/src/domain/workflow-templates/patch.ts

@@ -1,47 +0,0 @@
-import { code, fence, renderNextSteps, renderPreamble, type WorkflowContext } from '../workflow-context'
-
-export function renderPatch(c: WorkflowContext): string {
-  return `${c.frontmatter('基于当前已执行计划创建补丁并回写历史记录')}\
-# ${c.invoke('patch')} {描述}
-
-${renderPreamble(c, 'patch', `基于当前已执行计划创建增量补丁，修复问题或追加变更，生成 ${code('patch-{number}.md')} 并回写计划的影响范围与历史记录。`)}
-
-## 前置规则
-
-- 描述为空 → 拒绝执行。
-- 当前计划不存在 → 拒绝执行，提示先运行 ${code(c.cmd('plan'))}。
-- 当前计划状态为 ${code('未执行')} → 拒绝执行，提示先运行 ${code(c.cmd('implement'))}。
-- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。
-- 补丁不改变计划状态，完成后保持 ${code('已执行')}。
-
-## 执行步骤
-
-1. 阅读 ${code('plan.md')} 与已有 ${code('patch-{number}.md')}，了解上下文与历史补丁，避免重复修复。
-2. 根据描述执行补丁所需的代码变更。
-3. 完成必要验证（测试、类型检查等）。
-4. 创建 ${code('patch-{number}.md')}（编号：扫描当前计划目录已有补丁，取 max+1），遵循下方模板。
-5. 回写 ${code('plan.md')}：
-   - ${code('## 历史补丁')}：追加 ${code('- patch-{number}: {补丁名称}')}，按编号去重。
-   - ${code('## 影响范围')}：合并本次变更路径，按路径去重。
-
-## patch.md 标准模板
-
-${fence}markdown
-# {补丁名称}
-
-## 补丁内容
-
-{修改了什么、为什么修改}
-
-## 影响范围
-
-- 新增文件: ${code('/path/to/file')}
-- 修改文件: ${code('/path/to/file')}
-- 删除文件: ${code('/path/to/file')}
-${fence}
-
-${renderNextSteps(c, [
-  { command: 'done', description: '归档当前计划' },
-  { command: 'patch', description: '继续补丁' }
-])}`
-}

package/src/domain/workflow-templates/plan.ts

@@ -1,70 +0,0 @@
-import {
-  code,
-  fence,
-  renderNextSteps,
-  renderPreamble,
-  type WorkflowContext
-} from '../workflow-context'
-
-export function renderPlan(c: WorkflowContext): string {
-  return `${c.frontmatter('创建新计划并维护单当前计划 + preparing 队列结构')}\
-# ${c.invoke('plan')} {描述}
-
-${renderPreamble(c, 'plan', `创建新的执行计划，写入 ${code('.agent-context/plan-{number}/plan.md')}。按复杂度可拆分为多个计划，维护「单当前计划 + preparing 队列」结构。`)}
-
-## 前置规则
-
-- 描述为空 → 拒绝执行，提示必须附带描述。
-- 存在未归档的已执行当前计划 → 拒绝执行，提示先运行 ${code(c.cmd('done'))}。
-- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。
-- 编号：扫描 ${code('.agent-context/{,preparing/,done/}')} 全部 ${code('plan-N')}，取 max(N)+1，不复用。
-
-## 执行步骤
-
-1. **需求澄清**（存在以下任一歧义时必须向用户提问，否则直接跳到步骤 2）：
-   - 范围边界不清：无法判定影响哪些文件或模块。
-   - 存在显著不同的技术路径需用户决策。
-   - 验收标准不明确：无法判断何时算"完成"。
-2. 按复杂度决定单计划或多计划拆分。
-3. 多计划拆分时：最小编号进入 ${code('.agent-context/')} 作为当前计划，其余进入 ${code('.agent-context/preparing/')}。单计划直接创建到 ${code('.agent-context/plan-{number}')}。
-4. 每个计划创建 ${code('plan.md')}，遵循下方标准模板。
-5. **计划自检**（不通过则修改后重新检查）：
-   - 每个步骤可独立执行且有明确完成标准。
-   - 不存在过度拆分（过于琐碎）或拆分不足（单步骤过于复杂）。
-   - 影响范围可预估。
-
-## plan.md 标准模板
-
-${fence}markdown
-# {计划名称}
-
-> 状态: 未执行
-
-## 目标
-
-{明确的目标描述}
-
-## 内容
-
-{详细的实施步骤和内容}
-
-## 影响范围
-
-- 新增文件: \`/path/to/file\`
-- 修改文件: \`/path/to/file\`
-- 删除文件: \`/path/to/file\`
-
-## 历史补丁
-
-- patch-1: {补丁名称}
-${fence}
-
-- 状态行唯一，仅允许 ${code('未执行')} 或 ${code('已执行')}。
-- ${code('## 目标')} 与 ${code('## 内容')} 不可为空。
-- ${code('## 影响范围')} 与 ${code('## 历史补丁')} 创建时留空，分别由 ${code(c.cmd('implement'))} 和 ${code(c.cmd('patch'))} 写入。
-
-${renderNextSteps(c, [
-  { command: 'implement', description: '实施当前计划' },
-  { command: 'replan', description: '调整计划' }
-])}`
-}

package/src/domain/workflow-templates/replan.ts

@@ -1,36 +0,0 @@
-import { code, renderNextSteps, renderPreamble, type WorkflowContext } from '../workflow-context'
-
-export function renderReplan(c: WorkflowContext): string {
-  return `${c.frontmatter('重规划未实施计划，保持单当前计划结构不变')}\
-# ${c.invoke('replan')} {描述}
-
-${renderPreamble(c, 'replan', `重新规划已有的未实施计划（${code('preparing/')} 队列或未执行的当前计划），保持单当前计划结构不变。`)}
-
-## 前置规则
-
-- 描述为空 → 拒绝执行。
-- 无未实施计划 → 拒绝执行，提示使用 ${code(c.cmd('plan'))} 创建。
-- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。
-- 目标计划编号不存在 → 拒绝执行，列出可选编号。
-- 目标计划已执行 → 拒绝执行，提示使用 ${code(c.cmd('patch'))} 修补。
-- 重规划后违反单当前计划约束 → 回滚并报错。
-
-## 作用域规则
-
-- 默认作用域：${code('.agent-context/preparing/')} 中全部未实施计划。
-- 可通过描述指定仅重规划部分计划（如"重规划 plan-3 和 plan-5"）。
-- 当前计划为 ${code('已执行')} → 禁止重写，仅允许重规划 ${code('preparing/')} 队列。
-- 当前计划为 ${code('未执行')} 且用户明确要求 → 可纳入重规划范围。
-
-## 执行步骤
-
-1. 解析描述，确定重规划目标范围。
-2. 读取目标计划 ${code('plan.md')}，理解现有意图。
-3. 生成新的拆分方案，保持"单当前计划 + 若干 preparing 计划"结构。
-4. 新增计划编号：全局 max(N)+1 递增分配；未改动计划保持原编号。
-5. 更新目录结构，确保每个新计划的 ${code('plan.md')} 遵循标准模板。
-
-${renderNextSteps(c, [
-  { command: 'implement', description: '实施当前计划' }
-])}`
-}