@infinisys/is-fabric-team 0.1.0 → 0.2.0

package/lib/team-core.js

@@ -20,18 +20,38 @@ import {
 } from './team-model.js';
 import { assertStageProof, parseCriteria, problemStatus } from './problem-gate.js';
 import { TeamError } from './team-error.js';
+import { optionalBounded, requireBounded, requireSeeded } from './ledger-guards.js';
 import {
   assertReopenAllowed,
-  cycleInFlight,
   expireCycleAttentions,
   expireCycleReviews,
   priorAttempts,
-  promoteQueued,
 } from './cycle-close.js';
 import { boundedDecision, boundedProblem, stageName, tally, watchdogOf } from './status-view.js';
+import {
+  backfillLanes,
+  bindLane,
+  dropFromMergeQueue,
+  enqueueMerge,
+  focusLane,
+  focusOldestRunning,
+  focusedLane,
+  laneFor,
+  laneInFlight,
+  laneIsOpen,
+  laneStage,
+  laneSummaries,
+  mergeQueueRows,
+  openLanes,
+  requirementIn,
+} from './lanes.js';
 
 export { tally };
 
+export { bindLane, focusLane, focusedLane, laneFor, laneInFlight, laneIsOpen, laneStage, laneSummaries, openLanes };
+
+export { requireBounded, requireSeeded };
+
 export { TeamError };
 
 /** Role ids that are always seeded, in roster order. */
@@ -83,31 +103,6 @@ function bounded(value, field, max) {
   return text;
 }
 
-/**
- * Trim an optional string and enforce its bound.
- *
- * @param {unknown} value - candidate text.
- * @param {string} field - field name for the error.
- * @param {number} max - maximum accepted characters.
- * @returns {string | undefined} trimmed text or undefined.
- */
-function optionalBounded(value, field, max) {
-  if (value === undefined || value === null) return undefined;
-  if (typeof value !== 'string') {
-    throw new TeamError(`"${field}" must be a string`, 'invalid-arguments', { status: 400 });
-  }
-  const text = value.trim();
-  if (text === '') return undefined;
-  if (text.length > max) {
-    throw new TeamError(
-      `"${field}" exceeds ${max} characters`,
-      'invalid-arguments',
-      { status: 400 },
-    );
-  }
-  return text;
-}
-
 /**
  * Create a fresh, unseeded ledger.
  *
@@ -141,6 +136,7 @@ export function createTeamState(now = new Date().toISOString()) {
     workflow: [],
     reviews: [],
     evidence: [],
+    mergeQueue: [],
     counters: {
       identity: 0,
       requirement: 0,
@@ -153,22 +149,6 @@ export function createTeamState(now = new Date().toISOString()) {
   };
 }
 
-/**
- * Trim a required string and enforce its bound.
- *
- * @param {unknown} value - candidate text.
- * @param {string} field - field name for the error.
- * @param {number} max - maximum accepted characters.
- * @returns {string} trimmed text.
- */
-function requireBounded(value, field, max) {
-  const text = optionalBounded(value, field, max);
-  if (text === undefined) {
-    throw new TeamError(`"${field}" is required`, 'invalid-arguments', { status: 400 });
-  }
-  return text;
-}
-
 /**
  * Format the next sequence id for one record kind.
  *
@@ -374,15 +354,6 @@ export function retireRole(state, { roleId, by, now, reason }) {
  * @param {object} state - ledger state.
  * @returns {void}
  */
