req-tpm: README 默认英文，并接入顶层 README

README.md

@@ -43,9 +43,9 @@ Inside a Claude Code session:
 /plugin install ronny --marketplace MiniMax-AI/mcode-stack
 ```
 
-Use `jiachen` in place of `ronny` for that stack. From a clone of this
+Use `jiachen` or `req-tpm` in place of `ronny` for those stacks. From a clone of this
 repository, `scripts/install.sh` installs `ronny` (`scripts/install.sh jiachen`
-for that stack) with `claude` or `codex` when either is on `PATH`, and
+or `scripts/install.sh req-tpm` for the others) with `claude` or `codex` when either is on `PATH`, and
 otherwise copies that stack's skills into `~/.agents/skills/`.
 
 Older Claude Code can add the marketplace first, then install:
@@ -63,7 +63,7 @@ codex plugin marketplace add MiniMax-AI/mcode-stack
 codex plugin add ronny@mcode-stack
 ```
 
-Substitute `jiachen` the same way. To take a single skill instead of the
+Substitute `jiachen` or `req-tpm` the same way. To take a single skill instead of the
 plugin, copy that skill's folder into `~/.agents/skills/`. Codex and MiniMax
 Code both scan that directory; the copy steps are below.
 
@@ -152,6 +152,17 @@ out of them, and [`making-content`](stacks/jiachen/skills/making-content/SKILL.m
 which turns notes and material into Xiaohongshu image posts and short vertical
 videos.
 
+[`stacks/req-tpm`](stacks/req-tpm/) is an optional stack for requirement
+management. The person who raises a product or technical requirement acts as
+its TPM together with their own agent: challenge it at intake and fix a
+measurable expected outcome, get a priority decision from the owner, record
+the design decision, track it on a cadence and flag stale items, pass ship
+gates, and close only with evidence against the expected outcome. The body
+lives in a Feishu doc; status and flow live in Meegle (Feishu Project). It is
+v0 and needs the `meegle` and `lark-cli` CLIs plus a one-time look-up of your
+Meegle space's fields and states; see
+[`stacks/req-tpm/README.md`](stacks/req-tpm/README.md).
+
 A stack usually has three kinds of things:
 
 | Kind | What it is | How to use it |
@@ -201,8 +212,8 @@ templates/stack-template/   Template for a new stack
 ```
 
 Every stack is also a MiniMax Code plugin package. See
-[`stacks/ronny`](stacks/ronny/) and [`stacks/jiachen`](stacks/jiachen/) for
-what each one contains.
+[`stacks/ronny`](stacks/ronny/), [`stacks/jiachen`](stacks/jiachen/) and
+[`stacks/req-tpm`](stacks/req-tpm/) for what each one contains.
 
 ## Contributing
 

README_ZH.md

@@ -36,7 +36,7 @@ claude plugin install ronny --marketplace MiniMax-AI/mcode-stack
 /plugin install ronny --marketplace MiniMax-AI/mcode-stack
 ```
 
-装 Jiachen 的 stack 时，把 `ronny` 换成 `jiachen`。克隆本仓库后可以跑 `scripts/install.sh`（默认 `ronny`，或 `scripts/install.sh jiachen`）：`PATH` 里有 `claude` 或 `codex` 时，它会执行同样的安装，否则把该 stack 的 Skill 复制到 `~/.agents/skills/`。
+装 Jiachen 的 stack 时，把 `ronny` 换成 `jiachen`；装需求管理的 stack 时换成 `req-tpm`。克隆本仓库后可以跑 `scripts/install.sh`（默认 `ronny`，或 `scripts/install.sh jiachen`、`scripts/install.sh req-tpm`）：`PATH` 里有 `claude` 或 `codex` 时，它会执行同样的安装，否则把该 stack 的 Skill 复制到 `~/.agents/skills/`。
 
 较旧的 Claude Code 可以先加市场，再安装：
 
@@ -120,6 +120,8 @@ MiniMax Code 会自动发现这几个目录里的 Skill（每个 Skill 一个子
 
 上表是 [`stacks/ronny`](stacks/ronny/) 的内容。[`stacks/jiachen`](stacks/jiachen/) 里还有：[`lifting-loops`](stacks/jiachen/skills/lifting-loops/SKILL.md) 找出你总在给 agent 当「人工环节」的那些循环，帮你从里面抽身；[`making-content`](stacks/jiachen/skills/making-content/SKILL.md) 把笔记和素材做成小红书图文和竖版短视频。
 
+[`stacks/req-tpm`](stacks/req-tpm/README_ZH.md) 是一份可选的需求管理 stack：谁提的产品或技术需求，谁就和自己的 agent 一起当这条需求的 TPM。受理时先追问该不该做，写死可衡量的预期效果；优先级交给负责人拍板；记下方案决策；按节奏跟进，停滞的显式标出来；上线前过检查项；最后拿证据对照预期效果才关闭。需求正文放飞书文档，状态和流转放飞书项目（Meegle）。目前是 v0，需要 `meegle` 和 `lark-cli`，并先在自己的 Meegle 空间里查一遍字段和状态，见 [`stacks/req-tpm/README_ZH.md`](stacks/req-tpm/README_ZH.md)。
+
 每个 stack 里一般有三类东西：
 
 | 类型 | 是什么 | 怎么用 |
@@ -160,7 +162,7 @@ community/                  团队外的 stack，由协作者加进来
 templates/stack-template/   新增 stack 用的模板
 ```
 
-每份 stack 本身也是一个 MiniMax Code 插件包，具体内容见 [`stacks/ronny`](stacks/ronny/) 和 [`stacks/jiachen`](stacks/jiachen/)。
+每份 stack 本身也是一个 MiniMax Code 插件包，具体内容见 [`stacks/ronny`](stacks/ronny/)、[`stacks/jiachen`](stacks/jiachen/) 和 [`stacks/req-tpm`](stacks/req-tpm/README_ZH.md)。
 
 ## 参与贡献
 

stacks/README.md

@@ -8,7 +8,7 @@ MiniMax Code plugin package.
 | --- | --- | --- |
 | [`ronny`](ronny/) | Ronny, R&D lead | Skills and plain-text checklists |
 | [`jiachen`](jiachen/) | Jiachen, engineer | Skills and a `WORKFLOW.md` |
-| [`req-tpm`](req-tpm/) | MiniMax Code team | Optional v0 requirement-management stack: skills, templates and a `WORKFLOW.md` |
+| [`req-tpm`](req-tpm/) | MiniMax Code team | Optional, v0: the requester and their agent act as a requirement's TPM (Feishu doc body, Meegle status). Skills, templates and a `WORKFLOW.md` |
 
 Teammates are welcome to add their own; see below.
 

stacks/req-tpm/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "req-tpm",
   "displayName": "Requirement TPM",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Requirement management where the requester and their agent act as the requirement's TPM: intake with a measurable expected outcome, priority recommendation for the owner, design decision record, cadence tracking that flags stale items, ship readiness, and evidence-based outcome review. Body in a Feishu doc, status in Meegle.",
   "author": {
     "name": "MiniMax Code team"

stacks/req-tpm/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "req-tpm",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Requirement management where the requester and their agent act as the requirement's TPM: intake with a measurable expected outcome, priority recommendation for the owner, design decision record, cadence tracking that flags stale items, ship readiness, and evidence-based outcome review. Body in a Feishu doc, status in Meegle.",
   "author": {
     "name": "MiniMax Code team"

stacks/req-tpm/.minimax-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "name": "req-tpm",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "displayName": "Requirement TPM",
   "description": "Requirement management where the requester and their agent act as the requirement's TPM: intake with a measurable expected outcome, priority recommendation for the owner, design decision record, cadence tracking that flags stale items, ship readiness, and evidence-based outcome review. Body in a Feishu doc, status in Meegle.",
   "author": "MiniMax Code team",

stacks/req-tpm/README.md

@@ -1,46 +1,77 @@
 # req-tpm
 
-让需求提出人和自己的 Agent 一起，当这个需求的 TPM：从提出到效果验收，全程有文档、有工作项、有人在跟，不会悄悄丢掉。
+English | [中文](README_ZH.md)
 
-需求正文放飞书文档，状态和流转放飞书项目（Meegle）。每个 skill 都可以单独装、单独用，同时维护两边。
+`req-tpm` lets the person who raises a requirement act as its TPM, together
+with their own agent. Every product or technical requirement gets a doc, a
+work item and someone following it, from intake to the outcome review, so
+nothing gets dropped quietly.
 
-## 生命周期
+The requirement body lives in a Feishu doc. Status and flow live in Meegle
+(Feishu Project). Each skill installs and runs on its own, and keeps both
+sides in step.
+
+> **v0, optional.** This stack has not yet been run against a real Meegle
+> space. The field mapping separates keys confirmed in the `meegle` CLI's own
+> docs from project-specific fields, roles and states, which are assumptions
+> until you look them up in your space.
+
+## Lifecycle
 
 ```mermaid
 flowchart LR
-  A[req-intake<br/>该不该做<br/>预期效果] --> B[req-prioritize<br/>成本/影响/风险<br/>负责人拍板]
-  B --> C[req-design<br/>选项与决策<br/>波及面/检查点]
-  C --> D[req-track<br/>进展/阻塞/下一步<br/>停滞显式标出]
-  D --> E[req-ship<br/>回滚/可观测/DoD<br/>推进状态]
-  E --> F[req-outcome<br/>对照预期效果<br/>有证据才关闭]
-  F -- 未达成 --> C
-  A -- 建议不做 --> X[关闭并记录原因]
-  D -. 停滞 .-> D
+  A[req-intake<br/>worth doing?<br/>expected outcome] --> B[req-prioritize<br/>cost / impact / risk<br/>owner decides]
+  B --> C[req-design<br/>options and decision<br/>blast radius / checkpoints]
+  C --> D[req-track<br/>progress / blockers / next step<br/>flag stale items]
+  D --> E[req-ship<br/>rollback / observability / DoD<br/>move status]
+  E --> F[req-outcome<br/>compare with expected outcome<br/>close only with evidence]
+  F -- not met --> C
+  A -- recommend not doing --> X[close and record why]
+  D -. stale .-> D
 ```
 
-| 阶段 | Skill | 产出写到文档哪一节 |
+| Phase | Skill | Writes to doc sections |
 | --- | --- | --- |
-| 受理 | `req-intake` | 1–3 |
-| 排期 | `req-prioritize` | 4 |
-| 方案 | `req-design` | 5–6 |
-| 跟进 | `req-track` | 7 |
-| 上线 | `req-ship` | 8 |
-| 验收 | `req-outcome` | 9 |
+| Intake | [`req-intake`](skills/req-intake/SKILL.md) | 1–3 |
+| Prioritize | [`req-prioritize`](skills/req-prioritize/SKILL.md) | 4 |
+| Design | [`req-design`](skills/req-design/SKILL.md) | 5–6 |
+| Track | [`req-track`](skills/req-track/SKILL.md) | 7 |
+| Ship | [`req-ship`](skills/req-ship/SKILL.md) | 8 |
+| Outcome | [`req-outcome`](skills/req-outcome/SKILL.md) | 9 |
+
+## Rules we follow
 
-## 几条规则
+- The expected outcome is fixed at intake: metric, baseline, target, how we
+  measure it, and the observation window. The requirement is judged against it
+  at the end.
+- The requester recommends; the owner decides priority. The agent does not
+  change the priority of someone else's requirement.
+- A stale item is information. It goes to the top of the report. We don't
+  nudge people automatically, and we don't stay silent either.
+- Shipping is not done. A requirement closes only with evidence of the
+  outcome.
+- Anything visible to others (comments, @-mentions, status transitions) is
+  shown to the requester first and runs only after they confirm.
 
-- 预期效果在受理时就写死：指标、基线、目标、测法、观察窗口。最后用它验收。
-- 提出人提建议，负责人做优先级决定。Agent 不改别人需求的优先级。
-- 停滞本身是一条信息：报告里置顶，不自动催人，也不沉默。
-- 上线不等于完成。只有拿到效果证据才关闭。
-- 对外可见的写操作（评论、@人、状态流转）先给提出人看，确认后执行。
+## Dependencies
 
-## 依赖
+- The `meegle` CLI (Feishu Project), logged in. Fields and states are in
+  [`templates/meegle-field-mapping.md`](templates/meegle-field-mapping.md);
+  replace every entry marked as an assumption before the first real write.
+- `lark-cli`, reading and writing Feishu docs as the user (`--as user`).
+- The requirement doc template:
+  [`templates/requirement-doc.md`](templates/requirement-doc.md).
 
-- `meegle` CLI（飞书项目），已登录；字段和状态见 [`templates/meegle-field-mapping.md`](templates/meegle-field-mapping.md)。
-- `lark-cli`，以用户身份（`--as user`）读写飞书文档。
-- 需求文档模板：[`templates/requirement-doc.md`](templates/requirement-doc.md)。
+## Usage
 
----
+Install the whole stack:
+
+```bash
+claude plugin install req-tpm --marketplace MiniMax-AI/mcode-stack
+codex plugin add req-tpm@mcode-stack     # after: codex plugin marketplace add MiniMax-AI/mcode-stack
+scripts/install.sh req-tpm               # from a clone of this repository
+```
 
-**English.** `req-tpm` lets whoever raises a requirement act as its TPM together with their own agent: challenge it at intake and write a measurable expected outcome, get a priority decision from the owner, record the design decision and blast radius, track status on a cadence and flag stale items, check rollback/observability/DoD before shipping, and close only with evidence against the expected outcome. The body lives in a Feishu doc; status lives in Meegle (Feishu Project). Each skill installs on its own.
+Or copy one skill, such as `stacks/req-tpm/skills/req-intake`, into
+`~/.agents/skills/`. Start with `/req-intake` when someone raises a
+requirement. [`WORKFLOW.md`](WORKFLOW.md) lists which skill fits which moment.

stacks/req-tpm/README_ZH.md

@@ -0,0 +1,48 @@
+# req-tpm
+
+[English](README.md) | 中文
+
+让需求提出人和自己的 Agent 一起，当这个需求的 TPM：从提出到效果验收，全程有文档、有工作项、有人在跟，不会悄悄丢掉。
+
+需求正文放飞书文档，状态和流转放飞书项目（Meegle）。每个 skill 都可以单独装、单独用，同时维护两边。
+
+## 生命周期
+
+```mermaid
+flowchart LR
+  A[req-intake<br/>该不该做<br/>预期效果] --> B[req-prioritize<br/>成本/影响/风险<br/>负责人拍板]
+  B --> C[req-design<br/>选项与决策<br/>波及面/检查点]
+  C --> D[req-track<br/>进展/阻塞/下一步<br/>停滞显式标出]
+  D --> E[req-ship<br/>回滚/可观测/DoD<br/>推进状态]
+  E --> F[req-outcome<br/>对照预期效果<br/>有证据才关闭]
+  F -- 未达成 --> C
+  A -- 建议不做 --> X[关闭并记录原因]
+  D -. 停滞 .-> D
+```
+
+| 阶段 | Skill | 产出写到文档哪一节 |
+| --- | --- | --- |
+| 受理 | `req-intake` | 1–3 |
+| 排期 | `req-prioritize` | 4 |
+| 方案 | `req-design` | 5–6 |
+| 跟进 | `req-track` | 7 |
+| 上线 | `req-ship` | 8 |
+| 验收 | `req-outcome` | 9 |
+
+## 几条规则
+
+- 预期效果在受理时就写死：指标、基线、目标、测法、观察窗口。最后用它验收。
+- 提出人提建议，负责人做优先级决定。Agent 不改别人需求的优先级。
+- 停滞本身是一条信息：报告里置顶，不自动催人，也不沉默。
+- 上线不等于完成。只有拿到效果证据才关闭。
+- 对外可见的写操作（评论、@人、状态流转）先给提出人看，确认后执行。
+
+## 依赖
+
+- `meegle` CLI（飞书项目），已登录；字段和状态见 [`templates/meegle-field-mapping.md`](templates/meegle-field-mapping.md)。
+- `lark-cli`，以用户身份（`--as user`）读写飞书文档。
+- 需求文档模板：[`templates/requirement-doc.md`](templates/requirement-doc.md)。
+
+日常怎么挑 skill，见 [`WORKFLOW_ZH.md`](WORKFLOW_ZH.md)。
+
+> v0：还没在真实的 Meegle 空间里跑过。字段映射里标「假设」的部分，要先在你的空间里现查再替换。

stacks/req-tpm/WORKFLOW.md

@@ -1,12 +1,16 @@
-# req-tpm：什么时候用哪个 skill
+# req-tpm: which skill, when
 
-| 时刻 | Skill |
+English | [中文](WORKFLOW_ZH.md)
+
+| Moment | Skill |
 | --- | --- |
-| 有人提了一个需求 | `req-intake` |
-| 迭代规划 / 有人要插队 | `req-prioritize` |
-| 排上了，开发之前 | `req-design` |
-| 每个工作日 / 每周跟进 | `req-track` |
-| 准备上线 | `req-ship` |
-| 观察窗口结束 / 想关单 | `req-outcome` |
+| Someone raises a requirement | `req-intake` |
+| Iteration planning, or someone wants to jump the queue | `req-prioritize` |
+| Scheduled, before development starts | `req-design` |
+| Every workday or weekly follow-up | `req-track` |
+| Getting ready to ship | `req-ship` |
+| Observation window ends, or someone wants to close it | `req-outcome` |
 
-试点期间，我们先在 MiniMax Code 团队内部用，每个需求跑完整条链路后在文档里留一段使用记录，作为开放前的依据。
+During the pilot we use this inside the MiniMax Code team first. After each
+requirement runs the full chain, we leave a short usage note in its doc as
+the basis for opening it up further.

stacks/req-tpm/WORKFLOW_ZH.md

@@ -0,0 +1,14 @@
+# req-tpm：什么时候用哪个 skill
+
+[English](WORKFLOW.md) | 中文
+
+| 时刻 | Skill |
+| --- | --- |
+| 有人提了一个需求 | `req-intake` |
+| 迭代规划 / 有人要插队 | `req-prioritize` |
+| 排上了，开发之前 | `req-design` |
+| 每个工作日 / 每周跟进 | `req-track` |
+| 准备上线 | `req-ship` |
+| 观察窗口结束 / 想关单 | `req-outcome` |
+
+试点期间，我们先在 MiniMax Code 团队内部用，每个需求跑完整条链路后在文档里留一段使用记录，作为开放前的依据。

stacks/req-tpm/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "req-tpm",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Requirement management where the requester and their agent act as the requirement's TPM: intake with a measurable expected outcome, priority recommendation for the owner, design decision record, cadence tracking that flags stale items, ship readiness, and evidence-based outcome review. Body in a Feishu doc, status in Meegle.",
   "author": {
     "name": "MiniMax Code team"