feature-tracker-mcp
feature-tracker-mcp
一个与项目无关的功能与决策追踪器,专为一个人同时指挥多个 AI 编码会话并成为瓶颈的场景而构建。
它要解决的问题不是"追踪功能"。而是:你有多个轨道线同时进行,每个会话对其他会话一无所知,决策不断涌现,而阅读所有内容成了你的工作。这些决策大多平凡且可委托。少数真正属于你。如今没有任何机制把它们区分开来,所以你只能全部阅读。
这就是那个机制。
目录
Related MCP server: Waystone
角色
角色 | 职责 |
Claude | 编写代码 |
ChatGPT | 管理工作 — 功能、子功能、排序、需要缓解的风险 |
你 | 只回答关键问题:架构、花费、任何不可逆的事项 |
这个分工的意义在于,第二行目前是人的工作,而其中几乎不需要人来承担。
形态
flowchart TD
Ideate["/ideate — dialog"] -->|features as they are invented| DB[("project database")]
Session["coding session (Claude)"] -->|every substantive turn| Capture{"implies a feature,<br/>guardrail, schema change<br/>or risk?"}
Capture -->|yes, and not a duplicate| DB
Capture -->|no| Session
DB --> PM["ChatGPT as manager"]
PM -->|next task, in priority order| Session
PM -->|mundane decisions| PM
PM -->|architectural · install · spend| Gate[["gate queue"]]
Gate -->|approve / alter / reject| You([You])
You -->|proceed| Session
DB --> Table["/tracker-table · /standup"]
Table --> You两个属性起了作用:数据库是状态,所以没有任何东西依赖模型记住;门会阻塞,所以"是的,继续"是一个机制,而不是你必须恰好在场才能接住的消息。
现状
诚实的划分,因为本文档的其余部分描述了一个只部分构建的系统。
当前可用 — 8 个 MCP 工具,已针对真实数据库完成端到端验证:
工具 | 作用 |
| 记录功能、护栏、模式变更、风险或缓解。若类别不存在则创建,原子分配 id,除非强制否则拒绝疑似重复 |
| 已追踪项,优先级最低的在前,可按状态、类别和种类筛选 |
| 更改状态、标题、正文或优先级;每次更改都落入历史记录 |
| 追加式记录:什么改变了、何时、由谁、针对哪个提交 |
| 将会话不能独自做出的决策排队 — 架构、安装、花费、不可逆 |
| 等待人类的决策。只读 |
| 批准或拒绝,解除提出该决策的会话的阻塞 |
| 按状态和类别计数、待处理的门,以及读取了哪个树 |
**已定义但未构建:**下一节中的每个斜杠命令、持续捕获、执行循环,以及将 markdown 追踪器从数据库重新渲染出来的生成器。
已针对真实项目验证。 从现有的 387 行 markdown 追踪器导入了 75 个功能,每个 id 都保留 — DIP-16、GLG-1、UA-11 以及其余仍然可以解析,因为它们被引用在提交消息和工作树名称中,重新分配它们会使那段历史变成孤儿。类别计数器已推进到超过导入的最高 id,因此已经使用中的 id 不会被再次分配。
动词
每个都是一个技能,所以每个也是一个斜杠命令。这些尚未构建 — 它们是上面工具之上的预期界面。
动词 | 作用 |
| 启动功能生成循环。一个对话框,在功能被发明时将其写下来 |
| 按优先级顺序驱动一个类别的功能完成到完成 |
| 跨轨道状态:什么已移动、什么已过时、什么被阻塞 |
| 每个已追踪项:id、类别、标题、状态、优先级、最后移动时间 |
| 追加式记录,按功能或按会话 |
| 等待你的待批准项 |
| 在当前回合后停止并总结 |
/standup、/tracker-table 和 /gates 是只读的,永远不会消耗工作回合。
模式
构思。 一个对话框,其副产品是填充好的待办列表。功能被发明时立即被数据库,每个都呈现给你同意或修改 — 没有静默落地。这是队列被填满的方式。
执行。 一个类别的功能按优先级顺序一个接一个地被驱动到完成。ChatGPT 选择下一个功能,向编码会话简报,审查返回的内容,然后要么接受它,要么再次发送。
持续捕获。 平凡的部分,也是列表保持真实的原因。每次实质性回合 — 在任何会话中 — 都会被检查它暗示了什么:新表、护栏、CHECK 约束、需要缓解的风险、没人命名的子功能。每个都变成提议的行。替代方案就是今天发生的事情:它被提到一次,滚动消失,然后被昂贵地重新发现。
捕获运行在改变文件或得出结论的回合上。大多数回合不暗示任何东西,对所有回合都运行它,你就会得到一个没人读的待办列表。
脊柱:每个项目一个数据库
每个项目获得自己的 Postgres 数据库,在首次使用时创建,并从项目的 git 远程命名(因此每个项目的每个工作树和每个克隆都同意同一个追踪器)。
表 | 存放 |
| 功能记录时自动创建。拥有 id 计数器 |
| id、类别、标题、正文、种类、状态、优先级 |
| 追加式。每次更改,带有操作者、git 提交、分支、树的时间戳 |
| 审批队列:种类、问题、成本、状态、决策 |
kind 是 feature、guardrail、schema、risk、mitigation 之一。status 运行 proposed → agreed → in_progress → done,或 dropped。
Id 由数据库原子分配。 这不是细节 — 它是对一类真实、反复出现的 bug 的修复。两个会话独立读取文件,看到下一个空闲数字并都取走它,会产生重复的迁移 016 和冲突的 issue 编号。在事务内递增的计数器使这在结构上不可能。
每个事件都记录 git 提交、分支和树。 针对已被重写的提交提出的功能,与针对 HEAD 提出的功能是不同的声明,在没有戳记的情况下,以后谁都无法分辨区别。
类别
类别取代了"轨道"的非正式概念,并在功能记录时生成,而不是预先配置。在新类别下提议功能会创建它,带有自己的 id 前缀和计数器 — 因此 DIP-17 和 GLG-1 共存,既不会碰撞,也不需要集中管理。
门:审批队列
门是工作会话不能独自做出的决策。
种类 | 示例 |
| "这需要一个新的扩展 — 安装它?" |
| 新依赖、新服务 |
| "这次训练运行花费 $40。继续?" |
| 数据丢失、强制推送、任何不可恢复的 |
提出门阻塞提出它的会话。门在一个地方排队,你批准、修改或拒绝,然后会话恢复。这就是把*"这会花费 $40,你同意吗?"*从你必须留意观察的消息变成等待的队列项。
计数与收敛
进度报告为两个运动,绝不是比率:
3/14 -> 5/16 +2 agreed, +2 surfaced分子是共识,衡量收敛。分母增长是健康的 — 新项目意味着发现了真实的分歧,这些分歧一直存在,只是未被说出来。
一个百分比会颠倒这一点。12/16 -> 12/20 读作 75% -> 60%,是下降,但没有任何回归,只是命名了两个真正的问题。单一比率恰恰惩罚了系统存在所期望产生的行为,所以它永远不会被显示。
停止条件
状态 | 测试 | 报告为 |
完成 | 分子达到分母 | 共识 |
停滞 | 分子两轮未移动,无论分母如何 | 停滞,未收敛 |
回归 | 分子下降 — 重新打开 | 大声标记 |
已暂停 | 你暂停了它,或预算耗尽 | 已暂停,可恢复 |
停滞仅根据分子判断。项目浮出水面而没有任何共识,是原地打转,将其报告为进展是浪费一个下午的最快方式。
检查点、暂停与摘要
每两轮循环停止并报告:
NEEDS YOU (1)
· Is the target "one dollar per Track" or "one opportunity live"?
Not a fact — it is what you are optimising.
HANDLED (6 of 7 tracks) +2 agreed, +2 surfaced
filter-decide uncommitted migration 020 — no collision with other tracks
layer-lift 6 behind main, clean rebase available
...你可以在任何时刻说暂停,立即获得摘要,无需等待检查点。没有任何东西在你允许之外无人值守运行 — 自主性从两轮开始,并且只有在赢得信任之后才会延长。
为什么不在 git 中
这个追踪器以前是一个 markdown 文件。在最近的一周里,它从并发 worktree 中占用了 115 个提交,历史记录包含手工解决的编号冲突。在人类写入速率下,版本控制下的单个文件已经是争用点;添加来自多个会话的自动化每轮写入,会使其更糟。
因此数据库是权威的,markdown 变成生成的输出,按需重新生成并排除在版本控制之外。
要刻意接受的后果:git 历史曾经是审计追踪。feature_event 取代了它——仅追加,带有操作者和提交的印记——而这种取代是必需,而非可有可无。否则,你就是用合并冲突换来了失忆。
任何将 markdown 文件指定为权威来源的项目级指令,都必须在同一变更中重写。会话会遵守这些指令;如果有一条指令仍指向旧文件,它们就会继续写入一个没人读的东西。
什么会破坏它
提案泛滥。 跨多个轨道的每轮捕获可能生成数百行低价值行,然后你读到的就是积压日志而不是对话记录——同样的问题换了件衣服。标准很明确:只记录那些否则会丢失的、可操作的、并且尚未被覆盖的内容。去重是强制性的,因为两个会话独立注意到同一个缺失约束是常态,而不是边缘情况。
读错了树。 worktree 是一个独立的检出。把会话指向错误的 worktree,它会自信地报告你的文件缺失、你的更改未完成——而且这种报告读起来像是对代码的发现,而不是配置错误。每个操作都会记录它读取的树,因此不匹配在任何人对它采取行动之前就是可见的。
一个叙述而非计算的管理器。 计数是从数据库计算出来的,无法对不真实的事情说得头头是道。模型写的摘要可以。当两者不一致时,表格胜出。
自主性跑赢了注意力。 当没有人阅读时,累积错误最快变得代价高昂。门禁和检查点就是为此存在的,默认间隔被刻意设得很短。
构建顺序
category、feature、feature_event、gate;按项目创建数据库;原子 ID 分配MCP 工具:propose、list、update、table、history、gate raise/list/decide
持续捕获,带有标准和去重,以及同意或修改审查队列
/standup跨轨道,包括未提交的工作——仅凭提交会漏掉工作真正所在的地方门禁阻断会话
/ideate执行循环按优先级顺序驱动一个 category 完成
Available Tools
64 toolscheckpointA
Record everything agreed in one design session, in a single transaction. A design conversation produces features, risks, data sources and decisions together and they only make sense together; recording them one call at a time leaves a half-captured design if anything fails, and nothing afterwards can tell which rows came from that sitting. Duplicates are reported rather than skipped or forced — being told 'three of your fourteen already exist' is information the design session should see.
Inputs: items (required), cwd, goal, note, +2 more.
confer_digestB
Whether the peer channel is earning its place: where it changed the answer, and where it could not settle something. Both halves are reported, because showing only the first would make the mechanism unfalsifiable.
Inputs: cwd.
confer_historyB
What a subject has been through with a peer, newest first. Omit both filters for the whole project. Read this before re-litigating something — an argument already had and settled is on the record here.
Inputs: cwd, limit, subject_id, subject_kind.
confer_recordA
Record an exchange with a peer model as its own act. Use for a diff review before a feature is marked done — a worker cannot both review its own work and close it in one call, so the review has to exist first — and for any conferral worth keeping that is not attached to another write. The subject must already exist.
Inputs: subject_id (required), subject_kind (required), cwd, conferral.
db_backupA
Dump the project's tracker to .oz/backups and verify it. Take one before any bulk change — a refine pass, a restore, a migration. A dump restores anywhere, unlike a copy of the data directory, and the dump is checked before being reported as a backup: an unverified backup is a file, not a backup.
Inputs: cwd, label.
db_backupsB
Backups on disk, newest first.
Inputs: cwd.
db_restoreA
Restore a backup over the live tracker. DESTRUCTIVE and irreversible: it takes a safety backup first and refuses without confirm: true. Restoring the wrong file over a working tracker is the mistake with no undo.
Inputs: name (required), confirm (required), cwd.
derive_featuresA
Derive a feature checklist for a goal from the documentation and existing features, and put it straight in the backlog at 'proposed' — recorded, not yet agreed. Defining a goal must produce work, not just an objective. Call project_boundaries FIRST: re-proposing something already refused wastes a review round and teaches the principal that the queue does not learn. Candidates matching an existing feature are reported rather than created.
Inputs: goal (required), candidates (required), cwd, note, +2 more.
derive_gapsA
Record what a gap analysis found. Feature gaps land in the backlog at 'proposed' under one proposal, so derive_page/derive_review work on them unchanged. Goal gaps become HARD gates: creating a goal reshapes what every feature hangs off, and gate_reopen cannot unwind it once work routes in, so it stays the principal's however well the pair agrees. Call gap_scan first and check every candidate against the refusals it returns — a settled refusal is a decision, not an oversight. Finding nothing is a real outcome; record it as one rather than manufacturing candidates.
Inputs: cwd, note, actor, scope, +3 more.
derive_listC
Derivations and how far each review has got.
Inputs: cwd, goal.
derive_pageC
A page of a derivation still awaiting review. Deliberately small — a long list gets skimmed, and a skimmed checklist is worse than none because it looks reviewed.
Inputs: id (required), cwd, page, per_page, +1 more.
derive_reviewA
Review backlogged features: promote to 'agreed', reassign, or drop. Rejection means two different things — 'wrong_goal' is a routing error and the feature is still wanted, so it is MOVED not dropped; 'not_wanted' is a decision about the project. A rejection REQUIRES a rationale: accumulated rationales are how the project defines what it is not, and 'no' without a reason cannot be reasoned from.
Inputs: decisions (required), cwd, actor.
directive_ackA
Acknowledge a directive so it stops being returned to this worker.
Inputs: id (required), worker (required), cwd.
directive_issueA
Broadcast stop, pause, resume or rescan to every worker. Broadcast rather than addressed, so a worker that starts after the directive was issued still sees it — the case a point-to-point message silently misses. Scope it to a goal, or omit for all.
Inputs: kind (required), cwd, note, actor, +1 more.
directive_pollA
Directives this worker has not acknowledged. Poll between units of work and obey what comes back: stop means finish the current step and stop, pause means stop and wait for resume.
Inputs: worker (required), cwd, goal.
feature_blockedC
What is waiting, and on what. The mirror of feature_ready.
Inputs: cwd, goal.
feature_claimA
Take a feature to work on, if nobody else holds it. The claim is a LEASE with an expiry, not a flag: a worker that dies holding a flag blocks its feature forever, whereas a lease runs out and the work returns to the pool. Claim before starting, or two workers take the same item and you find out via a merge conflict.
Inputs: id (required), worker (required), cwd, lease_minutes.
feature_historyB
The append-only record: what changed, when, by whom, and against which git commit. This is the audit trail that replaces git history for the tracker itself.
Inputs: id, cwd, limit.
feature_linkA
Record that one feature depends on another. Priority order is meaningless without this: the highest-priority item may be blocked, and handing it to a worker wastes the worker.
Inputs: id (required), depends_on (required), cwd, note.
feature_listB
List tracked items, lowest priority number first. Use before proposing, to avoid duplicates.
Inputs: cwd, goal, kind, limit, +1 more.
feature_proposeA
Record a feature, guardrail, schema change, risk or mitigation so it is not lost. The goal is created if it does not exist, and the id is allocated atomically by the database, so concurrent sessions cannot collide on a number. Only record what would otherwise be lost, is actionable, and is not already tracked -- check feature_list first.
Inputs: goal (required), title (required), cwd, body, +4 more.
feature_readyA
What can be worked right now: not done, nothing it depends on outstanding, and no gate open on it — in goal-priority then feature-priority order. This is what a worker pulls from. Returns skipped_pending_a_gate ALONGSIDE the ready list: a gate clears only when the principal answers it, so the worker skips those and works the rest rather than stalling a whole goal on one question — but it must SAY SO out loud, because silently working around a blocked item looks exactly like having finished the goal.
Inputs: cwd, goal, limit.
feature_reassignA
Move a feature to a different goal. The id never changes, so anything citing it in a commit message or worktree name still resolves; the move is recorded in the history with its reason. Use when a refined objective shows an item does not belong where it was filed.
Inputs: id (required), goal (required), cwd, note, +1 more.
feature_refine_batchA
Set acceptance criteria on many features at once. Most are derivable from the body, the code and the docs, so doing them one at a time spends a round trip per item on work that needed no decision. Anything genuinely undecidable should become a gate rather than a guess.
Inputs: items (required), cwd, actor, conferral.
feature_releaseA
Give up a claim, returning the feature to the pool.
Inputs: id (required), worker (required), cwd.
feature_unblockedA
What a recently answered gate has released. Answering a gate changes a gate row and nothing else, so work it was holding stays invisible unless something looks — this is what a worker calls on resuming. Read each decision_note before starting: it is the answer the work was waiting on.
Inputs: cwd, since_hours.
feature_unlinkB
Remove a dependency between two features.
Inputs: id (required), depends_on (required), cwd.
feature_unrefinedB
Open features with no acceptance criteria — the work list for a refine pass. Until a feature says what done looks like, 'done' is whoever-built-it's opinion.
Inputs: cwd, goal, limit.
feature_updateA
Change a tracked item: status, title, body or priority. Every change is recorded in the append-only history, stamped with the git commit it was made against.
Inputs: id (required), cwd, body, note, +5 more.
gap_scanA
Everything needed to reason about coverage, in one read: every goal's objective, done-means, non-goals and constraints in its own words, what each holds, and every settled refusal. Read-only. This is the input to gap analysis — derive_features asks what ONE goal implies and so can only find work inside a goal somebody already wrote; this asks what the whole set fails to cover, which is the only way a MISSING goal is ever found. Returned unsummarised on purpose: a gap is noticed by reading the actual wording, and does not survive being condensed into counts.
Inputs: cwd.
gate_decideB
Approve or reject a pending gate, unblocking the session that raised it.
Inputs: id (required), decision (required), cwd, note.
gate_decide_batchA
Answer several gates at once, after a question round. Each decision applies independently and is reported separately: answering nine of eleven is a normal outcome, and one bad id must not throw away eight good answers.
Inputs: answers (required), cwd.
gate_listC
Decisions awaiting a human. Read-only; costs no work.
Inputs: cwd, status.
gate_queueA
Every pending decision, oldest first, shaped to be answered in one sitting rather than as interruptions. Carries age, what each gate blocks, the options and the raiser's recommendation — a gate that only asks is a gate that gets deferred. Use this for the periodic question round; it records that each gate was put to the principal.
Inputs: cwd, goal.
gate_raiseA
Raise a decision the working session must not take alone: an architectural choice, an install, a spend, or anything irreversible. The session should stop and wait -- this is how 'this costs $40, are you good with that' becomes a queued question rather than a message someone had to be present to catch.
Inputs: kind (required), question (required), cwd, goal, +7 more.
gate_reconcileA
Re-check a pending gate against the tree as it is now. A gate freezes its question at the moment it was raised and nothing re-reads it, so work that lands afterwards can answer it, invalidate its premise, or build the very thing it asks whether to build -- and it goes on being asked, because the row still says pending. Run this over every pending gate before putting any of them to the principal. 'moot' closes it as settled (never as a decision they did not take, and reversible with gate_reopen); 'repose' rewrites the question and resets asked_count. Both require evidence naming a path or a commit.
Inputs: id (required), verdict (required), evidence (required), cwd, +4 more.
gate_reopenB
Pull back a gate the pair settled. Auto-settling is only safe because it is reversible: two models can be confidently wrong together, and the principal finding that out later needs a lever, not an argument. Reopened gates come back as hard.
Inputs: id (required), cwd, note.
goal_defineA
Create a goal that does not exist yet, at the END of a definition session. The name comes out of the conversation rather than going into it — nobody should have to invent an identifier before working out what the thing is. Follow immediately with goal_refine to record its objective. Check goal_list first: a near-duplicate goal fragments the queue.
Inputs: name (required), cwd.
goal_listA
Categories with their priority, parallelism cap, and item counts. Every feature must belong to one — an uncategorised item is one nobody picks up. Check here before proposing, so a near-duplicate goal is not created alongside an existing one.
Inputs: cwd.
goal_membershipB
Everything filed under a goal, for re-testing membership once its objective is agreed. Imported features inherited their goal from which document heading they sat under — a filing location, not a judgement that the item serves the objective, because at import time there was no objective to test against. Run this after refining a goal that already holds work.
Inputs: name (required), cwd.
goal_pruneA
List categories holding no features, and optionally remove them. Defaults to a dry run: a goal with work is never removed, and Miscellaneous is always kept.
Inputs: cwd, apply.
goal_refineA
Record a goal's objective after a refinement session with the principal. A goal carrying only a name and a priority is a filing label: nothing in it says what is being attempted, so a worker cannot judge whether a feature actually serves it. Do NOT call this mid-discussion — record once, when consensus is reached.
Inputs: name (required), cwd, actor, status, +7 more.
goal_refine_batchA
Refine several goals in one call. Drafting is derivable from each goal's own documentation, so the expensive part is the handful of genuine decisions, not a sitting per goal. Read the source document ONCE and slice it by heading — re-reading it per goal is the same file four times. Draft the lot, record the lot with doc_ref so the next pass has a pointer instead of a search, and raise the questions that remain as gates.
Inputs: goals (required), cwd, actor, conferral.
goal_setB
Set a goal's priority and how many of its features may be worked at once. Parallelism is capped per goal rather than by token budget: the limit that matters is how many things are changing simultaneously.
Inputs: name (required), cwd, priority, max_parallel.
goal_showA
One goal in full — objective, what done means, what is explicitly excluded, constraints — with its item counts. A worker should read this before starting, so it can tell whether what it is about to build actually serves the goal.
Inputs: name (required), cwd.
goal_unrefinedA
Goals with no objective or no definition of done, ordered by how much work they already hold. These cannot be reasoned about: work under them is being ordered without anything saying what it is for. Refine the ones holding the most first. Each row carries its doc_ref where one is known, so the refine pass reads that section rather than searching the tracker markdown for it once per goal.
Inputs: cwd.
oz_shutdownA
Wind the project down and leave it resumable. Broadcasts stop, then stashes every uncommitted change in every worktree — untracked files included — and records where, tying each stash to the feature it belongs to. Does NOT wait for workers: waiting on one that may not poll again turns a wind-down into a vigil, and anything written afterwards is caught by the next run. Use force:true to also release every open claim, which is the 'kill it' form — deliberate, because releasing a live worker's claim invites two workers onto one feature.
Inputs: cwd, note, actor, force.
parity_gapsB
Coverage by dimension: how many features are unknown, missing, partial or satisfied. The cheap probe's target list — it decides where to spend effort, and is not itself the fix.
Inputs: cwd, goal.
parity_scanA
Run the cheap probe for one dimension across every feature and record the result. parity_gaps only reads; this is what makes the states real. A probe decides where to spend effort and is not itself the fix, so it is deliberately narrow: it records what was checked in each row's detail, because 'the id is not mentioned' must never be mistaken for 'the work is not done'. Probes exist for documentation and code; the others need a real check — a build, an applied migration — rather than a reference search.
Inputs: dimension (required), cwd, actor.
parity_setA
Record whether a feature is covered in one dimension — code, unit tests, functional tests, documentation, builds, infrastructure. Work is only done when it is done in every dimension; tracking code alone lets the rest drift silently.
Inputs: id (required), state (required), dimension (required), cwd, +2 more.
project_boundariesA
What this project is NOT: goals' stated non-goals, plus every refusal with its reasoning. The accumulated negative definition — boundaries nobody wrote into a goal statement but which were decided one refusal at a time. Read before deriving or proposing anything.
Inputs: cwd, goal.
standupA
Cross-track state in one call: counts, blocked, pending gates, worker liveness, and every worktree's uncommitted work. Reads working trees, not just commits — measured on this project, every worktree reported zero commits ahead while two held real uncommitted work, so a standup built on git history alone calls active tracks idle.
Inputs: cwd.
stash_listA
Work interrupted by a shutdown and not yet restored, newest first. Each names the worktree it came from — a stash only applies in the tree it was taken in.
Inputs: cwd, include_restored.
stash_restoreA
Put interrupted work back. Applied by sha rather than by position, and the stash entry is applied rather than dropped — so a restore that conflicts can be retried or abandoned without the work having evaporated. Refuses if the target worktree is already dirty: stacking a stash on top mixes two sets of half-finished work with no way to separate them afterwards.
Inputs: id (required), cwd.
study_concludeA
Record a study's recommendation and the document it produced. 'Do not build this' is a successful conclusion, not a failure; so is 'abandoned' when the question stopped mattering. Link the features it spawned or killed with study_outcome before concluding.
Inputs: id (required), recommendation (required), cwd, actor, +2 more.
study_designA
Record the method agreed with the principal, BEFORE execution. This is pre-registration and it is the point of the design phase: a method chosen after seeing the data can be selected — consciously or not — for the answer it produces. Call this once, at consensus, and do not execute a study that has no method recorded. Revising a method later is allowed and is counted, because a silently revised method is indistinguishable from a fitted one.
Inputs: id (required), method (required), cwd, actor, +3 more.
study_listB
Studies with what each spawned, killed or informed. Check before opening one — an already-answered question does not need answering twice.
Inputs: cwd, status.
study_openA
Open an investigation whose deliverable is a document and a decision, not code. Use when a question needs real analysis before anything can sensibly be built — whether an effect is real, which of two designs survives contact with the data, whether something is worth doing at all. A study is NOT a feature: it has no acceptance criteria, and it may correctly conclude 'do not build this'.
Inputs: question (required), cwd, actor, context.
study_outcomeB
Record that a study spawned, killed or informed a feature. 'killed' matters as much as 'spawned': a study that closes work off is doing its job, and without the link the reason a feature was dropped disappears — leaving it to be re-proposed by someone who never saw the study.
Inputs: relation (required), study_id (required), feature_id (required), cwd, +1 more.
study_showC
One study and every feature it touched — the provenance view.
Inputs: id (required), cwd.
study_statusB
Move a study between open, in_progress, concluded and abandoned.
Inputs: id (required), status (required), cwd.
tracker_statusA
Counts by status and goal, pending gates, and which database and tree were read. Progress is two numbers -- done and tracked -- never a ratio: the denominator growing means real work was found, and a percentage would report that as regression.
Inputs: cwd.
worker_heartbeatA
Report that a worker is alive and extend its leases. Silence is what 'stale' means, so a worker that stops heartbeating has its claims expire and its work picked up by someone else. Call this every few minutes while working.
Inputs: worker (required), cwd, goal, worktree, +1 more.
worker_listA
Workers, how long since each was heard from, whether it is stale, and how many features it holds. An idle worker and a working one look identical without this.
Inputs: cwd.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 64 tools
Most tools are carefully scoped and the descriptions do a lot of disambiguation work, but several pairs have blurry boundaries: parity_set vs parity_scan both write coverage, study_conclude vs study_status both touch the concluded state, and feature_ready vs feature_unblocked both answer what can be worked next. Agents would often need to read the full descriptions carefully to avoid misselection.
The dominant pattern is domain-prefixed snake_case (feature_, gate_, goal_, study_, derive_, db_, confer_), which is predictable and consistent. Minor deviations like standup, checkpoint, tracker_status, and oz_shutdown do not fit the prefix pattern, but they are few and still readable.
64 tools is an extreme surface for an agent to hold in context and choose among, especially when many are micro-operations like stash_restore, confer_digest, or goal_membership. Some consolidation into composite tools or subcommands would make the set far more usable without losing capability.
The lifecycle coverage is unusually thorough: features, goals, gates, studies, parity, workers, directives, derivations, backups, conferral, and shutdown workflows all have read/write/action counterparts. The main gap is the absence of a single-feature show/get tool for reading one tracked item's full detail, though feature_list likely covers basic lookup and agents can work around it.
Maintenance
Related MCP Connectors
Shared team record of decisions, changes and handoffs that every coding agent reads and writes.
Shared project memory that keeps teammates and AI agents aligned across sessions.
Shared tables and Markdown docs for teams and AI-built apps, with scoped access and audited changes.
The team layer for AI coding agents: shared contracts, collision alerts, E2EE sessions.
Related MCP Servers
- AlicenseBqualityDmaintenanceGives AI coding assistants persistent memory, safety controls, and project awareness by tracking coding sessions, protecting critical files from modifications, and managing approval workflows with automatic changelog generation.19MIT
- AlicenseAqualityBmaintenanceEnables AI coding assistants to contribute to and query a team-shared project memory, storing human-confirmed decisions with source and scope so work can continue across machines.122Apache 2.0
- AlicenseNot gradedqualityCmaintenanceEnables coding agents to persist and resume shared working state—tasks, progress, decisions, commands, tests, checkpoints, and handoffs—backed by SQLite while keeping Git authoritative for files and repository state.MIT
- AlicenseNot gradedqualityAmaintenanceEnables AI coding assistants to persistently save, search, checkpoint, and restore project context across sessions, including decisions, progress, and file state. It supports shared channels, git-aware organization, and batch operations for long-running or parallel development workflows.243 npmMIT