openfeel 1.2.4 → 1.3.1

package/dsh/lib/index.js

@@ -0,0 +1,189 @@
+/**
+ * OpenFeel × DSH — Feel 模式适配器入口
+ *
+ * 本插件是 **OpenFeel 的 DSH 适配版本**，不是独立实现：
+ * 它把 OpenFeel 的 CLI 与 `.openfeel/` 工作区投影到 DeepSeek Harness，
+ * 让 agent 与用户都能在 DSH 内使用 Feel 流程。
+ *
+ * 插件结构（与 OpenFeel 的适配器层约定一致）：
+ *   lib/index.js            插件入口（name / inject / apply）
+ *   lib/adapters/cli.js     CLI 执行器（进程、编码、退出码语义）
+ *   lib/adapters/workspace.js  会话工作区 → OpenFeel 项目根
+ *   lib/adapters/dashboard.js  状态快照与「下一步」决策
+ *   lib/tools/index.js      13 个模型工具
+ *   lib/surface/command.js  `/feel` 人类命令
+ *   lib/surface/prompt.js   Feel 纪律系统提示段
+ *
+ * 设计约束：
+ * - **零运行时依赖**：只用 Node 内置模块，因此不依赖任何 DSH 内部包即可加载。
+ * - **单一权威**：所有状态变更与门禁判定都在 OpenFeel CLI 侧；本插件只做投影。
+ * - **拒绝即信息**：CLI 的门禁拒绝原样透传给模型，附可操作的纠正建议。
+ *
+ * @module openfeel-dsh
+ */
+
+import { FeelCli } from './adapters/cli.js';
+import { resolveWorkspace } from './adapters/workspace.js';
+import { createFeelCommandHandler } from './surface/command.js';
+import { FEEL_PROMPT_NAME, FEEL_PROMPT_ORDER, renderFeelPrompt } from './surface/prompt.js';
+import { createTools } from './tools/index.js';
+
+/** Loader 入口 id。 */
+export const name = 'openfeel-dsh';
+
+/**
+ * 硬依赖的宿主服务。
+ *
+ * 刻意保持最小：`tools` / `commands` / `systemPrompt` 是插件的三个落点。
+ * `skills` 等可选服务不在此列——缺失时插件仍然工作。
+ */
+export const inject = ['tools', 'commands', 'systemPrompt'];
+
+/** 命令定义 id（与包名一致）。 */
+const COMMAND_ID = '@openfeel/dsh/feel';
+
+/**
+ * 归一化插件配置。
+ *
+ * 配置缺失时给出**安全默认值**：
+ * - `command: 'openfeel'`（走 PATH，安装后最常见）。
+ * - `autoPrompt: true`（启用即注入纪律段落）。
+ * - `log: false`（不写 `~/.openfeel/cli/logs/`，避免只读沙箱下失败）。
+ *
+ * @param {Record<string, any> | undefined} raw Loader 传入的配置。
+ * @returns {{ command: string, commandPrefix: string[], timeoutMs: number, log: boolean, autoPrompt: boolean, language: string, cwd: string | undefined }}
+ */
+export function normalizeConfig(raw) {
+  const source = typeof raw === 'object' && raw !== null ? raw : {};
+  const commandPrefix = Array.isArray(source.commandPrefix)
+    ? source.commandPrefix.filter((item) => typeof item === 'string')
+    : [];
+  const timeoutMs = Number.isFinite(source.timeoutMs) && source.timeoutMs > 0 ? Number(source.timeoutMs) : 120_000;
+  return {
+    command: typeof source.command === 'string' && source.command !== '' ? source.command : 'openfeel',
+    commandPrefix,
+    timeoutMs,
+    log: source.log === true,
+    autoPrompt: source.autoPrompt !== false,
+    language: source.language === 'en' ? 'en' : 'zh-CN',
+    cwd: typeof source.cwd === 'string' && source.cwd !== '' ? source.cwd : undefined,
+  };
+}
+
+/**
+ * 取当前正在装配提示的会话 Agent。
+ *
+ * 提示装配期没有直接的 agent/cwd 入参，只能经 `agents.currentInitiator()`
+ * 沿进程内的驱动链反查——`dsh-tool-goal` 用的是同一手法。
+ * `agents` 未挂载或调用失败时返回 `undefined`（提示段据此放弃注入）。
+ *
+ * @param {object} ctx 插件上下文。
+ * @returns {object | undefined} 发起当前装配的 Agent。
+ */
+function currentAgent(ctx) {
+  try {
+    const agents = typeof ctx.get === 'function' ? ctx.get('agents') : undefined;
+    if (agents === undefined || typeof agents.currentInitiator !== 'function') return undefined;
+    return agents.currentInitiator();
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * 插件挂载。
+ *
+ * @param {object} ctx Cordis 上下文（插件私域）。
+ * @param {Record<string, any>} [rawConfig] Loader 传入的配置。
+ */
+export function apply(ctx, rawConfig) {
+  const config = normalizeConfig(rawConfig);
+  const log = typeof ctx.logger === 'function'
+    ? ctx.logger('openfeel-dsh')
+    : {
+      info: (...args) => console.log('[openfeel-dsh]', ...args),
+      warn: (...args) => console.warn('[openfeel-dsh]', ...args),
+      error: (...args) => console.error('[openfeel-dsh]', ...args),
+      debug: () => {},
+    };
+
+  const cli = new FeelCli({
+    command: config.command,
+    commandPrefix: config.commandPrefix,
+    timeoutMs: config.timeoutMs,
+    log: config.log,
+    cwd: config.cwd ?? process.cwd(),
+  });
+
+  /* ── 工具面 ─────────────────────────────────────────────── */
+
+  const tools = createTools({ cli });
+  for (const tool of tools) {
+    ctx.tools.register(tool);
+  }
+
+  /* ── 人类命令面 ─────────────────────────────────────────── */
+
+  ctx.commands.register({
+    definitionId: COMMAND_ID,
+    name: 'feel',
+    description: 'Feel 模式（OpenFeel 流水线治理）：状态 / 需求看板 / 相位推进 / 健康检查',
+    input: {
+      hint: '[status|next|overview|board|recover|health|stage|req|claim|advance|archive|kb|config]',
+      attachments: false,
+    },
+    handler: createFeelCommandHandler({ cli }),
+  });
+
+  /* ── 系统提示面 ─────────────────────────────────────────── */
+
+  if (config.autoPrompt) {
+    ctx.systemPrompt.section({
+      name: FEEL_PROMPT_NAME,
+      order: FEEL_PROMPT_ORDER,
+      // 注意：PromptSection.text 的签名是 `(context: AssembleContext) => string`，
+      // 而 `AssembleContext = { scope?, signal? }` —— **不含 cwd**。
+      // 因此必须经 `agents.currentInitiator()` 反查会话，否则只能用宿主进程 cwd，
+      // 会把「宿主启动目录」误当会话工作区。
+      text: () => {
+        const agent = currentAgent(ctx);
+        const sessionCwd = agent?.session?.header?.cwd;
+        // 拿不到会话且没有显式 cwd 配置 → 不注入（宁可不打扰，也不给错的项目）。
+        if ((typeof sessionCwd !== 'string' || sessionCwd === '') && config.cwd === undefined) return '';
+
+        let resolved;
+        try {
+          resolved = resolveWorkspace(agent === undefined ? {} : { agent }, { fallback: config.cwd });
+        } catch {
+          return '';
+        }
+        // 不回溯：只有会话工作区**本身**是 OpenFeel 项目时才注入 Feel 纪律。
+        // 否则在任意目录开会话都会被灌流程提示（这正是曾经的误报来源）。
+        if (!resolved.initialized) return '';
+        return renderFeelPrompt({ projectRoot: resolved.projectRoot, detected: true, language: config.language });
+      },
+    });
+  }
+
+  /* ── 启动自检（非阻断） ─────────────────────────────────── */
+
+  void cli
+    .probeVersion()
+    .then((version) => {
+      if (version === undefined) {
+        log.warn(
+          `未检测到 OpenFeel CLI（命令 "${config.command}"）。Feel 工具会返回可操作的安装指引；` +
+            '安装后执行 npm install -g openfeel 即可，无需重启宿主。',
+        );
+        return;
+      }
+      log.info(`已就绪：OpenFeel CLI ${version}；注册 ${tools.length} 个工具、1 个 /feel 命令。`);
+    })
+    .catch(() => {
+      /* 自检失败不影响挂载 */
+    });
+
+  log.debug?.(`Feel 适配器已挂载：command=${config.command} timeoutMs=${config.timeoutMs} autoPrompt=${config.autoPrompt}`);
+}
+
+export { FeelCli, resolveWorkspace };

package/dsh/lib/surface/command.js

@@ -0,0 +1,186 @@
+/**
+ * OpenFeel × DSH 适配器 — `/feel` 人类命令
+ *
+ * 面向**人**的命令面：直接转发到 OpenFeel CLI 并把输出回显到会话。
+ * 与工具面的区别：工具面给 agent 用结构化 JSON；命令面给人用 OpenFeel
+ * 原生的可读输出（看板、健康报告、阶段状态）。
+ *
+ * 门禁不在适配器里判：写操作一律交给 CLI，拒绝原因原样回显。
+ */
+
+import { FeelError } from '../adapters/cli.js';
+import { resolveWorkspace } from '../adapters/workspace.js';
+
+/** 命令用法（帮助文本）。 */
+export const FEEL_USAGE = [
+  'Feel 模式（OpenFeel × DSH）— 用法：',
+  '',
+  '  /feel                      查看帮助',
+  '  /feel status               流水线状态摘要',
+  '  /feel next                 下一步该谁做',
+  '  /feel overview             全状态可视化',
+  '  /feel board                需求看板（7 状态）',
+  '  /feel recover              跨会话上下文恢复',
+  '  /feel health [--fix]       健康检查（可回写 status.md 状态字段）',
+  '  /feel stage [<id>]         阶段状态（省略 id 列出全部）',
+  '  /feel req <id>             需求详情',
+  '  /feel advance <stage> <to> 推进相位（受转移表 / done 门 / REV 阻塞约束）',
+  '  /feel claim <REQ-NNN>      认领需求',
+  '  /feel archive list         已归档版本',
+  '  /feel kb <query>           检索知识库',
+  '  /feel config               查看有效配置',
+  '',
+  '所有能力同样以工具形式提供给 agent（feel_status / feel_flow / feel_req / ...）。',
+].join('\n');
+
+/**
+ * 简单分词（支持双引号包裹的参数）。
+ * @param {string} input
+ * @returns {string[]}
+ */
+export function tokenize(input) {
+  /** @type {string[]} */
+  const tokens = [];
+  let current = '';
+  let quote = null;
+  for (const ch of input) {
+    if (quote !== null) {
+      if (ch === quote) {
+        quote = null;
+        continue;
+      }
+      current += ch;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (current !== '') {
+        tokens.push(current);
+        current = '';
+      }
+      continue;
+    }
+    current += ch;
+  }
+  if (current !== '') tokens.push(current);
+  return tokens;
+}
+
+/**
+ * 创建 `/feel` 命令的处理器。
+ *
+ * @param {object} context
+ * @param {import('../adapters/cli.js').FeelCli} context.cli
+ * @returns {(invocation: { agent: object, rawInput: string }) => Promise<{ kind: 'success'|'error', text: string }>}
+ */
+export function createFeelCommandHandler(context) {
+  const { cli } = context;
+
+  return async function handleFeelCommand(invocation) {
+    const tokens = tokenize(invocation.rawInput ?? '');
+    const sub = (tokens[0] ?? '').toLowerCase();
+    const rest = tokens.slice(1);
+
+    if (sub === '' || sub === 'help') {
+      return { kind: 'success', text: FEEL_USAGE };
+    }
+
+    /** @param {object} execLike */
+    const workspaceOf = (execLike) => {
+      const resolved = resolveWorkspace(execLike, { fallback: cli.cwd });
+      if (!resolved.initialized) {
+        throw new FeelError(
+          `当前工作区 ${resolved.projectRoot} 不是 OpenFeel 项目（缺少 .openfeel/）。请先执行 \`openfeel init\`。`,
+          { kind: 'refusal', code: 'FEEL_NOT_INITIALIZED' },
+        );
+      }
+      return resolved.projectRoot;
+    };
+
+    const execLike = { agent: invocation.agent };
+    let cwd;
+    try {
+      cwd = workspaceOf(execLike);
+    } catch (error) {
+      return { kind: 'error', text: messageOf(error) };
+    }
+
+    /** @param {string[]} args */
+    const runText = async (args) => {
+      const result = await cli.run(args, { cwd });
+      if (result.code !== 0) throw cli.errorFromResult(result, args);
+      return result.stdout;
+    };
+
+    try {
+      switch (sub) {
+        case 'status':
+          return { kind: 'success', text: await runText(['flow', 'status']) };
+        case 'overview':
+          return { kind: 'success', text: await runText(['flow', 'overview']) };
+        case 'board':
+          return { kind: 'success', text: await runText(['req', 'board']) };
+        case 'recover':
+          return { kind: 'success', text: await runText(['flow', 'recover']) };
+        case 'next': {
+          const next = await runText(['req', 'next']);
+          const flow = await cli.run(['flow', 'current'], { cwd });
+          const parts = [flow.stdout, '', '可接取需求：', next];
+          return { kind: 'success', text: parts.filter((part) => part.trim() !== '').join('\n') };
+        }
+        case 'health': {
+          const argv = ['flow', 'health', ...rest];
+          return { kind: 'success', text: await runText(argv) };
+        }
+        case 'stage': {
+          const argv = rest.length === 0 ? ['stage', 'status'] : ['stage', 'status', rest[0]];
+          return { kind: 'success', text: await runText(argv) };
+        }
+        case 'req': {
+          const id = rest[0];
+          if (id === undefined) return { kind: 'error', text: '用法：/feel req <REQ-NNN>\n\n' + FEEL_USAGE };
+          return { kind: 'success', text: await runText(['req', 'show', id]) };
+        }
+        case 'claim': {
+          const id = rest[0];
+          if (id === undefined) return { kind: 'error', text: '用法：/feel claim <REQ-NNN>' };
+          return { kind: 'success', text: await runText(['req', 'claim', id]) };
+        }
+        case 'advance': {
+          const [stage, to] = rest;
+          if (stage === undefined || to === undefined) {
+            return { kind: 'error', text: '用法：/feel advance <stage> <phase>\n\n合法相位见 /feel status 或 openfeel flow phases。' };
+          }
+          return { kind: 'success', text: await runText(['flow', 'advance', '--stage', stage, '--to', to]) };
+        }
+        case 'archive': {
+          const argv = rest[0] === 'list' ? ['flow', 'archive', 'list'] : ['flow', 'archive', 'list'];
+          return { kind: 'success', text: await runText(argv) };
+        }
+        case 'kb': {
+          const query = rest.join(' ').trim();
+          if (query === '') return { kind: 'error', text: '用法：/feel kb <关键词>' };
+          return { kind: 'success', text: await runText(['knowledge', 'search', query]) };
+        }
+        case 'config':
+          return { kind: 'success', text: await runText(['config', 'effective']) };
+        default:
+          return { kind: 'error', text: `未知子命令「${sub}」。\n\n${FEEL_USAGE}` };
+      }
+    } catch (error) {
+      return { kind: 'error', text: messageOf(error) };
+    }
+  };
+}
+
+/**
+ * 取错误消息。
+ * @param {unknown} error
+ * @returns {string}
+ */
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}

package/dsh/lib/surface/prompt.js

@@ -0,0 +1,131 @@
+/**
+ * OpenFeel × DSH 适配器 — 系统提示段落
+ *
+ * 本段落只在 Feel 模式启用时注入，用来教会 agent **OpenFeel 的纪律**，
+ * 而不是重复工具说明。原则来自 OpenFeel 的 `feel` 角色定义与 AGENTS.md：
+ *
+ * - 调度者不是执行者：先判断「该谁做」。
+ * - `pipeline.phase` 只是宏观态；调度目标是 `phase != done` 的**活跃阶段**。
+ * - 禁止手改 `flow.json` / `status.md`；一切写入经 CLI，门禁才有权威。
+ * - 门禁拒绝是**预期结果**，据其纠正，不得绕过。
+ */
+
+/** 段落放置顺序：紧跟工具说明，位于长上下文之前。 */
+export const FEEL_PROMPT_ORDER = 40;
+
+/** 段落名（稳定标识；同层重名会抛错）。 */
+export const FEEL_PROMPT_NAME = 'feel-mode';
+
+/**
+ * 生成系统提示段落正文。
+ *
+ * @param {object} [options]
+ * @param {string} [options.projectRoot] 当前项目根（用于指路）。
+ * @param {boolean} [options.detected] 是否检测到 .openfeel/。
+ * @param {string} [options.language] 'zh-CN' | 'en'。
+ * @returns {string}
+ */
+export function renderFeelPrompt(options = {}) {
+  const language = options.language ?? 'zh-CN';
+  if (language === 'en') return renderEnglish(options);
+  return renderChinese(options);
+}
+
+/**
+ * 中文段落。
+ * @param {{ projectRoot?: string, detected?: boolean }} options
+ * @returns {string}
+ */
+function renderChinese(options) {
+  const where = options.detected === true && options.projectRoot !== undefined
+    ? `当前项目：\`${options.projectRoot}\`（已初始化 \`.openfeel/\`）。`
+    : '当前工作区尚未检测到 `.openfeel/`：若用户要求使用 Feel 流程，先提示运行 `openfeel init`。';
+
+  return `<feel_mode>
+Feel 模式已启用：本会话在 OpenFeel 流程治理下工作。${where}
+
+## 你的角色：调度者，不是执行者
+你的价值是判断「该谁做」，而不是自己做。OpenFeel 的 15 个相位各有负责 Agent：
+planner（计划）/ schemer（方案）/ executor（执行）/ reviewer（审查）/ feel-tester（测试）/ archiver（归档）。
+**具体映射由 \`flow next --json\` 权威给出**，本适配器不维护本地映射。
+Feel（你）只做编排、决策与门禁判断。
+
+## 每次动手前
+1. 调 \`feel_status\` 读快照：宏观相位、**每个阶段的相位**、当前模式与来源、该阶段在此模式下的**合法下一相位**、负责 Agent。
+2. 调 \`feel_next\` 拿「下一步该谁做」的明确建议（含合法下一相位、推荐工具调用、OpenFeel 交接标记）。
+3. 按建议派发（DSH 用 \`subagent\` / \`workflow\` 工具），或经 \`feel_flow action=advance\` 推进。
+
+## 不可违背的纪律
+- **调度目标是活跃阶段**：\`pipeline.phase\` 只是宏观态（active/paused/done）。多阶段并行时，取 \`phase != done\` 的阶段为调度目标，按依赖与优先级择一推进。
+- **禁止手改 \`flow.json\`**：一切经 \`feel_flow\`（底层 \`openfeel flow\`）。手改会破坏 revision 乐观并发、审计日志与跨文件一致性。
+- **禁止手改 \`status.md\`**：经 \`feel_stage action=set\` / \`action=task\`（底层 \`openfeel stage\`）。
+- **门禁拒绝是预期结果**：相位不合法、done 门未过、blocking REV 未关，都是流程在保护你。读拒绝原因 → 纠正 → 重试；**不要**用 \`force\` 绕过（\`--force\` 也只能跳过相位合法性，**不能**绕过 blocking REV 门与版本归档判据）。
+- **退出码 2 = 并发冲突，可重试**：先重读状态（\`feel_status\` 或 \`feel_verify action=recover\`）再重试。
+- **错误分类看 JSON envelope**：\`--json\` 失败的 \`error.kind\` / \`error.code\` / \`error.detail\` 是权威；退出码 3 = 内部故障。
+- **manual 模式先问**：当 \`auto_advance=disabled\` 时，推进到下一相位前必须询问用户，禁止静默推进。
+- **归档判据不可协商**：版本归档要求该版本**全部阶段 done** 且**无 blocking open REV**，没有 force 覆盖。归档由 CLI 执行，调度侧只提示不代劳。
+- **不主动读归档**：常规调度不要读 \`.openfeel/flow-archive/**\`（防上下文污染）；需要历史时用 \`feel_archive action=show\`。
+
+## 三种工作流模式
+- \`full\`：plan → plan_review → scheme → exec → review → test → archive，六道关全走。
+- \`fast\`：跳过 \`scheme_*\` 与 \`test_*\`；**计划审查与代码审查各保留一轮**（fast 不等于免审）。
+- \`general\`：无流水线（空转移表），按需直接调度通用工作者；**仅需求级合法**，阶段级/部署级会拒绝。
+
+## 需求分发
+需求是排期层（\`REQ-NNN\`，7 状态：draft/scheduled/in_progress/done/blocked/cancelled/rejected）。
+接取流程：\`feel_req action=next\` → \`claim\` → \`link\` 到阶段 → 阶段推进驱动聚合 → 全部关联阶段 done 时需求自动收口。
+\`done\` 门：非 general 需求必须**全部关联阶段 done**；general 需求在零关联阶段时走双完成路径。
+
+## 收尾
+多步骤任务（≥3 步）开始即建 todo 列表并持续更新。阶段推进与需求流转后，向用户汇报「做了什么 / 卡在哪 / 建议下一步」。
+</feel_mode>`;
+}
+
+/**
+ * 英文段落。
+ * @param {{ projectRoot?: string, detected?: boolean }} options
+ * @returns {string}
+ */
+function renderEnglish(options) {
+  const where = options.detected === true && options.projectRoot !== undefined
+    ? `Project: \`${options.projectRoot}\` (initialized \`.openfeel/\`).`
+    : 'No `.openfeel/` detected in this workspace: if the user asks for the Feel process, suggest `openfeel init` first.';
+
+  return `<feel_mode>
+Feel mode is active: this session works under OpenFeel process governance. ${where}
+
+## Your role: orchestrator, not implementer
+Your value is deciding WHO acts, not acting yourself. The 15 pipeline phases each have an owning agent:
+planner / schemer / executor / reviewer / feel-tester / archiver. **The authoritative mapping comes from
+\`flow next --json\`**; this adapter keeps no local copy. You (Feel) only orchestrate, decide, and read gates.
+
+## Before acting
+1. Call \`feel_status\` for the snapshot: macro phase, **each stage's phase**, current mode and its source, the **legal next phases** for that stage under its mode, and the responsible agent.
+2. Call \`feel_next\` for an explicit "who does what next" recommendation (legal next phases, suggested tool call, OpenFeel handoff marker).
+3. Dispatch accordingly (DSH \`subagent\` / \`workflow\`), or advance with \`feel_flow action=advance\`.
+
+## Non-negotiable rules
+- **The schedule target is an ACTIVE stage**: \`pipeline.phase\` is only macro state (active/paused/done). With parallel stages, pick a stage whose \`phase != done\` and advance one at a time following deps and priority.
+- **Never hand-edit \`flow.json\`**: go through \`feel_flow\` (the \`openfeel flow\` CLI). Hand edits break revision CAS, the audit log, and cross-file consistency.
+- **Never hand-edit \`status.md\`**: use \`feel_stage action=set\` / \`action=task\`.
+- **Gate refusals are expected**: an illegal phase, an unmet done gate, or an open blocking REV is the process protecting you. Read the reason, correct, retry. Do **not** reach for \`force\`: \`--force\` only skips phase legality; it cannot bypass the blocking-REV gate or the version-archive criteria.
+- **Exit code 2 = concurrent revision conflict, retryable**: re-read state (\`feel_status\` or \`feel_verify action=recover\`), then retry.
+- **Classify failures from the JSON envelope**: \`--json\` failures carry \`error.kind\` / \`error.code\` / \`error.detail\`; exit code 3 = internal error.
+- **Ask before advancing under manual mode**: when \`auto_advance=disabled\`, ask the user before advancing; never advance silently.
+- **Archive criteria are not negotiable**: a version archive requires every stage of that version to be \`done\` AND no blocking open REV; there is no force override. The CLI performs the archive; you only prompt.
+- **Do not read archives during normal scheduling**: avoid \`.openfeel/flow-archive/**\`; use \`feel_archive action=show\` on demand.
+
+## The three workflow modes
+- \`full\`: plan → plan_review → scheme → exec → review → test → archive (all six gates).
+- \`fast\`: skips \`scheme_*\` and \`test_*\`; **plan review and code review each keep one round** (fast is not review-free).
+- \`general\`: no pipeline (empty transition table), dispatch general workers on demand; requirement-level only.
+
+## Requirement distribution
+Requirements are the scheduling layer (\`REQ-NNN\`, 7 statuses: draft/scheduled/in_progress/done/blocked/cancelled/rejected).
+Flow: \`feel_req action=next\` → \`claim\` → \`link\` to a stage → stage advancement drives aggregation → auto-close when every linked stage is done.
+The \`done\` gate: a non-general requirement needs ALL linked stages done; a general requirement with zero linked stages uses the dual completion path.
+
+## Wrap-up
+Create a todo list at the start of any multi-step task (≥3 steps) and keep it current. After advancing a phase or requirement, report what changed, what blocked, and the suggested next step.
+</feel_mode>`;
+}