@infinisys/is-fabric-team 0.1.0 → 0.2.0

package/lib/problem-gate.js

@@ -253,14 +253,45 @@ function evidenceOf(state) {
   return Array.isArray(state?.evidence) ? state.evidence : [];
 }
 
+/**
+ * The requirement one evidence row belongs to.
+ *
+ * Attribution is written when the row is observed, not guessed when it is read:
+ * a commit knows its branch and a command knows the directory it ran in, and the
+ * Host stamps both with the lane it resolved. Reading it back as an id is what
+ * keeps two lanes' runs apart — matching by command text alone let one lane's
+ * check green a criterion in another.
+ *
+ * @param {object} row - evidence row.
+ * @returns {string | null} requirement id, or null for evidence recorded while
+ *   no lane was open.
+ */
+export function requirementOfEvidence(row) {
+  return typeof row?.requirementId === 'string' ? row.requirementId : null;
+}
+
+/**
+ * The evidence rows that belong to one lane.
+ *
+ * @param {object} state - ledger state.
+ * @param {object | undefined} requirement - lane; defaults to the focused one.
+ * @returns {object[]} rows of that lane.
+ */
+function scopedRows(state, requirement) {
+  const id = requirement?.id ?? state?.activeRequirementId ?? null;
+  const rows = evidenceOf(state);
+  if (id === null) return rows;
+  return rows.filter((row) => requirementOfEvidence(row) === id);
+}
+
 /**
  * The position of the newest observed commit, or -1 when none exists.
  *
  * @param {object} state - ledger state.
  * @returns {number} evidence array index.
  */
