@infinisys/is-fabric-team 0.1.0 → 0.2.0

package/README.md

@@ -1,5 +1,7 @@
 # @infinisys/is-fabric-team
 
+> **会改动 DSH 的默认行为。** 它会关掉原生的 `tool-agent-team` 与 `ui-agent-team`，把 `subagent` 容量改成 16 个并发、深度 3，并注册四个 Agent 预设。后果与退回写法见 [docs/disclaimer.md](https://gitfox.studio/infinity/Fabric/-/blob/master/docs/disclaimer.md)。
+
 Infinity Fabric 的 **AI 团队插件**（v2）：新增 **团队协作模式（Team Collaboration Mode）** 的四个 Agent 预设。会话根身份是 **assistant**；插件自动拉起 `lead` 和 8 个角色；章程/名册/身份是本地状态；GitFox 只跟踪工作项。工具面是**结构性**的：每个角色跑只挂载它该有能力的那套工具的预设，助手和 Lead 根本没有 shell / 写文件工具可"揽活"。
 
 ## 预设与工具面
@@ -103,22 +105,34 @@ GitFox 通过 `web_fetch` 或 shell `curl`/`wget` 访问会被硬拒绝：议题
 
 | 环节 | 门禁读什么 |
 | --- | --- |
-| `intake` | 每条验收标准必须配一条**可执行 check**（同序、一行一条）。没有 check 的标准只是观点。门禁不看命令的措辞，只看它的运行记录：`true` / `echo` / `ls` 不会被拒绝，它们只会永远“从未失败过”，这会被标记出来而不是当成罪证。**一轮没结题时不会拒收**：新需求照样登记，进队列等当前周期结束（`abandon` 或走到 `retro`）再接过舞台，先来的先上——请求不会因为前面卡住而丢掉 |
+| `intake` | 每条验收标准必须配一条**可执行 check**（同序、一行一条）。没有 check 的标准只是观点。门禁不看命令的措辞，只看它的运行记录：`true` / `echo` / `ls` 不会被拒绝，它们只会永远“从未失败过”，这会被标记出来而不是当成罪证。**一轮没结题时不会拒收**：新需求当场开成自己的车道，从 `intake` 起步，不必等前面那件交付——请求不会因为前面卡住而丢掉 |
 | `implementation` | Host 亲眼见过的 `infinity_git commit`。没有提交，阶段不动 |
 | `test` | 每条标准的 check 至少真跑过一次 |
 | `review` / `delivery` | 每条 check **至少真跑过一次**（`problem-unresolved` 只在有标准一次都没跑过时出现）。红、旧都不再挡住阶段：绿不绿照样写进 `problem`，由席位判断；“从未失败过”仍然在 `problem.neverFailed` 里点名 |
-| 关议题 / 合 MR | **只在本轮需求自己的那张议题上、且本轮确实有可执行 check 时才管**，门槛与阶段一致：每条 check 至少跑过一次就放行，红的也算跑过（关闭是记账，不是“修好了”的声明）。一次都没跑过的标准仍然拦住，因为那是没看过，不是没通过。会议、决策、别的项目的议题一律放行；本轮没有需求在跑时也一律放行 |
+| 关议题 / 合 MR | **只在本轮需求自己的那张议题（或它绑定的合入请求）上、且本轮确实有可执行 check 时才管**，门槛与阶段一致：每条 check 至少跑过一次就放行，红的也算跑过（关闭是记账，不是“修好了”的声明）。一次都没跑过的标准仍然拦住，因为那是没看过，不是没通过。合入还按队列走：请求在合入队列里但前面还有车道时拒绝，并点名谁先走。会议、决策、别的项目的议题一律放行；本轮没有需求在跑时也一律放行 |
 | 工作流推进 | 只写本地账本，不再为每个阶段开议题 |
 
 所以“通过门禁”不是一个可以单独做的动作：先让那条 check 跑起来，修好，然后在最终提交上把那条命令跑成绿色。形式（标准 + check）只是实质（行为）的可执行描述——正如形式化验证的目标是行为一致，而不是形式化验证本身。删掉门禁，工作仍然成立；删掉工作，门禁无法通过。
 
 三道墙曾经互相咬合：评审阶段要求“先红过才准绿”（天生为绿的 check 永远过不了）、每个需求最多三个决策（第四个只能弃周期重开）、`vote` 阶段又必须先有一个**未决**决策（决策在别处通过过就再也进不去）。三条合起来，工作做得再完整也只能以 `abandon` 收场。现在三条都撤了，留下的是治理核心：决策只能由四席一致投票产生，实现阶段必须有已通过的决策。
 
-后来又有三道墙同样把人卡死，一并撤掉：**新鲜度**（提交一次就把所有跑绿的验收作废，于是任何一边干活一边提交的团队永远 0 绿，只能弃周期——现在绿的跑就作数，之后的提交只在 `criterionStatus` 里记成 `staleAgainst` 这个事实）、**登记口**（周期的验收没全绿就不许登记新需求，请求直接丢掉——现在进队列）、**结题全绿**（关议题/合 MR/进 review、delivery 都要求全绿——现在只要每条 check 都真跑过一次）。三道墙的共同点是把“仪器测得的结果”当成“工作能不能继续”的开关；放宽后，红与旧都只是写进状态的事实，交给人去判断。
+后来又有三道墙同样把人卡死，一并撤掉：**新鲜度**（提交一次就把所有跑绿的验收作废，于是任何一边干活一边提交的团队永远 0 绿，只能弃周期——现在绿的跑就作数，之后的提交只在 `criterionStatus` 里记成 `staleAgainst` 这个事实）、**登记口**（周期的验收没全绿就不许登记新需求，请求直接丢掉——现在直接开成新车道）、**结题全绿**（关议题/合 MR/进 review、delivery 都要求全绿——现在只要每条 check 都真跑过一次）。三道墙的共同点是把“仪器测得的结果”当成“工作能不能继续”的开关；放宽后，红与旧都只是写进状态的事实，交给人去判断。
 
 门槛是刻意压低的：门槛太高，团队会为了关掉一张讨论议题而绕过账本。记账动作只要不冒充“完成”（`review` / `delivery` 仍然要求每条 check 跑过一次，绿不绿写在状态里），就不该被未完成的需求挡住。
 
-Host 侧实现：`lib/problem-gate.js`（从账本推导状态；`problemStatus` 与 `closureStatus` 读同一批运行，后者只数有 check 的标准）、`lib/problem-host.js`（`tools/result` 记录真实 commit/命令，`tools/pre-execute` 只拦本轮需求自己的议题与合并）。账本只新增 `evidence` 表与需求的 `criteria[].check`；旧账本加载自动补空表，没有 check 的旧标准不会把议题永久锁死。
+Host 侧实现：`lib/problem-gate.js`（从账本推导状态；`problemStatus` 与 `closureStatus` 读同一批运行，后者只数有 check 的标准）、`lib/problem-host.js`（`tools/result` 记录真实 commit/命令，并按分支与工作目录把证据归到对应车道；`tools/pre-execute` 只拦本轮需求自己的议题与合并）、`lib/lanes.js`（车道的阶段、绑定、焦点与合入队列）。账本只新增 `evidence` 表与需求的 `criteria[].check`；旧账本加载自动补空表，没有 check 的旧标准不会把议题永久锁死。
+
+### 并行：一条需求一条车道，master 一次只合一条
+
+团队不再让所有需求排成一条队。每条需求登记时就是一条**车道**：它有自己的阶段（`intake` → … → `retro`）、自己的决策和自己的证据，所以第二件事在第一条还在实现时就能开工。
+
+- **车道是默认，不是例外。** `intake` 永不拒收，也不排队：新需求立刻从 `intake` 起步。`status` 的 `lanes` 列出所有在跑的车道（阶段、决策、分支、工作目录），`workflow` / `abandon` / `propose_decision` / `vote` / `decide` / `publish` 都可以带 `requirement_id` 指明落在哪一条。
+- **各自一棵树。** 车道可以用 `lane` 动作绑上自己的分支和工作目录（先 `create_worktree` 建树，再 `lane` 绑定）。之后那个席位在树里跑命令、用 `infinity_git` 提交，Host 就能把观察到的东西记到正确的车道上——提交看分支，命令看工作目录。
+- **证据只认自己的车道。** 一条车道的验收只看它自己的提交与运行：别的车道跑绿同一条命令，不算这一条通过。旧账本没有车道字段时，按登记时间把历史证据补记给当时在跑的那条车道。
+- **串行的只有合入。** 交付把车道排进合入队列（`status.mergeQueue`），一条一条落到 `master`：这样几条车道能同时改代码，而 `master` 每一步都能构建。合入仍然要过四席评审，评审通过才轮到它。
+- **阶段回到一条车道内。** 推进阶段读的是这条车道自己的阶段，不是全局指针；`state.stage` 仍保留，它是当前车道（focus）的镜像，给状态视图和老读者用。
+
+车轮战和车队战的区别在这里：并行的是实现，不是合入。
 
 ### 缺件门禁（硬门禁）
 
@@ -152,15 +166,16 @@ Host 侧实现：`lib/problem-gate.js`（从账本推导状态；`problemStatus`
 
 | action | 权限 | 说明 |
 | --- | --- | --- |
-| `status` | 成员 | 只读：默认只给核心字段（`activeDecision` 与 `problem` 排在最前）；历史表用 `include` 点名追加 |
+| `status` | 成员 | 只读：默认只给核心字段（`activeDecision` 与 `problem` 排在最前，`lanes` 与 `mergeQueue` 始终在）；历史表用 `include` 点名追加 |
 | `roster` | 成员 | 只读：本地名册、角色、阶段 |
 | `configure` | assistant / lead | 本地固定 GitFox 项目，不创建 issue |
 | `intake` | assistant（或 lead） | 创建 GitFox 需求并登记；未 configure 则失败 |
-| `abandon` | assistant / lead | 关闭卡死的周期但不伪装完成：必须给 `reason`；需求标记 `abandoned`、议题追加“未完成即关闭”的记录、stage 回到 `intake`，下一轮 `intake` 因此可以开启；需求、证据、决策、会议全部保留 |
+| `abandon` | assistant / lead | 关闭一条卡死的车道但不伪装完成：必须给 `reason`（`requirement_id` 省略时关当前车道）；需求标记 `abandoned`、议题追加“未完成即关闭”的记录，别的车道照常推进；需求、证据、决策、会议全部保留 |
+| `lane` | 成员（绑定只给 assistant / lead） | 只读一条车道的现状；带 `branch` / `worktree` / `mr` 时把这条车道绑到自己的分支、工作目录和合入请求（`mr` 写 `project#iid`，`requirement_id` 省略时用当前车道）。绑定决定证据归谁、合入门禁查哪条车道，所以只有掌计划的两个席位能写 |
 | `meeting` | 成员 | 创建带纪要的 GitFox 会议；retro 只能 docs/hr |
 | `propose_decision` | lead | 四席一致投票的决策。一个需求可以提任意多个决策——没有上限，因为每个新提案都要重新拿四票，投票本身才是那道闸 |
 | `vote` / `decide` | 投票席位 / lead | 只在 `vote` 阶段；不可改票；缺票/reject/abstain 阻断 |
-| `workflow` | 阶段 owner / lead | 逐级推进；门禁读 Host 观察到的工作（commit、check 运行），不创建议题 |
+| `workflow` | 阶段 owner / lead | 按 `requirement_id` 推进某一条车道（省略时为当前车道），一次一级；门禁读 Host 观察到的工作（commit、check 运行），不创建议题 |
 | `reviews` | 成员 | 共享状态评审队列（合并 / 变基 / MR / issue），最新在前；`per_page`（默认 20，最大 100）+ 不透明 `cursor`，返回 `total` / `next_cursor` |
 | `review` | qa、secure、lead | 必需席位投票；merge 需 qa + secure，issue 需 lead + qa |
 | `define_role` | HR | 定义章程外的职位：`role_id` / `role_name` / `mandate` + `capabilities`（`shell`、`write` 的任意组合）；不可定义 assistant/lead/hr，且不获得投票席位 |

package/client.js

@@ -690,9 +690,9 @@ const DATA_ZH = {
   'principle_missing-is-a-task_title': '缺东西是任务，不是状态',
   'principle_missing-is-a-task_text':
     '缺少硬件、内核、依赖或远端对端，本身都不构成阻塞。为不存在的目标板做交叉编译或 JIT，从源码构建维护类依赖，先用回环地址测通传输，再去等对端。只要 Host 观察到确实尝试过，阻塞报告才会被接受；在那之前，唯一诚实的做法是去跑那次尝试。绕行式的运行会被 Host 识别并标出，绝不当作修复。',
-  'principle_one-cycle_title': '一个交付物只走一个周期，拒绝快开发',
-  'principle_one-cycle_text':
-    '这套流程用一次完整的过程交付一整件事：一个需求、一次方案、一次投票、一次实现、一次验收、一次交付。它不是装小步骤的容器。当前需求没有全部验收通过之前，新需求一律被拒；从已开着的需求里再切出一个更小的需求，同样被拒。快开发对 AI 是陷阱而不是对人：AI 本来就够快，切成小单元省不下时间，却要再付一整套流程。把整件事放进一个需求，立案时列全每条判据，一次实现，一次验收。',
+  'principle_parallel-lanes_title': '多车道并行，master 一次只合一条',
+  'principle_parallel-lanes_text':
+    '多个需求可以同时开工：每条车道有自己的阶段、自己的决策和自己的证据，所以第二件事不用等第一件交付才开始。立案时仍然要把整件事说全，一次列齐所有判据，因为把一件事切成好几条车道，等于每一刀都要再付一次投票和验收，还把真正的活藏了起来。保持串行的是合入：交付排进队列，一条一条落到 master，这样每一步 master 都能构建。证据只算自己那条车道的：提交写着它属于哪个分支，命令写着它在哪个工作目录里跑，别的车道的绿灯不能替这一条通过。',
   'principle_fast-fail_title': '快速失败',
   'principle_fast-fail_text':
     '立即拒绝非法操作、缺失的跟踪、缺失的投票和被破坏的边界。绝不带着残缺或乐观的状态继续往下走。',

package/cordis.patch.yml

@@ -231,7 +231,11 @@
                 You are an implementation seat of the Infinity Fabric AI Team, powered by the {{model}}
                 model. Implement only inside the claim the Lead assigned and inside your role's write
                 scopes; write tests before production code; never approve your own work; drive git only
-                through infinity_git; a denied tool call is final.
+                through infinity_git; a denied tool call is final. When the Lead hands you a lane, call
+                create_worktree named after that requirement and report the branch and path back before
+                you change anything: that worktree is your lane's tree, and every command you run there,
+                plus every commit you make with infinity_git, belongs to it. Never work in another lane's
+                tree and never switch this session back to the project root mid-lane.
           - id: agent-instructions
             name: '@deepseek-ai/dsh-agent-instructions'
             config:

package/index.js

@@ -48,6 +48,8 @@ import {
 } from './lib/team-runtime.js';
 import { definePosition, requireCatalogRole, retirePosition } from './lib/positions.js';
 import { assertNoBareBlocker } from './lib/blocker-gate.js';
+import { laneAction, optionalLane, optionalRequirement } from './lib/lane-action.js';
+import { currentDirectory } from './lib/session-dir.js';
 import { amendCriterion } from './lib/criterion-amend.js';
 import { createScopeInstaller } from './lib/scope-install.js';
 import { createMemberTools } from './lib/member-tools.js';
@@ -103,6 +105,7 @@ const DELEGATED_ACTIONS = Object.freeze({
   configure,
   intake,
   abandon,
+  lane: laneAction,
   amend,
   meeting,
   propose_decision: propose,
@@ -114,13 +117,14 @@ const DELEGATED_ACTIONS = Object.freeze({
   define_role: definePosition,
   retire_role: retirePosition,
   attention: attentionAction,
-  publish: (core, caller) =>
+  publish: (core, caller, args) =>
     publishWorkRecord({
       store: core.store,
       loadState: loadedState,
       tracked,
       ctx: core.ctx,
       caller,
+      ...optionalRequirement(args),
     }),
 });
 
@@ -503,6 +507,7 @@ async function intake(core, caller, args) {
  */
 async function abandon(core, caller, args) {
   const reason = requireString(args, 'reason', 'abandon');
+  const requirementId = optionalId(args, 'requirement_id');
   const abandoned = await core.store.mutate(async (draft, now) => {
     requireSeeded(draft);
     const roles = callerRoles(draft, caller);
@@ -511,6 +516,7 @@ async function abandon(core, caller, args) {
     // half state: the issue is only touched once the ledger accepts the close.
     const preview = abandonCycle(structuredClone(draft), {
       reason,
+      ...(requirementId === undefined ? {} : { requirementId }),
       roles,
       member: caller.member,
       now,
@@ -534,6 +540,7 @@ async function abandon(core, caller, args) {
     );
     return abandonCycle(draft, {
       reason,
+      ...(requirementId === undefined ? {} : { requirementId }),
       roles,
       member: caller.member,
       now,
@@ -575,6 +582,7 @@ async function amend(core, caller, args) {
     return amendCriterion(draft, {
       index,
       check,
+      ...optionalRequirement(args),
       ...(reason === undefined ? {} : { reason }),
       roles: callerRoles(draft, caller),
       member: caller.member,
@@ -610,12 +618,14 @@ async function meeting(core, caller, args) {
   const record = await core.store.mutate(async (draft, now) => {
     requireSeeded(draft);
     const roles = callerRoles(draft, caller);
+    const lane = optionalLane(draft, args);
     recordMeeting(structuredClone(draft), {
       topic,
       kind,
       attendees,
       minutes,
       tracking: null,
+      requirementId: lane?.id,
       member: caller.member,
       roles,
       now,
@@ -798,6 +808,7 @@ async function decide(core, caller, args) {
  */
 async function workflow(core, caller, args) {
   const target = requireString(args, 'stage', 'workflow');
+  const requirementId = optionalId(args, 'requirement_id');
   if (!STAGE_IDS.includes(target) || target === 'intake') {
     throw new TeamError(
       `stage must be one of: ${STAGE_IDS.filter((id) => id !== 'intake').join(', ')}`,
@@ -815,6 +826,7 @@ async function workflow(core, caller, args) {
     const roles = callerRoles(draft, caller);
     return advanceWorkflow(draft, {
       target,
+      ...(requirementId === undefined ? {} : { requirementId }),
       ...(note === undefined ? {} : { note }),
       tracking: null,
       roles,
@@ -825,11 +837,25 @@ async function workflow(core, caller, args) {
   return {
     action: 'workflow',
     stage: target,
+    requirementId: entry.requirementId,
     workflow: entry,
     problem: problemStatus(await core.store.load()),
   };
 }
 
+/**
+ * Read one optional id argument, trimmed.
+ *
+ * @param {Record<string, unknown>} args - tool arguments.
+ * @param {string} key - field name.
+ * @returns {string | undefined} the id.
+ */
+function optionalId(args, key) {
+  const value = args[key];
+  return typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined;
+}
+
+
 /**
  * Local HR enrollment. No GitFox issue.
  *
@@ -1694,6 +1720,7 @@ export function apply(ctx, config = {}) {
     loadState: loadedState,
     memberOf: (state, agent) => memberFor(core, state, agent),
     isTeamAgent: (agent) => isTeamModeAgent(ctx, agent),
+    cwdOf: (agent) => currentDirectory(ctx, agent),
     withTeam: (agent, run) => core.withTeam(agent, run),
   });
   handles.workRecords = createWorkRecordController({
@@ -1811,6 +1838,7 @@ export const inject = [
   'userQuestions',
   'webServer',
   'sessionProjections',
+  'workingDirectory',
 ];
 /** Re-exported for tests. */
 export { TEAM_MODE_PROTOCOL };

package/lib/criterion-amend.js

@@ -50,7 +50,7 @@ function requireText(value, field, max) {
  * Replace the command behind one acceptance criterion, in place.
  *
  * @param {object} state - ledger state.
- * @param {{ index: number, check: string, reason?: string, roles: string[], member: string, now: string }} input - amendment.
+ * @param {{ index: number, check: string, reason?: string, requirementId?: string, roles: string[], member: string, now: string }} input - amendment.
  * @returns {{ requirement: object, amendment: object }} the amended requirement and the record.
  */
 export function amendCriterion(state, input) {
@@ -62,21 +62,23 @@ export function amendCriterion(state, input) {
       { status: 403 },
     );
   }
-  const requirement = (state.requirements ?? []).find(
-    (candidate) => candidate.id === state.activeRequirementId,
-  );
+  const wanted = input.requirementId ?? state.activeRequirementId;
+  const requirement = (state.requirements ?? []).find((candidate) => candidate.id === wanted);
   if (requirement === undefined) {
     throw new TeamError(
-      'there is no active requirement to amend; open intake first',
+      input.requirementId === undefined
+        ? 'there is no active requirement to amend; open intake first'
+        : `unknown requirement "${input.requirementId}"; read "status" for the lanes`,
       'no-active-requirement',
     );
   }
   // Before review the check is still a hypothesis about how to watch the work.
   // Once review or delivery starts, replacing the command would be grading a
   // fixed answer on a new question, so a different measurement needs a new cycle.
-  if (['review', 'delivery'].includes(state.stage)) {
+  const stage = inputStage(state, requirement);
+  if (['review', 'delivery'].includes(stage)) {
     throw new TeamError(
-      `the active cycle is already at "${state.stage}"; the checks it is being reviewed against are closed — a different measurement needs a new cycle`,
+      `requirement ${requirement.id} is already at "${stage}"; the checks it is being reviewed against are closed — a different measurement needs a new cycle`,
       'cycle-in-flight',
       { status: 409 },
     );
@@ -107,3 +109,17 @@ export function amendCriterion(state, input) {
   state.updatedAt = input.now;
   return { requirement, amendment };
 }
+
+/**
+ * The stage of the lane being amended.
+ *
+ * @param {object} state - ledger state.
+ * @param {object} requirement - the lane.
+ * @returns {string} stage id.
+ */
+function inputStage(state, requirement) {
+  if (typeof requirement.stage === 'string') return requirement.stage;
+  const focused = state.activeRequirementId === requirement.id;
+  if (focused && typeof state.stage === 'string') return state.stage;
+  return 'intake';
+}

package/lib/cycle-close.js

@@ -1,70 +1,14 @@
 /**
- * Cycle boundaries: what a cycle owns while it runs, and when the next one may
- * open.
+ * Closing one lane, and what an abandoned attempt leaves behind.
  *
- * Leaving an abandoned cycle's pending reviews behind turns it into a permanent
- * backlog that re-arms the team goal every round; the same is true for an open
- * attention nobody can answer once the cycle is gone.
- *
- * A second requirement beside a running cycle used to be refused outright. That
- * refusal lost the ask: a team whose cycle was stuck at a red or stale check
- * could not take the next piece of work at all. Intake is recorded now and
- * waits in a queue (`promoteQueued` below), so one cycle still runs at a
- * time without anything being turned away.
- */
-
-/**
- * Whether the ledger is inside a cycle that has not ended yet.
- *
- * "Ended" is not the same as "all green": a cycle ends by closing (abandon) or
- * by a new requirement opening after retro. Every state in between is in
- * flight, whatever its stage and however red its checks are.
- *
- * @param {object} state - ledger state.
- * @returns {boolean} true while a cycle owns the stage.
- */
-export function cycleInFlight(state) {
-  const active = (state.requirements ?? []).find(
-    (candidate) => candidate.id === state.activeRequirementId,
-  );
-  if (active === undefined) return false;
-  if (state.stage === 'retro') return false;
-  return true;
-}
-
-/**
- * Give the stage to the oldest requirement waiting in the queue.
+ * Lanes run side by side, so closing one is a local act: it ends that lane's
+ * reviews and attentions and leaves every other lane exactly where it stood.
+ * Nothing here decides who runs next — that is the focus, not a queue.
  *
- * Registering intake while a cycle runs used to be refused outright
- * ("cycle-in-flight"), which is what left a team with a stuck cycle unable to
- * take the next ask at all: the request was lost, not deferred. A queued
- * requirement keeps its record and its criteria, activates the moment the
- * stage is free, and starts at intake like any other.
- *
- * @param {object} state - ledger state.
- * @param {{ at: string, by: string }} input - when and who freed the stage.
- * @returns {object | undefined} the requirement that took the stage.
+ * Leaving an abandoned lane's pending reviews behind turns it into a permanent
+ * backlog that re-arms the team goal every round; the same is true for an open
+ * attention nobody can answer once the lane is gone.
  */
-export function promoteQueued(state, input) {
-  if (cycleInFlight(state)) return undefined;
-  const next = (state.requirements ?? []).find((candidate) => candidate.status === 'queued');
-  if (next === undefined) return undefined;
-  delete next.status;
-  delete next.queuedAt;
-  next.activatedAt = input.at;
-  next.activatedBy = input.by;
-  state.activeRequirementId = next.id;
-  state.activeDecisionId = null;
-  state.stage = 'intake';
-  state.updatedAt = input.at;
-  state.workflow.push({
-    stage: 'intake',
-    at: input.at,
-    by: input.by,
-    note: `${next.id} takes the stage from the queue`,
-  });
-  return next;
-}
 
 /**
  * How many abandoned attempts share one request.

package/lib/lane-action.js

@@ -0,0 +1,106 @@
+/**
+ * The `lane` action: read one lane, and optionally bind it to the branch and
+ * directory its work lives in.
+ *
+ * This is how a Lead hands a lane its own tree. The worker then runs every
+ * command inside that directory, and the Host attributes what it observes there
+ * to this lane. Without the binding, two workers editing at once would both
+ * look like the focused lane. Binding is limited to the assistant and the Lead:
+ * the attribution has to come from the seats that own the plan, not from the
+ * seat whose work is being attributed.
+ */
+import { bindLane, laneFor, laneSummaries } from './lanes.js';
+import { requireSeeded } from './ledger-guards.js';
+import { assertCallerRole } from './team-core.js';
+import { TeamError } from './team-error.js';
+
+/** Only the seats that own the plan may point a lane at a branch and a tree. */
+const BINDING_ROLES = ['assistant', 'lead'];
+
+/**
+ * Read or bind one lane.
+ *
+ * @param {object} core - plugin state.
+ * @param {{ member: string }} caller - caller.
+ * @param {Record<string, unknown>} args - tool arguments.
+ * @returns {Promise<object>} canonical result.
+ */
+export async function laneAction(core, caller, args) {
+  const requirementId = stringArg(args, 'requirement_id');
+  const branch = stringArg(args, 'branch');
+  const worktree = stringArg(args, 'worktree');
+  const mr = stringArg(args, 'mr');
+  const row = await core.store.mutate((draft, now) => {
+    requireSeeded(draft);
+    if (branch === undefined && worktree === undefined && mr === undefined) {
+      return readLane(draft, requirementId);
+    }
+    assertCallerRole(draft, caller, BINDING_ROLES, 'lane');
+    return bindLane(draft, {
+      ...(requirementId === undefined ? {} : { requirementId }),
+      ...(branch === undefined ? {} : { branch }),
+      ...(worktree === undefined ? {} : { worktree }),
+      ...(mr === undefined ? {} : { mr }),
+      member: caller.member,
+      now,
+    });
+  });
+  return { action: 'lane', lane: row };
+}
+
+/**
+ * One lane row, without changing anything.
+ *
+ * @param {object} state - ledger state.
+ * @param {string | undefined} requirementId - named lane, defaulting to the focus.
+ * @returns {object} lane row.
+ * @throws {TeamError} when no such lane is open.
+ */
+function readLane(state, requirementId) {
+  const wanted = requirementId ?? state.activeRequirementId;
+  const row = laneSummaries(state).find((lane) => lane.id === wanted);
+  if (row === undefined) {
+    throw new TeamError(
+      `no open lane ${requirementId ?? 'in focus'}; read "status" for the lanes`,
+      'no-active-requirement',
+    );
+  }
+  return row;
+}
+
+/**
+ * Read one optional string argument, trimmed.
+ *
+ * @param {Record<string, unknown>} args - tool arguments.
+ * @param {string} key - field name.
+ * @returns {string | undefined} the value.
+ */
+function stringArg(args, key) {
+  const value = args[key];
+  return typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined;
+}
+
+/**
+ * Narrow the "requirement_id" argument to a publish call.
+ *
+ * @param {Record<string, unknown>} args - tool arguments.
+ * @returns {{ requirementId?: string }} options.
+ */
+export function optionalRequirement(args) {
+  const requirementId = stringArg(args, 'requirement_id');
+  return requirementId === undefined ? {} : { requirementId };
+}
+
+/**
+ * The lane an action names, or the focused lane when it names none.
+ *
+ * @param {object} state - ledger state.
+ * @param {Record<string, unknown>} args - tool arguments.
+ * @returns {object | undefined} the lane, or undefined when nothing is open.
+ */
+export function optionalLane(state, args) {
+  const requirementId = stringArg(args, 'requirement_id');
+  if (requirementId !== undefined) return laneFor(state, requirementId);
+  const focused = state.activeRequirementId;
+  return focused === null || focused === undefined ? undefined : laneFor(state, focused);
+}