-export function requireSeeded(state) {
-  if (state.seeded !== true) {
-    throw new TeamError(
-      'The team is not seeded. The Lead must call infinity_team action "bootstrap" with the GitFox project first.',
-      'not-seeded',
-    );
-  }
-}
-
 /**
  * Resolve the long-lived identity owned by one Agent member name.
  *
@@ -685,12 +656,16 @@ export function retireIdentity(state, { employeeId, by, now, reason }) {
   return identity;
 }
 
+
 /**
- * Open one tracked requirement.
+ * Open one tracked requirement as its own lane.
  *
- * The requirement is always recorded: when a cycle is in flight it is queued
- * instead of taking the stage (see `promoteQueued`), because refusing intake
- * lost the ask. One-cycle-at-a-time is about what runs, not what is written.
+ * Every requirement owns a stage pointer, so intake no longer waits behind a
+ * running cycle: opening work beside running work is what makes the team able
+ * to use more than one pair of hands. What used to be the cycle's exclusivity
+ * lives where it belongs — in the vote (one approved decision per lane) and in
+ * the merge queue, which keeps `master` buildable while lanes land one at a
+ * time.
  *
  * @param {object} state - ledger state.
  * @param {object} input - title, request, acceptance, checks, tracking, member, roles, now.
@@ -719,43 +694,26 @@ export function recordRequirement(state, input) {
     acceptance,
     criteria,
     ...(boundaries === undefined ? {} : { boundaries }),
+    status: 'open',
+    stage: 'intake',
+    decisionId: null,
     tracking: input.tracking,
     openedBy: input.member,
     createdAt: input.now,
     ...(reopens === 0 ? {} : { reopens, reopenReason }),
   };
   state.requirements.push(requirement);
-  // A queued requirement is not active: the cycle that owns the stage keeps it
-  // until it ends (abandon or retro), and an older queued ask keeps its place.
-  const older = (state.requirements ?? []).find(
-    (candidate) => candidate.status === 'queued' && candidate.id !== requirement.id,
-  );
-  if (cycleInFlight(state) || older !== undefined) {
-    requirement.status = 'queued';
-    requirement.queuedAt = input.now;
-    state.updatedAt = input.now;
-    state.workflow.push({
-      stage: state.stage,
-      at: input.now,
-      by: input.member,
-      note: `${requirement.id} queued behind ${older?.id ?? state.activeRequirementId}; it takes the stage when the cycle ends`,
-    });
-    promoteQueued(state, { at: input.now, by: input.member });
-    return requirement;
-  }
-  // A new requirement after the final stage starts the next cycle instead of
-  // leaving the ledger stuck at "retro" forever.
-  if (state.stage === 'retro') {
-    state.stage = 'intake';
-    state.workflow.push({
-      stage: 'intake',
-      at: input.now,
-      by: input.member,
-      note: `New cycle opened by ${requirement.id}`,
-    });
-  }
-  state.activeRequirementId = requirement.id;
-  state.activeDecisionId = null;
+  // A lane takes the focus only when nothing else is running: opening work
+  // must not move the reported state out from under the seat reading it.
+  const focused = focusedLane(state);
+  if (focused === undefined || !laneInFlight(state, focused)) focusLane(state, requirement.id);
+  state.workflow.push({
+    stage: 'intake',
+    at: input.now,
+    by: input.member,
+    requirementId: requirement.id,
+    note: `${requirement.id} opened as a lane at intake`,
+  });
   state.updatedAt = input.now;
   return requirement;
 }
@@ -786,39 +744,44 @@ export function abandonCycle(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 close; the ledger is already waiting at intake',
+      'there is no open lane to close; pass "requirement_id" to name the lane, or the ledger has no work in flight',
       'no-active-requirement',
     );
   }
+  if (!laneIsOpen(requirement)) {
+    throw new TeamError(
+      `requirement ${requirement.id} is already ${requirement.status ?? 'closed'}`,
+      'lane-closed',
+      { status: 409 },
+    );
+  }
+  const stage = laneStage(state, requirement);
   const reason = requireBounded(input.reason, 'reason', 2_000);
   requirement.status = 'abandoned';
   requirement.abandonedAt = input.now;
   requirement.abandonedBy = input.member;
   requirement.abandonReason = reason;
-  requirement.abandonedStage = state.stage;
-  requirement.abandonedDecisionId = state.activeDecisionId ?? null;
-  // Closing the cycle also closes the work that belonged to it. Leaving its
+  requirement.abandonedStage = stage;
+  requirement.abandonedDecisionId = requirement.decisionId ?? state.activeDecisionId ?? null;
+  // Closing the lane also closes the work that belonged to it. Leaving its
   // pending reviews behind turns an abandoned cycle into a permanent backlog
   // that re-arms the team goal every round.
   expireCycleReviews(state, requirement, input.now);
   expireCycleAttentions(state, requirement, input.now);
-  state.activeRequirementId = null;
-  state.activeDecisionId = null;
-  state.stage = 'intake';
   state.workflow.push({
-    stage: 'intake',
+    stage,
     at: input.now,
     by: input.member,
-    note: `Cycle closed without completion: ${requirement.id} — ${reason}`,
+    requirementId: requirement.id,
+    note: `Lane closed without completion: ${requirement.id} — ${reason}`,
   });
-  // The stage is free, so whatever waited behind this cycle starts now instead
-  // of waiting for someone to remember it.
-  promoteQueued(state, { at: input.now, by: input.member });
+  // Only the lane that held the focus moves the reported state; the other
+  // lanes keep running, which is the whole point of having them.
+  if (state.activeRequirementId === requirement.id) focusOldestRunning(state);
   state.updatedAt = input.now;
   return requirement;
 }
@@ -870,7 +833,7 @@ export function recordMeeting(state, input) {
     attendees: [...input.attendees],
     minutes,
     tracking: input.tracking,
-    requirementId: state.activeRequirementId ?? null,
+    requirementId: input.requirementId ?? state.activeRequirementId ?? null,
     openedBy: input.member,
     createdAt: input.now,
   };
@@ -925,8 +888,11 @@ export function proposeDecision(state, input) {
     decidedBy: null,
   };
   state.decisions.push(decision);
-  state.activeRequirementId = requirement.id;
-  state.activeDecisionId = decision.id;
+  // The decision belongs to one lane; recording it there is what lets the vote
+  // stage read the right proposal when several lanes are in flight.
+  requirement.decisionId = decision.id;
+  if (focusedLane(state) === undefined) focusLane(state, requirement.id);
+  if (state.activeRequirementId === requirement.id) state.activeDecisionId = decision.id;
   state.updatedAt = input.now;
   return decision;
 }
@@ -974,10 +940,12 @@ export function castVote(state, input) {
     );
   }
   // Votes belong to the vote stage: it is where the decision was opened and
-  // the only stage whose gate reads an open decision. Voting earlier used to
-  // end with an approved decision outside the vote stage — a cycle that could
-  // never advance again, then blamed on the process.
-  if (state.stage !== 'vote') throw new TeamError(`votes are cast in the vote stage; the active requirement is in "${state.stage}" — advance to "vote" first`, 'workflow-order', { status: 409 });
+  // the only stage whose gate reads an open decision. The stage is the one the
+  // decision's own lane stands at, so a vote cannot be cast on a lane that is
+  // still planning while another lane votes.
+  const lane = decisionLane(state, decision);
+  const stage = laneStage(state, lane);
+  if (stage !== 'vote') throw new TeamError(`votes are cast in the vote stage; requirement ${decision.requirementId} is in "${stage}" — advance that lane to "vote" first`, 'workflow-order', { status: 409 });
   if (!VOTES.includes(input.vote)) {
     throw new TeamError(`vote must be one of: ${VOTES.join(', ')}`, 'invalid-vote', { status: 400 });
   }
@@ -1045,10 +1013,12 @@ export function finalizeDecision(state, input) {
   if (decision.status === 'approved') {
     throw new TeamError(`decision ${decision.id} is already approved`, 'decision-approved');
   }
-  // A decision takes effect inside the vote stage, where its votes were cast.
+  // A decision takes effect inside the vote stage of the lane that owns it.
   // Finalizing it earlier left an approved decision with the vote stage still
   // ahead: the gate could never open again and the cycle looked stuck.
-  if (state.stage !== 'vote') throw new TeamError(`a decision is finalized in the vote stage; the active requirement is in "${state.stage}" — advance to "vote" first`, 'workflow-order', { status: 409 });
+  const lane = decisionLane(state, decision);
+  const stage = laneStage(state, lane);
+  if (stage !== 'vote') throw new TeamError(`a decision is finalized in the vote stage; requirement ${decision.requirementId} is in "${stage}" — advance that lane to "vote" first`, 'workflow-order', { status: 409 });
   assertUnanimous(decision);
   decision.status = 'approved';
   decision.decidedAt = input.now;
@@ -1226,21 +1196,34 @@ export function castReviewVerdict(state, input) {
 }
 
 /**
- * Validate one forward workflow transition and apply it.
+ * Validate one forward workflow transition on one lane and apply it.
+ *
+ * The lane is named by `requirement_id`; without it the focused lane moves,
+ * which keeps a single-lane caller working unchanged. Several lanes may stand
+ * at different stages at once — that is what lets the team run intake, a vote
+ * and an implementation side by side instead of queueing them.
  *
  * @param {object} state - ledger state.
- * @param {{ target: string, note?: string, tracking: object, roles: string[], member: string, now: string }} input - transition.
+ * @param {{ target: string, requirementId?: string, note?: string, tracking: object, roles: string[], member: string, now: string }} input - transition.
  * @returns {object} the appended workflow entry.
  */
 export function advanceWorkflow(state, input) {
   requireSeeded(state);
-  const expected = nextStage(state.stage);
+  const requirement = requirementIn(state, input.requirementId);
+  const stage = laneStage(state, requirement);
+  if (!laneIsOpen(requirement)) {
+    throw new TeamError(
+      `requirement ${requirement.id} is ${requirement.status ?? 'closed'}; nothing is left to advance — open a new lane with intake`,
+      'workflow-complete',
+    );
+  }
+  const expected = nextStage(stage);
   if (expected === undefined) {
-    throw new TeamError(`workflow is already at its final stage "${state.stage}"`, 'workflow-complete');
+    throw new TeamError(`requirement ${requirement.id} is already at its final stage "${stage}"`, 'workflow-complete');
   }
   if (input.target !== expected) {
     throw new TeamError(
-      `workflow must advance exactly one stage: next is "${expected}", not "${input.target}"`,
+      `workflow must advance exactly one stage: ${requirement.id} stands at "${stage}", so next is "${expected}", not "${input.target}"`,
       'workflow-order',
     );
   }
@@ -1253,22 +1236,46 @@ export function advanceWorkflow(state, input) {
     );
   }
   const note = optionalBounded(input.note, 'note', 4000);