-function newestCommitIndex(state) {
-  const rows = evidenceOf(state);
+function newestCommitIndex(state, requirement) {
+  const rows = scopedRows(state, requirement);
   for (let index = rows.length - 1; index >= 0; index -= 1) {
     if (rows[index]?.kind === 'commit') return index;
   }
@@ -303,10 +334,11 @@ export function runVerdict(command, check) {
  *
  * @param {object} state - ledger state.
  * @param {{ check?: string }} criterion - acceptance criterion.
+ * @param {object} [requirement] - lane whose run must count; defaults to the focused one.
  * @returns {object[]} matching command evidence.
  */
-export function runsOf(state, criterion) {
-  return runsOfVerdict(state, criterion, 'attributable');
+export function runsOf(state, criterion, requirement) {
+  return runsOfVerdict(state, criterion, 'attributable', requirement);
 }
 
 /**
@@ -318,22 +350,24 @@ export function runsOf(state, criterion) {
  *
  * @param {object} state - ledger state.
  * @param {{ check?: string }} criterion - acceptance criterion.
+ * @param {object} [requirement] - lane whose run must count; defaults to the focused one.
  * @returns {object[]} matching command evidence.
  */
-export function maskedRunsOf(state, criterion) {
-  return runsOfVerdict(state, criterion, 'masked');
+export function maskedRunsOf(state, criterion, requirement) {
+  return runsOfVerdict(state, criterion, 'masked', requirement);
 }
 
 /**
  * @param {object} state - ledger state.
  * @param {{ check?: string }} criterion - acceptance criterion.
  * @param {'attributable' | 'masked'} wanted - verdict to keep.
+ * @param {object} [requirement] - lane whose runs count.
  * @returns {object[]} matching command evidence.
  */
-function runsOfVerdict(state, criterion, wanted) {
+function runsOfVerdict(state, criterion, wanted, requirement) {
   const check = normalizeCommand(criterion?.check);
   if (check === '') return [];
-  const rows = evidenceOf(state).filter((row) => row.kind === 'command');
+  const rows = scopedRows(state, requirement).filter((row) => row.kind === 'command');
   const verdicts = commandVerdicts(rows, check);
   return rows.filter((row, index) => verdicts[index] === wanted);
 }
@@ -398,12 +432,13 @@ function commandVerdicts(rows, check) {
  *
  * @param {object} state - ledger state.
  * @param {{ check?: string }} criterion - acceptance criterion.
+ * @param {object} [requirement] - lane whose evidence decides this criterion.
  * @returns {{ passed: boolean, reason?: string, exitCode?: number, workaround?: boolean, neverFailed?: boolean, staleAgainst?: CommitFacts | null, masked?: string }} status.
  */
-export function criterionStatus(state, criterion) {
-  const runs = runsOf(state, criterion);
+export function criterionStatus(state, criterion, requirement) {
+  const runs = runsOf(state, criterion, requirement);
   if (runs.length === 0) {
-    const masked = maskedRunsOf(state, criterion);
+    const masked = maskedRunsOf(state, criterion, requirement);
     if (masked.length === 0) return { passed: false, reason: 'never-run' };
     return { passed: false, reason: 'masked-run', masked: String(masked.at(-1).detail ?? '') };
   }
@@ -413,10 +448,9 @@ export function criterionStatus(state, criterion) {
   }
   // Whether a commit landed after this run is a fact about the tree, not about
   // the check: it travels beside the pass so the reader can judge how old the
-  // evidence is, and never turns a green run into a refusal.
-  const rows = evidenceOf(state);
-  const commitIndex = isLocalOnly(state) ? -1 : newestCommitIndex(state);
-  const stale = commitIndex !== -1 && commitIndex > rows.indexOf(latest);
+  // evidence is, and never turns a green run into a refusal. Both sides are
+  // read inside the lane, so another lane's commit never ages this pass.
+  const staleAgainst = isLocalOnly(state) ? null : commitAfter(state, requirement, latest);
   // A failing run says the check exercises the problem — but it does not matter
   // *when* it ran, and it is not required at all. Requiring it asked the team to
   // manufacture the order (commit the broken state, run, then commit the fix),
@@ -428,10 +462,31 @@ export function criterionStatus(state, criterion) {
     passed: true,
     workaround: latest.workaround === true,
     neverFailed: !failed,
-    ...(stale ? { staleAgainst: commitFacts(rows[commitIndex]) } : {}),
+    ...(staleAgainst === null ? {} : { staleAgainst }),
   };
 }
 
+/**
+ * The newest commit on one lane when it was observed after a given row.
+ *
+ * Ordering is the order the Host recorded the rows in, not the clock: a commit
+ * and the run it followed can carry the same second, and a run recorded before
+ * a commit stays older than that commit. Both rows are read inside the lane, so
+ * another lane's commit never ages this pass.
+ *
+ * @param {object} state - ledger state.
+ * @param {object} requirement - lane to read.
+ * @param {object} row - the run being judged.
+ * @returns {CommitFacts | null} the newer commit, or null.
+ */
+function commitAfter(state, requirement, row) {
+  const index = newestCommitIndex(state, requirement);
+  if (index === -1) return null;
+  const newestRow = scopedRows(state, requirement)[index];
+  const all = evidenceOf(state);
+  return all.indexOf(newestRow) > all.indexOf(row) ? commitFacts(newestRow) : null;
+}
+
 /**
  * Short branch name for one evidence row, or null when the Host did not record
  * one (evidence written before branches were captured).
@@ -476,9 +531,9 @@ function commitFacts(row) {
  * @param {object} state - ledger state.
  * @returns {CommitFacts | null} newest commit, or null when none was observed.
  */
-export function newestCommit(state) {
-  const index = newestCommitIndex(state);
-  return index === -1 ? null : commitFacts(evidenceOf(state)[index]);
+export function newestCommit(state, requirement) {
+  const index = newestCommitIndex(state, requirement);
+  return index === -1 ? null : commitFacts(scopedRows(state, requirement)[index]);
 }
 
 /**
@@ -512,7 +567,7 @@ export function describeCommit(facts) {
  */
 export function productDelta(state, requirement) {
   const since = typeof requirement?.createdAt === 'string' ? requirement.createdAt : '';
-  const commits = evidenceOf(state).filter(
+  const commits = scopedRows(state, requirement).filter(
     (row) => row?.kind === 'commit' && String(row.at ?? '') >= since,
   );
   const mainline = commits.filter((row) => MAINLINE_BRANCHES.includes(branchName(row)));
@@ -541,12 +596,10 @@ export function productDelta(state, requirement) {
  * question about the instrument.
  *
  * @param {object} state - ledger state.
+ * @param {object} [requirement] - lane to report; defaults to the focused one.
  * @returns {{ resolved: boolean, requirementId: string | null, total: number, passed: number, workarounds: number[], neverFailed: number[], missing: object[], delta: ProductDelta, newest: CommitFacts | null, checks: { total: number, ran: number, neverRan: number, masked: number } }} status.
  */
-export function problemStatus(state) {
-  const requirement = (state.requirements ?? []).find(
-    (candidate) => candidate.id === state.activeRequirementId,
-  );
+export function problemStatus(state, requirement = activeRequirement(state)) {
   if (requirement === undefined) {
     return {
       resolved: false,
@@ -569,16 +622,18 @@ export function problemStatus(state) {
   }
   const rows = criteriaOf(requirement).map((criterion) => ({
     ...criterion,
-    ...criterionStatus(state, criterion),
+    ...criterionStatus(state, criterion, requirement),
   }));
   const missing = rows.filter((row) => row.passed !== true);
   // Three states, disjoint by construction: a check whose run carried its own
   // exit code, a check that ran but lost the exit code to a later command, and
   // a check never invoked at all. Calling the middle one "never ran" is what
   // told the team its finished work had not been attempted.
-  const ran = rows.filter((row) => runsOf(state, row).length > 0).length;
+  const ran = rows.filter((row) => runsOf(state, row, requirement).length > 0).length;
   const masked = rows.filter(
-    (row) => runsOf(state, row).length === 0 && maskedRunsOf(state, row).length > 0,
+    (row) =>
+      runsOf(state, row, requirement).length === 0 &&
+      maskedRunsOf(state, row, requirement).length > 0,
   ).length;
   return {
     resolved: rows.length > 0 && missing.length === 0,
@@ -589,7 +644,7 @@ export function problemStatus(state) {
     neverFailed: rows.filter((row) => row.neverFailed === true).map((row) => row.index),
     missing,
     delta: productDelta(state, requirement),
-    newest: newestCommit(state),
+    newest: newestCommit(state, requirement),
     checks: { total: rows.length, ran, masked, neverRan: rows.length - ran - masked },
   };
 }
@@ -613,10 +668,10 @@ export function problemStatus(state) {
  * With no active requirement nothing is in flight, so nothing is gated.
  *
  * @param {object} state - ledger state.
+ * @param {object} [requirement] - lane whose criteria are being closed over.
  * @returns {{ gated: boolean, resolved: boolean, requirementId: string | null, total: number, ran: number, passed: number, failed: object[], missing: object[], newest: CommitFacts | null }} status.
  */
-export function closureStatus(state) {
-  const requirement = activeRequirement(state);
+export function closureStatus(state, requirement = activeRequirement(state)) {
   if (requirement === undefined) {
     return {
       gated: false,
@@ -627,7 +682,7 @@ export function closureStatus(state) {
       passed: 0,
       failed: [],
       missing: [],
-      newest: newestCommit(state),
+      newest: newestCommit(state, requirement),
     };
   }
   const criteria = criteriaOf(requirement).filter(
@@ -635,7 +690,7 @@ export function closureStatus(state) {
   );
   const rows = criteria.map((criterion) => ({
     ...criterion,
-    ...criterionStatus(state, criterion),
+    ...criterionStatus(state, criterion, requirement),
   }));
   const missing = rows.filter((row) => row.passed !== true);
   const failed = rows.filter((row) => row.reason === 'failed');
@@ -650,34 +705,92 @@ export function closureStatus(state) {
     passed: rows.length - missing.length,
     failed,
     missing,
-    newest: newestCommit(state),
+    newest: newestCommit(state, requirement),
   };
 }
 
 /**
- * Whether a closing target is the ticket the ledger opened for the active
- * requirement.
+ * The open lane whose ticket a closing action targets.
  *
- * Only that ticket stands for the problem this cycle claims to solve. Meeting
- * tickets, decision tickets and tickets from other work are discussion
- * bookkeeping: the gate must not hold them open until the cycle ends.
+ * Only a lane's own ticket stands for the problem that lane claims to solve, so
+ * the bar is read from that lane rather than from whatever happens to hold the
+ * focus. Meeting tickets, decision tickets and tickets from other work are
+ * discussion bookkeeping: the gate must not hold them open until a lane ends.
+ *
+ * @param {object} state - ledger state.
+ * @param {{ verb: string, project: string, iid?: number }} target - artifact action.
+ * @returns {object | undefined} the lane that owns the ticket.
+ */
+export function laneOwningIssue(state, target) {
+  if (target?.verb !== 'close' || typeof target.project !== 'string') return undefined;
+  const iid = Number(target.iid);
+  if (!Number.isInteger(iid)) return undefined;
+  const wanted = target.project.trim().toLowerCase();
+  return (state.requirements ?? []).find((requirement) => {
+    if (requirement.status !== undefined && requirement.status !== 'open') return false;
+    const tracking = requirement.tracking;
+    if (tracking === null || tracking === undefined) return false;
+    if (typeof tracking.project !== 'string' || !Number.isInteger(tracking.issue)) return false;
+    return tracking.issue === iid && tracking.project.trim().toLowerCase() === wanted;
+  });
+}
+
+/**
+ * The open lane whose merge request a merging action targets.
+ *
+ * A merge names a project and an iid, never a requirement, so the lane has to
+ * be bound to its request (`action "lane"` with `mr`). Without a binding the
+ * gate leaves the merge alone rather than checking the focused lane: holding an
+ * unrelated request to another lane's bar is worse than not gating it.
+ *
+ * @param {object} state - ledger state.
+ * @param {{ verb: string, project: string, iid?: number }} target - artifact action.
+ * @returns {object | undefined} the lane that owns the request.
+ */
+export function laneOwningMerge(state, target) {
+  if (target?.verb !== 'merge' || typeof target.project !== 'string') return undefined;
+  const iid = Number(target.iid);
+  if (!Number.isInteger(iid)) return undefined;
+  const wanted = target.project.trim().toLowerCase();
+  return (state.requirements ?? []).find((requirement) => {
+    if (requirement.status !== undefined && requirement.status !== 'open') return false;
+    const request = requirement.mergeRequest;
+    if (request === undefined || request === null) return false;
+    return request.iid === iid && String(request.project).trim().toLowerCase() === wanted;
+  });
+}
+
+/**
+ * Why a merge must wait for the queue.
+ *
+ * Deliveries land one at a time so `master` builds at every step. A request
+ * that is not in the queue is none of this rule's business (a hotfix, a release
+ * branch); one that is queued but not at the head waits, and the refusal names
+ * who goes first.
+ *
+ * @param {object} state - ledger state.
+ * @param {object | undefined} lane - the lane the request belongs to.
+ * @param {{ ref: string }} target - merge action.
+ * @returns {string | undefined} refusal reason.
+ */
+export function mergeQueueRefusal(state, lane, target) {
+  if (lane === undefined) return undefined;
+  const queue = Array.isArray(state.mergeQueue) ? state.mergeQueue : [];
+  const position = queue.findIndex((row) => row.requirementId === lane.id);
+  if (position <= 0) return undefined;
+  const head = queue[0].requirementId;
+  return `merge-queued: ${target.ref} belongs to ${lane.id}, and ${head} is ahead of it in the merge queue. Deliveries land one at a time so master builds at every step: wait for ${head} to land, then merge this one.`;
+}
+
+/**
+ * Whether a closing target is a ticket the ledger opened for an open lane.
  *
  * @param {object} state - ledger state.
  * @param {{ verb: string, project: string, iid?: number }} target - artifact action.
  * @returns {boolean} true when the ledger owns the ticket.
  */
 export function ownsActiveIssue(state, target) {
-  if (target?.verb !== 'close') return false;
-  const tracking = activeRequirement(state)?.tracking;
-  if (tracking === null || tracking === undefined) return false;
-  if (typeof tracking.project !== 'string' || !Number.isInteger(tracking.issue)) return false;
-  if (typeof target.project !== 'string') return false;
-  const iid = Number(target.iid);
-  return (
-    Number.isInteger(iid) &&
-    iid === tracking.issue &&
-    tracking.project.trim().toLowerCase() === target.project.trim().toLowerCase()
-  );
+  return laneOwningIssue(state, target) !== undefined;
 }
 
 /**
@@ -705,11 +818,12 @@ function missingText(row) {
  *
  * @param {object} state - ledger state.
  * @param {string} action - blocked action name for the message.
+ * @param {object} [requirement] - lane making the claim.
  * @returns {void}
  * @throws {TeamError} when no criterion has been attempted.
  */
-export function assertProblemResolved(state, action) {
-  const status = closureStatus(state);
+export function assertProblemResolved(state, action, requirement) {
+  const status = closureStatus(state, requirement);
   if (status.resolved) return;
   const unobserved = status.missing.filter(
     (row) => row.reason === 'never-run' || row.reason === 'masked-run',
@@ -732,17 +846,18 @@ export function assertProblemResolved(state, action) {
  *
  * @param {object} state - ledger state.
  * @param {string} target - target stage.
+ * @param {object} [requirement] - lane being advanced.
  * @returns {void}
  * @throws {TeamError} when the observed work does not support the stage.
  */
-export function assertStageProof(state, target) {
+export function assertStageProof(state, target, requirement = activeRequirement(state)) {
   if (!STAGES_USING_PROOF.includes(target)) return;
   if (target === 'implementation') {
     // A local-only workspace has no remote to publish to; the commit bar would
     // only make the team commit for the gate. The approved decision, enforced
     // by the caller, is the whole bar there.
     if (isLocalOnly(state)) return;
-    if (newestCommitIndex(state) === -1) {
+    if (newestCommitIndex(state, requirement) === -1) {
       throw new TeamError(
         'stage "implementation" requires a commit recorded by infinity_git; the gate reads the commit, not a ticket or an evidence id',
         'gate-unsatisfied',
@@ -751,14 +866,14 @@ export function assertStageProof(state, target) {
     return;
   }
   if (target === 'test') {
-    const missing = criteriaOf(activeRequirement(state)).filter(
-      (criterion) => runsOf(state, criterion).length === 0,
+    const missing = criteriaOf(requirement).filter(
+      (criterion) => runsOf(state, criterion, requirement).length === 0,
     );
     if (missing.length > 0) {
       throw new TeamError(
         `stage "test" requires every check to have run at least once, as the last command on its line. Not attributable yet: ${missing
           .map((criterion) => {
-            const masked = maskedRunsOf(state, criterion).length > 0;
+            const masked = maskedRunsOf(state, criterion, requirement).length > 0;
             return `#${criterion.index} ${criterion.check ?? '(no check)'}${masked ? ' (ran, but a later command in the same line took its exit code)' : ''}`;
           })
           .join('; ')}`,
@@ -767,7 +882,7 @@ export function assertStageProof(state, target) {
     }
     return;
   }
-  assertProblemResolved(state, target);
+  assertProblemResolved(state, target, requirement);
 }
 
 /**
@@ -788,7 +903,12 @@ export function activeRequirement(state) {
  * published?" from facts rather than from prose.
  *
  * @param {object} state - ledger state.
- * @param {{ kind: string, detail: string, tool: string, member: string, role?: string, branch?: string, files?: string[], exitCode?: number, workaround?: boolean, ref?: string, noteId?: number, now: string }} input - evidence.
+ * Every row is stamped with the lane it was observed in. That stamp is what
+ * keeps two lanes' runs apart when they run the same command, and what lets the
+ * gate read one lane's work while another is still editing.
+ *
+ * @param {object} state - ledger state.
+ * @param {{ kind: string, detail: string, tool: string, member: string, role?: string, requirementId?: string, branch?: string, files?: string[], exitCode?: number, workaround?: boolean, ref?: string, noteId?: number, now: string }} input - evidence.
  * @returns {object} recorded evidence.
  */
 export function recordEvidence(state, input) {
@@ -801,6 +921,7 @@ export function recordEvidence(state, input) {
     detail: String(input.detail).slice(0, 500),
     tool: input.tool,
     member: input.member,
+    requirementId: input.requirementId ?? state.activeRequirementId ?? null,
     ...optionalEvidence(input),
     at: input.now,
   };

package/lib/problem-host.js

@@ -18,10 +18,96 @@ import {
   artifactRefusal,
   closureStatus,
   isWorkaroundRun,
-  ownsActiveIssue,
+  laneOwningIssue,
+  laneOwningMerge,
+  mergeQueueRefusal,
   recordEvidence,
 } from './problem-gate.js';
 
+/**
+ * Normalize a branch name for comparison.
+ *
+ * @param {unknown} value - branch text.
+ * @returns {string} short branch name.
+ */
+function shortBranch(value) {
+  return String(value ?? '').trim().replace(/^refs\/heads\//, '');
+}
+
+/**
+ * The open lanes still doing work.
+ *
+ * @param {object} state - ledger state.
+ * @returns {object[]} lanes.
+ */
+function runningLanes(state) {
+  return (state.requirements ?? []).filter(
+    (requirement) => requirement.status === undefined || requirement.status === 'open',
+  );
+}
+
+/**
+ * Whether one directory sits inside a lane's worktree.
+ *
+ * @param {string | null} cwd - session directory.
+ * @param {unknown} worktree - lane worktree.
+ * @returns {boolean} true when the directory belongs to the lane.
+ */
+function insideWorktree(cwd, worktree) {
+  if (typeof cwd !== 'string' || typeof worktree !== 'string' || worktree === '') return false;
+  const base = worktree.replace(/[\\/]+$/, '');
+  return cwd === base || cwd.startsWith(`${base}/`) || cwd.startsWith(`${base}\\`);
+}
+
+/**
+ * Which lane a piece of evidence was observed in.
+ *
+ * Attribution is read from the fact the tool produced: a commit names its
+ * branch, a command names the directory it ran in, a note names the thread it
+ * landed on. Each of those is set before the model speaks, so two lanes editing
+ * at once cannot claim each other's work. When nothing matches — a commit on
+ * `master`, a command run outside every worktree — the focused lane owns it,
+ * which is what a single-lane team meant anyway.
+ *
+ * @param {object} state - ledger state.
+ * @param {{ kind: string, branch?: string, ref?: string }} evidence - observed evidence.
+ * @param {string | null} cwd - directory the call ran in.
+ * @returns {string | null} requirement id.
+ */
+export function laneForEvidence(state, evidence, cwd) {
+  const match = runningLanes(state).find(matcher(evidence, cwd));
+  return match?.id ?? state.activeRequirementId ?? null;
+}
+
+/**
+ * The predicate that reads one kind of evidence against a lane.
+ *
+ * @param {{ kind: string, branch?: string, ref?: string }} evidence - observed evidence.
+ * @param {string | null} cwd - directory the call ran in.
+ * @returns {(lane: object) => boolean} lane predicate.
+ */
+function matcher(evidence, cwd) {
+  if (evidence.kind === 'commit') {
+    const branch = shortBranch(evidence.branch);
+    return (lane) => branch !== '' && shortBranch(lane.branch) === branch;
+  }
+  if (evidence.kind === 'command') return (lane) => insideWorktree(cwd, lane.worktree);
+  const ref = String(evidence.ref ?? '').trim().toLowerCase();
+  return (lane) => threadRef(lane) === ref;
+}
+
+/**
+ * The ticket reference of one lane, lowercased.
+ *
+ * @param {object} lane - requirement record.
+ * @returns {string} `project#iid`, or an empty string.
+ */
+function threadRef(lane) {
+  const tracking = lane.tracking;
+  if (typeof tracking?.project !== 'string' || !Number.isInteger(tracking?.issue)) return '';
+  return `${tracking.project.trim().toLowerCase()}#${tracking.issue}`;
+}
+
 /**
  * Commit evidence from a successful `infinity_git commit` result.
  *
@@ -134,6 +220,7 @@ export function createProblemController({
   loadState,
   memberOf,
   isTeamAgent,
+  cwdOf = () => null,
   withTeam = (_agent, run) => run(),
 }) {
   /**
@@ -150,8 +237,10 @@ export function createProblemController({
     await store.mutate((draft, now) => {
       const member = memberOf(draft, execution.agent);
       if (member === undefined) return undefined;
+      const requirementId = laneForEvidence(draft, evidence, cwdOf(execution.agent));
       return recordEvidence(draft, {
         ...evidence,
+        ...(requirementId === null ? {} : { requirementId }),
         member: member.name,
         role: member.role,
         now,
@@ -186,8 +275,13 @@ export function createProblemController({
         ? undefined
         : `problem-unresolved: the team ledger is unreadable, so the verification state is unknown; refusing to merge ${target.ref}`;
     }
-    if (target.verb === 'close' && !ownsActiveIssue(state, target)) return undefined;
-    const status = closureStatus(state);
+    const lane =
+      target.verb === 'close' ? laneOwningIssue(state, target) : laneOwningMerge(state, target);
+    if (target.verb === 'close' && lane === undefined) return undefined;
+    const queued = mergeQueueRefusal(state, lane, target);
+    if (queued !== undefined) return queued;
+    if (target.verb === 'merge' && lane === undefined) return undefined;
+    const status = closureStatus(state, lane);
     return status.resolved ? undefined : artifactRefusal(target, status);
   }
 

package/lib/publish-action.js

@@ -1,4 +1,4 @@
-import { TeamError, requireSeeded } from './team-core.js';
+import { TeamError, laneFor, requireSeeded } from './team-core.js';
 import { activeRequirement, problemStatus, recordEvidence } from './problem-gate.js';
 import { trackedThread, workRecordBody } from './work-record-gate.js';
 
@@ -18,12 +18,14 @@ import { trackedThread, workRecordBody } from './work-record-gate.js';
  * @param {(ctx: object, operation: () => Promise<unknown>, action: string) => Promise<unknown>} deps.tracked - GitFox error mapper.
  * @param {object} deps.ctx - Host context with the DevOps service.
  * @param {{ member: string, role: string }} deps.caller - caller.
+ * @param {string} [deps.requirementId] - lane to publish, defaulting to the focused one.
  * @returns {Promise<object>} published record summary.
  */
-export async function publishWorkRecord({ store, loadState, tracked, ctx, caller }) {
+export async function publishWorkRecord({ store, loadState, tracked, ctx, caller, requirementId }) {
   const state = await loadState(store);
   requireSeeded(state);
-  const requirement = activeRequirement(state);
+  const requirement =
+    requirementId === undefined ? activeRequirement(state) : laneFor(state, requirementId);
   if (requirement === undefined) {
     throw new TeamError(
       'there is no active requirement, so there is no cycle whose work record could be published',
@@ -31,7 +33,7 @@ export async function publishWorkRecord({ store, loadState, tracked, ctx, caller
       { status: 409 },
     );
   }
-  const thread = trackedThread(state);
+  const thread = trackedThread(state, requirement);
   if (thread === undefined) {
     throw new TeamError(
       'the active requirement has no tracked ticket, and a work record belongs to a thread: open tracked intake against the GitFox project, then publish',
@@ -58,11 +60,12 @@ export async function publishWorkRecord({ store, loadState, tracked, ctx, caller
       member: caller.member,
       role: caller.role,
       ref: thread.ref,
+      requirementId: requirement.id,
       ...(Number.isInteger(noteId) ? { noteId } : {}),
       now,
     });
   });
-  const status = problemStatus(state);
+  const status = problemStatus(state, requirement);
   return {
     action: 'publish',
     ref: thread.ref,

package/lib/session-dir.js

@@ -0,0 +1,21 @@
+/**
+ * The directory a session is working in right now.
+ *
+ * `session.header.cwd` keeps the directory the session was opened with, so a
+ * worker that moved into a worktree still reports the project root there. The
+ * live directory lives on the `workingDirectory` service; the header is only the
+ * fallback for a Host without that service.
+ *
+ * @param {object} ctx - Host context.
+ * @param {object} agent - live Agent.
+ * @returns {string | null} directory, or null when it is unknown.
+ */
+export function currentDirectory(ctx, agent) {
+  const session = agent?.session;
+  if (session === undefined) return null;
+  try {
+    return ctx.workingDirectory?.get?.(session) ?? session.header?.cwd ?? null;
+  } catch {
+    return session.header?.cwd ?? null;
+  }
+}