-  gate(state, input.target);
+  gate(state, input.target, requirement);
   const entry = {
     stage: input.target,
     at: input.now,
     by: input.member,
+    requirementId: requirement.id,
     ...(note === undefined ? {} : { note }),
     tracking: input.tracking,
   };
   state.workflow.push(entry);
-  state.stage = input.target;
+  requirement.stage = input.target;
+  if (input.target === 'delivery') enqueueMerge(state, requirement, input.now);
+  if (input.target === 'retro') {
+    // Retro is the last stage, so reaching it finishes the lane: the branch is
+    // no longer waiting for `master`, and the focus moves to whatever is still
+    // running. A delivered lane keeps its history but stops being work.
+    requirement.status = 'delivered';
+    requirement.deliveredAt = input.now;
+    dropFromMergeQueue(state, requirement.id);
+    if (state.activeRequirementId === requirement.id) focusOldestRunning(state);
+  } else if (state.activeRequirementId === requirement.id) {
+    state.stage = input.target;
+  }
   state.updatedAt = input.now;
   return entry;
 }
 
 /**
- * Enforce one stage gate against the active requirement and decision.
+ * The lane a decision belongs to.
+ *
+ * @param {object} state - ledger state.
+ * @param {object} decision - decision record.
+ * @returns {object | undefined} lane record.
+ */
+function decisionLane(state, decision) {
+  return (state.requirements ?? []).find((candidate) => candidate.id === decision.requirementId);
+}
+
+/**
+ * Enforce one stage gate against one lane's requirement and decision.
  *
  * plan needs a tracked requirement, vote needs a decision for it, implementation
  * needs that decision approved, retro needs minutes. `vote` used to require an
@@ -1281,30 +1288,24 @@ export function advanceWorkflow(state, input) {
  *
  * @param {object} state - ledger state.
  * @param {string} target - target stage.
+ * @param {object} requirement - lane the stage belongs to.
  * @returns {void}
  */
-function gate(state, target) {
-  assertStageProof(state, target);
-  if (
-    target === 'plan' &&
-    (state.activeRequirementId === null ||
-      !state.requirements.some((requirement) => requirement.id === state.activeRequirementId))
-  ) {
-    throw new TeamError('stage "plan" requires an active tracked requirement', 'gate-unsatisfied');
-  }
+function gate(state, target, requirement) {
+  assertStageProof(state, target, requirement);
   if (target === 'vote') {
-    const decision = activeDecision(state);
-    if (decision === undefined) throw new TeamError('stage "vote" requires a decision for the active requirement; the Lead proposes one, then all four voting seats vote on it', 'gate-unsatisfied');
+    const decision = decisionOf(state, requirement);
+    if (decision === undefined) throw new TeamError(`stage "vote" requires a decision for ${requirement.id}; the Lead proposes one, then all four voting seats vote on it`, 'gate-unsatisfied');
     // Approved: nothing is left to vote, so the stage that records the settled
     // direction opens. Rejected with every seat heard: the vote is over and
     // re-entering it would only relitigate the same proposal.
-    if (decision.status === 'rejected' && tally(decision).missing === 0) throw new TeamError(`stage "vote" cannot settle ${decision.id}: all four seats have voted to reject it; the Lead proposes a different decision (there is no cap) or the cycle closes with abandon`, 'gate-unsatisfied');
+    if (decision.status === 'rejected' && tally(decision).missing === 0) throw new TeamError(`stage "vote" cannot settle ${decision.id}: all four seats have voted to reject it; the Lead proposes a different decision (there is no cap) or the lane closes with abandon`, 'gate-unsatisfied');
   }
   if (target === 'implementation') {
-    const decision = activeDecision(state);
+    const decision = decisionOf(state, requirement);
     if (decision === undefined || decision.status !== 'approved') {
       throw new TeamError(
-        'stage "implementation" requires the active decision to be approved by all four seats',
+        `stage "implementation" requires ${requirement.decisionId ?? 'the lane\'s decision'} to be approved by all four seats`,
         'gate-unsatisfied',
       );
     }
@@ -1314,16 +1315,28 @@ function gate(state, target) {
     !state.meetings.some(
       (meeting) =>
         meeting.kind === 'retro' &&
-        (meeting.requirementId ?? null) === (state.activeRequirementId ?? null),
+        (meeting.requirementId ?? null) === requirement.id,
     )
   ) {
     throw new TeamError(
-      'stage "retro" requires a tracked retro meeting for the active requirement',
+      `stage "retro" requires a tracked retro meeting for ${requirement.id}`,
       'gate-unsatisfied',
     );
   }
 }
 
+/**
+ * The decision one lane is working on.
+ *
+ * @param {object} state - ledger state.
+ * @param {object} requirement - lane record.
+ * @returns {object | undefined} decision record.
+ */
+export function decisionOf(state, requirement) {
+  if (requirement?.decisionId === null || requirement?.decisionId === undefined) return undefined;
+  return (state.decisions ?? []).find((candidate) => candidate.id === requirement.decisionId);
+}
+
 /**
  * One seat's public view, including its human-owned model route.
  *
@@ -1364,25 +1377,6 @@ function roleSnapshot(state, role, roleModels) {
  * @param {{ tracking?: object, runtime?: object }} [extra] - connection and runtime facts.
  * @returns {object} public snapshot.
  */
-/**
- * Work that arrived while a cycle was running.
- *
- * Recorded, never refused, and it takes the stage when the cycle ends — the
- * status view lists it so a queued ask is visible instead of looking lost.
- *
- * @param {object} state - ledger state.
- * @returns {{ id: string, title: string, queuedAt: string | null }[]} queued requirements.
- */
-function queuedRequirements(state) {
-  return (state.requirements ?? [])
-    .filter((candidate) => candidate.status === 'queued')
-    .map((candidate) => ({
-      id: candidate.id,
-      title: candidate.title,
-      queuedAt: candidate.queuedAt ?? null,
-    }));
-}
-
 export function publicSnapshot(state, extra = {}) {
   const roleModels = state.roleModels ?? {};
   const roles = catalogRoles(state).map((role) => roleSnapshot(state, role, roleModels));
@@ -1401,7 +1395,8 @@ export function publicSnapshot(state, extra = {}) {
     stageName: stageName(state.stage),
     activeRequirementId: state.activeRequirementId ?? null,
     activeDecisionId: state.activeDecisionId ?? null,
-    queue: queuedRequirements(state),
+    lanes: laneSummaries(state),
+    mergeQueue: mergeQueueRows(state),
     problem: problemStatus(state),
     evidence: (state.evidence ?? []).slice(-50),
     createdAt: state.createdAt,
@@ -1593,10 +1588,13 @@ export function statusReport(state, options = {}) {
     activeRequirementId: view.activeRequirementId,
     activeDecisionId: view.activeDecisionId,
     activeDecision: current === undefined ? null : boundedDecision(current),
+    lanes: view.lanes,
+    mergeQueue: view.mergeQueue,
     problem: boundedProblem(view.problem),
     counts: {
       identities: state.identities.length,
       requirements: state.requirements.length,
+      lanes: view.lanes.length,
       decisions: state.decisions.length,
       meetings: state.meetings.length,
       reviews: (state.reviews ?? []).length,
@@ -1743,4 +1741,6 @@ function normalizeTeamDocument(value) {
   if (value.activeRequirementId === undefined) value.activeRequirementId = null;
   if (value.activeDecisionId === undefined) value.activeDecisionId = null;
   if (value.watchdog === undefined) value.watchdog = null;
+  backfillLanes(value);
 }
+

package/lib/team-model.js

@@ -407,9 +407,9 @@ export const PRINCIPLES = Object.freeze([
     text: 'Missing hardware, a kernel, a dependency or a remote peer is not a blocker by itself. Cross-compile or JIT for an absent target device, build maintenance-support dependencies from source, and measure a transport on loopback before waiting for a peer. The Host accepts a blocked report once it observes an attempt; before that, the only honest move is to run the attempt. Workaround runs are detected and surfaced by the Host, never passed off as a fix.',
   }),
   Object.freeze({
-    id: 'one-cycle',
-    title: 'One deliverable, one cycle — fast dev is refused',
-    text: 'This workflow carries one whole deliverable from intake to retro in a single pass: one requirement, one plan, one vote, one implementation, one acceptance, one delivery. It is not a container for small steps. A second requirement is refused while the open one has not passed all of its criteria, and a smaller requirement cut out of an ask that is already open is refused with it. Fast dev is a trap for an agent, not for a human: an agent is already fast, so a smaller unit buys no time and pays the whole process again. Put the whole ask into one requirement, list every criterion at intake, implement it once, accept it once.',
+    id: 'parallel-lanes',
+    title: 'Many lanes at once, one master',
+    text: 'Several requirements run side by side: each lane carries its own stage, its own decision and its own evidence, so a second ask starts work while the first is still being implemented. Intake still takes the whole ask, every criterion listed at once, because splitting one ask into several lanes pays the vote and the acceptance round once per slice and hides the real work. What stays serial is the merge: deliveries join a queue and land on master one at a time, so master builds at every step. Proof is per lane: a commit names its branch, a command names its worktree, and another lane’s green run never satisfies this one.',
   }),
   Object.freeze({
     id: 'fast-fail',
@@ -523,7 +523,7 @@ You are the Assistant (assistant) of the Infinity Fabric AI Team. You are the se
 2. Intake and handoff
 - Extract the user's goal, acceptance criteria, boundaries, non-goals and risks.
 - Call infinity_team action "intake". It creates the tracked GitFox requirement. If no project is pinned yet, ask the Lead (or call action "configure" as lead) to pin one first; without tracking, no planning or implementation may exist.
-- One cycle at a time. Intake carries the whole ask: every criterion the user named, listed at once. A second intake while a requirement is open is recorded and queued behind it (never refused), and takes the stage when that cycle ends, so nothing the user asked for is lost and no case-by-case loop opens. If a check is wrong, use "amend"; if the ask grows, it belongs in the open requirement.
+- One lane per requirement, several lanes at once. Intake carries the whole ask: every criterion the user named, listed at once. A second intake opens its own lane at intake and starts work immediately instead of waiting behind the first; nothing the user asked for is lost and no case-by-case loop opens. Pass "requirement_id" whenever an action should land on a lane other than the focused one. Give each lane its own tree: the worker calls create_worktree for that lane (name it after the requirement id) and reports the branch and path back; you bind it with action "lane", and only you and the assistant can bind, because the binding decides whose evidence a commit is. From then on the worker runs every command inside that directory, so the Host attributes commits and runs to the right lane. If create_worktree is not available in this profile, run one lane at a time in the shared checkout: two workers in one tree cannot be told apart, and the evidence would land on the wrong lane. Delivery queues the lane for merge; master takes one branch at a time. If a check is wrong, use "amend"; if the ask grows, it belongs in the open requirement.
 - Then send the requirement id to lead with team_send_message. The Lead owns planning and execution.
 
 3. Identities and HR

package/lib/tool-schema.js

@@ -17,6 +17,7 @@ const ACTIONS = [
   'configure',
   'intake',
   'abandon',
+  'lane',
   'amend',
   'meeting',
   'propose_decision',
@@ -36,7 +37,7 @@ const ACTIONS = [
 
 /** Model-facing description of the `infinity_team` tool. */
 export const TOOL_DESCRIPTION =
-  'Infinity Fabric AI Team governance. "status" is a bounded read-only view: it leads with the active decision and the problem block and appends only the tables named in "include"; "roster" is read-only; "configure" pins the GitFox project locally (no issue; normally auto-discovered from the workspace remote); "intake" opens a tracked requirement with acceptance criteria plus one check per criterion (a criterion without a check is an opinion; the gate reads whether the check actually ran, not whether its wording looks like a command), and it carries the whole ask: while a requirement is open a new intake is recorded as queued and takes the stage when that cycle ends, so one cycle still runs at a time, nothing the user asked for is lost, and no case-by-case loop opens; "abandon" closes the active cycle without completion (reason required: the requirement is marked abandoned, its issue is annotated, the stage returns to intake and nothing is reported as done); "amend" swaps the command behind one criterion in place, keeping the criterion, the previous command and every run already recorded, so a check written before the flag existed does not cost a whole cycle; reopening the same request after an abandon needs "reopenReason", and a fourth attempt at the same request is refused; "meeting" records tracked minutes; "propose_decision"/"vote"/"decide" enforce the fixed four-seat unanimity, accept as many decisions for one requirement as it needs (there is no cap: every proposal still costs a fresh vote by all four seats, which is what bounds the loop), refuse "vote" and "decide" outside the vote stage so a decision takes effect where its votes were cast, and keep a rejected decision open until every seat has recorded its vote: a reject decides the outcome at once but never silences the remaining seats; "workflow" advances exactly one stage whose gate is read from the work the Host observed (a real commit, real check runs), never from a ticket or a label; a workspace that stays local is exempt from the commit bars: no stage waits for a commit and a check need not follow one, while the runs remain the evidence; "reviews" returns one newest-first page of the shared-state review queue (per_page 1-100, default 20; pass the returned "next_cursor" as "cursor" to drain it) and "review" records a required seat verdict; "publish" composes the cycle work record from the runs and commits the Host observed and posts it as a comment on the requirement ticket (the model does not write the record). Closing an issue or merging a merge request only needs every check to have been attempted once (a red or old run is reported to the seats, not held against the action), and the cycle ticket also needs its record published plus a docs+qa review before it closes. A process markdown file committed to the repository (evidence, gap reports, notes, retros) is refused: work is recorded on the ticket, the repository records the product. HR-only "define_role" creates a position the charter never had (id, name, mandate and the exact tool surface as a "capabilities" pair), "retire_role" closes one permanently, and "enroll"/"retire"/"spawn_member" manage the local roster. A defined position never holds a voting seat, and assistant/lead/hr can never be defined or retired. Model routing belongs exclusively to the human operator: the AI Team panel sets one team default and an optional pin per seat, and no Agent action can choose or change a model — HR included. Teams are per workspace; setup, charter and identities are local. A workspace that stays local still runs the team but opens GitFox issues/MR only when the user asks.';
+  'Infinity Fabric AI Team governance. "status" is a bounded read-only view: it leads with the active decision and the problem block, always lists the open lanes and the merge queue, and appends only the history tables named in "include"; "roster" is read-only; "configure" pins the GitFox project locally (no issue; normally auto-discovered from the workspace remote); "intake" opens a tracked requirement with acceptance criteria plus one check per criterion (a criterion without a check is an opinion; the gate reads whether the check actually ran, not whether its wording looks like a command), and it opens a lane: every requirement carries its own stage, its own decision and its own evidence, so several asks run side by side instead of waiting in a queue and nothing the user asked for is lost; "abandon" closes one lane without completion (pass "requirement_id", or the focused lane closes; reason required: the requirement is marked abandoned, its issue is annotated, nothing is reported as done, and the other lanes keep running); "lane" reports one lane and, when "branch" and "worktree" are given (assistant or Lead only), records where its work lives so its commits and commands are attributed to it and never to another lane; "amend" swaps the command behind one criterion in place, keeping the criterion, the previous command and every run already recorded, so a check written before the flag existed does not cost a whole cycle; reopening the same request after an abandon needs "reopenReason", and a fourth attempt at the same request is refused; "meeting" records tracked minutes; "propose_decision"/"vote"/"decide" enforce the fixed four-seat unanimity, accept as many decisions for one requirement as it needs (there is no cap: every proposal still costs a fresh vote by all four seats, which is what bounds the loop), refuse "vote" and "decide" outside the vote stage so a decision takes effect where its votes were cast, and keep a rejected decision open until every seat has recorded its vote: a reject decides the outcome at once but never silences the remaining seats; "workflow" advances one lane exactly one stage — pass "requirement_id" to move a lane that is not in focus — and its gate is read from the work the Host observed in that lane (a real commit on that lane’s branch, that lane’s own check runs), never from a ticket or a label; a workspace that stays local is exempt from the commit bars: no stage waits for a commit and a check need not follow one, while the runs remain the evidence; "reviews" returns one newest-first page of the shared-state review queue (per_page 1-100, default 20; pass the returned "next_cursor" as "cursor" to drain it) and "review" records a required seat verdict; "publish" composes the cycle work record from the runs and commits the Host observed and posts it as a comment on the requirement ticket (the model does not write the record). Closing a ticket or merging a merge request only needs that lane’s checks to have been attempted once (a red or old run is reported to the seats, not held against the action), and a lane ticket also needs its record published plus a docs+qa review before it closes. A process markdown file committed to the repository (evidence, gap reports, notes, retros) is refused: work is recorded on the ticket, the repository records the product. HR-only "define_role" creates a position the charter never had (id, name, mandate and the exact tool surface as a "capabilities" pair), "retire_role" closes one permanently, and "enroll"/"retire"/"spawn_member" manage the local roster. A defined position never holds a voting seat, and assistant/lead/hr can never be defined or retired. Model routing belongs exclusively to the human operator: the AI Team panel sets one team default and an optional pin per seat, and no Agent action can choose or change a model — HR included. Teams are per workspace; setup, charter and identities are local. A workspace that stays local still runs the team but opens GitFox issues/MR only when the user asks.';
 
 /** JSON-schema parameters of the `infinity_team` tool. */
 export const TOOL_PARAMETERS = {
@@ -45,7 +46,11 @@ export const TOOL_PARAMETERS = {
   properties: {
     action: { type: 'string', enum: ACTIONS, description: 'Team operation.' },
     project: { type: 'string', description: 'GitFox project in "namespace/name" form for "configure"; omit to keep the auto-discovered binding.' },
-    requirement_id: { type: 'string', description: 'Tracked requirement id for "propose_decision".' },
+    requirement_id: {
+      type: 'string',
+      description:
+        'Tracked requirement id. Names the lane for "lane", "workflow" and "abandon"; for "propose_decision" it names the requirement the decision is for.',
+    },
     decision_id: { type: 'string', description: 'Decision id for "vote"/"decide".' },
     title: { type: 'string', description: 'Requirement or decision title.' },
     request: { type: 'string', description: 'Verbatim user request for "intake".' },
@@ -90,6 +95,17 @@ export const TOOL_PARAMETERS = {
       description: 'Immediate next workflow stage.',
     },
     note: { type: 'string', description: 'Transition note.' },
+    branch: { type: 'string', description: 'For "lane": the branch this lane commits to.' },
+    mr: {
+      type: 'string',
+      description:
+        'For "lane": the merge request that will land this lane, as "project#iid". The merge gate then checks this lane, not whichever lane is focused.',
+    },
+    worktree: {
+      type: 'string',
+      description:
+        'For "lane": the absolute directory this lane works in (the path "create_worktree" returned). Commands run there are attributed to this lane.',
+    },
     review_id: { type: 'string', description: 'Review id for "review" (RV-0001 style).' },
     verdict: { type: 'string', enum: REVIEW_VERDICTS, description: 'Required-seat verdict for "review".' },
     op: {