faberun 0.13.0 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "faberun",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Faberun is a development orchestration system that turns intent into verified software: harness- and model-agnostic, it keeps the intent, coordinates the work, verifies the result and decides what happens next.",
   "type": "module",
   "bin": {

package/src/campaign/index.mjs

@@ -21,7 +21,9 @@ import { handoffFromState, materializeHandoff } from "./handoff.mjs";
 /** @typedef {{path: string, digest: string}} CampaignContract */
 /** @typedef {{runId: string, contractPath?: string, branch: string, sha: string, previousSha: string|null, at: string}} PromotionRecord */
 /** @typedef {{code: string, message: string, at: string, contractPath?: string, contractId?: string, runId?: string, node?: string|null, status?: string|null, resume?: string}} CampaignAttention */
-/** @typedef {{id: string, goal: string, status: "active"|"closed", linkedRunIds: string[], contracts: CampaignContract[], landBranch: string, promotions: PromotionRecord[], attention?: CampaignAttention, createdAt: string, updatedAt: string, closedAt?: string}} Campaign */
+/** @typedef {{runId: string, node: string, passed: boolean|null, verdict: string|null}} RequirementNodeEvidence */
+/** @typedef {{requirementId: string, status: "covered"|"open", nodes: RequirementNodeEvidence[]}} RequirementClosure */
+/** @typedef {{id: string, goal: string, status: "active"|"closed", linkedRunIds: string[], contracts: CampaignContract[], landBranch: string, promotions: PromotionRecord[], attention?: CampaignAttention, requirements?: RequirementClosure[], createdAt: string, updatedAt: string, closedAt?: string}} Campaign */
 /** @typedef {{type: string, eventId: string, at: string, sessionId?: string, text?: string, tool?: string, transcript?: string|null, transcriptUnavailable?: boolean, format?: string|null, cursor?: string|null, decisionId?: string, supersedes?: string, runId?: string, questionId?: string, campaignId?: string, nodeId?: string|null, phase?: string, checkpointsDone?: number, checkpointsTotal?: number, runtime?: string|null, state?: string, lastProgressAt?: string, attention?: string|null}} JournalEntry */
 /** @typedef {{updatedAt: string|null, decisions: Record<string, JournalEntry>, questions: Record<string, JournalEntry>, constraints: JournalEntry[], intents: JournalEntry[], outcomes: JournalEntry[], sessions: JournalEntry[], next: JournalEntry|null, evicted: Record<string, number>}} Projection */
 /** @typedef {{cursor: number, byte: number, size: number, projection: Projection}} ProjectionRecord */
@@ -135,12 +137,82 @@ export function closeCampaign(campaignPath, { at = new Date().toISOString(), eve
   }
   const repoRoot = campaignRepoRoot(campaignPath);
   const ledgerFiles = preserveCampaignLedger(campaignPath, repoRoot);
-  const closed = /** @type {Campaign} */ ({ ...campaign, status: "closed", closedAt: at, updatedAt: at });
+  // The closure travels on the record itself, computed in one deterministic
+  // pass over the linked runs' own files before the close is written.
+  const requirements = buildRequirementClosure(campaignPath, campaign);
+  /** @type {Campaign} */
+  const closed = { ...campaign, status: "closed", closedAt: at, updatedAt: at, requirements };
   writeJsonAtomic(join(campaignPath, CAMPAIGN_FILE), closed);
   appendJournal(campaignPath, { type: "campaign.closed", at, eventId });
   return { path: campaignPath, campaign: closed, ledgerFiles };
 }
 
+/**
+ * The requirement closure a close records: one entry per requirement id the
+ * linked runs' contracts declared, correlated only by the identifiers the runs
+ * carried -- the contract node's declaration and the id the done node snapshot
+ * itself carries, stamped there by the engine -- never by requirement text. A
+ * requirement no done node carries is recorded as open rather than omitted.
+ * Deterministic and free of external calls: runs are visited in sorted id
+ * order, nodes in contract order, requirement ids sorted, and the only inputs
+ * are files already on disk. A run that never launched (or was pruned)
+ * contributes nothing.
+ *
+ * @param {string} campaignPath
+ * @param {Campaign} campaign
+ * @returns {RequirementClosure[]}
+ */
+function buildRequirementClosure(campaignPath, campaign) {
+  const runsDir = resolve(campaignPath, "..", "..");
+  /** @type {Map<string, RequirementNodeEvidence[]>} */
+  const covered = new Map();
+  /** @type {Set<string>} */
+  const declared = new Set();
+  for (const runId of [...campaign.linkedRunIds].sort()) {
+    const contract = readRunJson(join(runsDir, runId, "contract.json"));
+    const nodes = contract !== null && Array.isArray(contract.nodes) ? /** @type {JsonObject[]} */ (contract.nodes) : [];
+    for (const node of nodes) {
+      const nodeId = typeof node.id === "string" ? node.id : "";
+      const requirementIds = Array.isArray(node.requirementIds) ? node.requirementIds : [];
+      if (!nodeId || requirementIds.length === 0) continue;
+      const snapshot = readRunJson(join(runsDir, runId, "nodes", `${nodeId}.json`));
+      const done = snapshot !== null && snapshot.status === "done";
+      const carried = snapshot !== null && Array.isArray(snapshot.requirementIds) ? /** @type {unknown[]} */ (snapshot.requirementIds) : [];
+      const verification = snapshot !== null ? /** @type {JsonObject|null|undefined} */ (snapshot.verification) : undefined;
+      const gate = snapshot !== null ? /** @type {JsonObject|null|undefined} */ (snapshot.gate) : undefined;
+      const passed = verification && typeof verification.passed === "boolean" ? verification.passed : null;
+      const verdict = gate && typeof gate.verdict === "string" ? gate.verdict : null;
+      for (const requirementId of requirementIds) {
+        if (typeof requirementId !== "string") continue;
+        declared.add(requirementId);
+        if (!done || !carried.includes(requirementId)) continue;
+        const evidence = covered.get(requirementId) ?? [];
+        evidence.push({ runId, node: nodeId, passed, verdict });
+        covered.set(requirementId, evidence);
+      }
+    }
+  }
+  return [...declared].sort().map((requirementId) => {
+    const nodes = covered.get(requirementId) ?? [];
+    return { requirementId, status: nodes.length > 0 ? "covered" : "open", nodes };
+  });
+}
+
+/**
+ * @param {string} path
+ * @returns {JsonObject|null} null when the file is absent or not JSON: a run
+ * that never launched contributes nothing to the closure rather than failing
+ * the close, the same discipline `preserveCampaignLedger` applies to a run
+ * without a usage ledger.
+ */
+function readRunJson(path) {
+  try {
+    return /** @type {JsonObject} */ (JSON.parse(readFileSync(path, "utf8")));
+  } catch {
+    return null;
+  }
+}
+
 /**
  * The repository a campaign's ledger is preserved into. Under the home layout
  * the campaign path carries the project id at the resolver's fixed position,

package/src/campaign/record.mjs

@@ -99,4 +99,32 @@ function validateCampaign(campaign) {
       if (promotion.contractPath !== undefined) requireString(promotion.contractPath, `campaign.promotions[${index}].contractPath`);
     }
   }
+  // The requirement closure a close records: one entry per requirement id the
+  // linked runs' contracts declared, correlated by the identifiers the runs
+  // carried, with every uncovered requirement kept as open. Optional on read
+  // so a campaign closed before the field existed stays readable.
+  if (record.requirements !== undefined) {
+    if (!Array.isArray(record.requirements)) throw new TypeError("campaign.requirements must be an array");
+    for (const [index, entry] of record.requirements.entries()) {
+      assertObject(entry, `campaign.requirements[${index}]`);
+      const closure = /** @type {JsonObject} */ (entry);
+      requireId(closure.requirementId, `campaign.requirements[${index}].requirementId`);
+      if (closure.status !== "covered" && closure.status !== "open") {
+        throw new TypeError(`campaign.requirements[${index}].status must be covered or open`);
+      }
+      if (!Array.isArray(closure.nodes)) throw new TypeError(`campaign.requirements[${index}].nodes must be an array`);
+      for (const [position, evidence] of closure.nodes.entries()) {
+        assertObject(evidence, `campaign.requirements[${index}].nodes[${position}]`);
+        const node = /** @type {JsonObject} */ (evidence);
+        requireId(node.runId, `campaign.requirements[${index}].nodes[${position}].runId`);
+        requireId(node.node, `campaign.requirements[${index}].nodes[${position}].node`);
+        if (node.passed !== null && typeof node.passed !== "boolean") {
+          throw new TypeError(`campaign.requirements[${index}].nodes[${position}].passed must be a boolean or null`);
+        }
+        if (node.verdict !== null && typeof node.verdict !== "string") {
+          throw new TypeError(`campaign.requirements[${index}].nodes[${position}].verdict must be a string or null`);
+        }
+      }
+    }
+  }
 }

package/src/contract/index.mjs

@@ -37,7 +37,7 @@ const CONTRACT_FIELDS = new Set([
 ]);
 const DEFAULTS_FIELDS = new Set(["worker", "judge"]);
 const NODE_FIELDS = new Set([
-  "id", "type", "phase", "runtime", "dependsOn", "taskPacket", "taskPacketFile", "prompt", "promptFile",
+  "id", "type", "phase", "requirementIds", "runtime", "dependsOn", "taskPacket", "taskPacketFile", "prompt", "promptFile",
   "definitionOfDone", "gate", "timeoutSec", "maxTurns",
   "requiredCapabilities", "packetHash", "sourceIdentity", "replayPolicy",
 ]);
@@ -68,7 +68,7 @@ const GATE_REVIEWS = new Set(["none", "advisory", "blocking"]);
 
 /** @typedef {{enabled: boolean, review?: ("none"|"advisory"|"blocking"), runtime?: string, failOn?: ("minor"|"major"|"critical")[], maxRevisions?: number, requiredCapabilities?: CapabilityRequirements, skipWhen?: {verificationGreen: true, maxChangedPaths: number}}} ValidatedGate */
 
-/** @typedef {{id: string, type: string, phase: string, runtime?: string, dependsOn: string[], taskPacket: TaskPacket, taskPacketFile?: string, prompt: string, definitionOfDone: import("./definition-of-done.mjs").DefinitionOfDoneItem[], gate: ValidatedGate, timeoutSec?: number, maxTurns?: number, requiredCapabilities: CapabilityRequirements, packetHash: string, sourceIdentity: SourceIdentity, replayPolicy: "safe"|"reconcile"|"never"}} ValidatedNode */
+/** @typedef {{id: string, type: string, phase: string, requirementIds?: string[], runtime?: string, dependsOn: string[], taskPacket: TaskPacket, taskPacketFile?: string, prompt: string, definitionOfDone: import("./definition-of-done.mjs").DefinitionOfDoneItem[], gate: ValidatedGate, timeoutSec?: number, maxTurns?: number, requiredCapabilities: CapabilityRequirements, packetHash: string, sourceIdentity: SourceIdentity, replayPolicy: "safe"|"reconcile"|"never"}} ValidatedNode */
 
 /** @typedef {{schemaVersion: number, contractVersion: string, id: string, campaignId: string, goal: string, cwd: string, sourceIdentity: SourceIdentity, runtimes: Record<string, ValidatedRuntime>, runtimeDefaults: {worker?: string, judge?: string}, nodes: ValidatedNode[], maxParallel: number, pollIntervalMs: number, stallTimeoutSec: number, timeoutSec: number, maxTurns: number, phaseSessionReuse: boolean, finalVerification?: VerificationCommand[], sharedVerification?: VerificationCommand[], nodeAdvisory?: NodeAdvisoryPolicy, warnings: string[]}} ValidatedContract */
 /** @typedef {{costUsd?: number, durationSec?: number}} NodeAdvisoryPolicy */
@@ -98,11 +98,11 @@ const GATE_REVIEWS = new Set(["none", "advisory", "blocking"]);
 /** @typedef {{history: RoutingHistoryEntry[], currentOverride: RoutingOverride|null, assignments?: RuntimeAssignments, availability?: Record<string, RuntimeAvailability>, tierExhaustion?: TierExhaustion, tierExhaustionCycle?: number}} RoutingState */
 /** @typedef {{revision?: number, heartbeatCount: number, dryHeartbeatCount: number, progressSignature?: string|null, lastHeartbeatAt: string|null, lastProgressAt: string|null, nextCheckAt?: string|null}} ProgressState */
 /** @typedef {{status: "unassigned"|"provisioning"|"ready"|"failed"|"removed", path: string|null, branch: string|null, commit: string|null, baseSha?: string|null, sealedSha?: string|null, sealError?: string|null, previousAttempt?: number|null}} WorktreeState */
-/** @typedef {{schemaVersion: number, contractVersion: string, id: string, type: string, sourceIdentity: SourceIdentity, packetHash: string, status: NodeStatus, phase: NodePhase, attempt: number, revisions: number, judgeFailures?: number, review?: ("none"|"advisory"|"blocking"), runtime: RuntimeSnapshot|null, blockedBy: string[], startedAt: string|null, updatedAt: string, result: unknown, gate: GateResult|null, error: SnapshotError|null, usage?: Usage, costUsd?: number, routing?: RoutingState|null, progress?: ProgressState|null, worktree?: WorktreeState|null, integratedHead?: string|null, invocations?: Invocation[], executionOverrides?: ExecutionOverride[], verification?: VerificationState|null, scope?: BoundedScope|null, scopeFindings?: ScopeFindings|null, previousAttempt?: string, sessionPolicy?: {forceFresh?: boolean}|null, declaredReadBytes?: number|null}} NodeSnapshot */
+/** @typedef {{schemaVersion: number, contractVersion: string, id: string, type: string, sourceIdentity: SourceIdentity, packetHash: string, requirementIds?: string[], status: NodeStatus, phase: NodePhase, attempt: number, revisions: number, judgeFailures?: number, review?: ("none"|"advisory"|"blocking"), runtime: RuntimeSnapshot|null, blockedBy: string[], startedAt: string|null, updatedAt: string, result: unknown, gate: GateResult|null, error: SnapshotError|null, usage?: Usage, costUsd?: number, routing?: RoutingState|null, progress?: ProgressState|null, worktree?: WorktreeState|null, integratedHead?: string|null, invocations?: Invocation[], executionOverrides?: ExecutionOverride[], verification?: VerificationState|null, scope?: BoundedScope|null, scopeFindings?: ScopeFindings|null, previousAttempt?: string, sessionPolicy?: {forceFresh?: boolean}|null, declaredReadBytes?: number|null}} NodeSnapshot */
 /** @typedef {{path: string, sha: string}} ControllerIdentity */
 /** @typedef {{schemaVersion: number, contractVersion: string, pid: number, processStartToken: string|null, startedAt: string, sourceIdentity: SourceIdentity, controllerIdentity?: ControllerIdentity, integrationRef?: string, identityWarnings?: string[], relaunchCount?: number, lastRelaunchProgressAt?: string|null, attention?: {code: string, message: string, at: string}|null, contractDigest?: string, scopeDecision?: ScopeDecision, autoRetries?: Record<string, {code: string, at: string}>}} RunMetadata */
 /** @typedef {{at: string, base: string|null, dirtyTreeFingerprint: string|null}} ScopeDecision */
-/** @typedef {{schemaVersion: number, contractVersion: string, at: string, node: string, from?: string, to: string, type?: string, phase?: string, attempt?: number, role?: "worker"|"judge", status?: NodeStatus, runtime?: string, currentRuntime?: string, errorCode?: string, error?: SnapshotError, verdict?: string, summary?: string, revisions?: number, sourceIdentity: SourceIdentity, packetHash: string, override?: unknown, recovery?: unknown, invocationId?: string, unexpectedPaths?: string[], unexpectedPathCount?: number}} EventRecord */
+/** @typedef {{schemaVersion: number, contractVersion: string, at: string, node: string, from?: string, to: string, type?: string, phase?: string, attempt?: number, role?: "worker"|"judge", status?: NodeStatus, runtime?: string, currentRuntime?: string, errorCode?: string, error?: SnapshotError, verdict?: string, summary?: string, revisions?: number, requirementIds?: string[], sourceIdentity: SourceIdentity, packetHash: string, override?: unknown, recovery?: unknown, invocationId?: string, unexpectedPaths?: string[], unexpectedPathCount?: number}} EventRecord */
 
 /**
  * Validate and canonicalize the versioned contract. Runtime JSON remains
@@ -179,6 +179,17 @@ export function validateContract(raw, contractPath, options = {}) {
     ids.add(node.id);
     requireString(node.type, `nodes[${index}].type`);
     boundedString(node.phase, `nodes[${index}].phase`, 128);
+    // A node's requirementIds are inherited from its phase at freeze time
+    // (src/plan/freeze.mjs stamps them) and are optional on read: a contract
+    // without the field loads unchanged, which is what keeps CONTRACT_VERSION
+    // at 0.3.0 while requirement ids reach the node.
+    const requirementIds = node.requirementIds;
+    if (requirementIds !== undefined) {
+      if (!Array.isArray(requirementIds) || requirementIds.length > 64) {
+        throw new TypeError(`nodes[${index}].requirementIds must be an array of at most 64 requirement ids`);
+      }
+      requirementIds.forEach((id, position) => boundedString(id, `nodes[${index}].requirementIds[${position}]`, 128));
+    }
     if (node.runtime !== undefined) requireRuntime(runtimes, node.runtime, `nodes[${index}].runtime`);
     const dependsOn = node.dependsOn ?? [];
     if (!Array.isArray(dependsOn) || dependsOn.some((id) => typeof id !== "string")) {

package/src/contract/snapshot.mjs

@@ -127,7 +127,7 @@ export function validateNodeSnapshot(value, expectedNode = null) {
   assertObject(value, "node snapshot");
   rejectUnknown(value, new Set([
     "schemaVersion", "contractVersion", "id", "type", "sourceIdentity", "packetHash", "status", "phase",
-    "attempt", "revisions", "judgeFailures", "runtime", "blockedBy", "startedAt", "updatedAt", "result", "gate", "error", "usage",
+    "attempt", "revisions", "judgeFailures", "requirementIds", "runtime", "blockedBy", "startedAt", "updatedAt", "result", "gate", "error", "usage",
     "costUsd", "routing", "progress", "worktree", "invocations", "executionOverrides", "verification", "scope",
     "scopeFindings", "review", "previousAttempt", "sessionPolicy", "integratedHead", "declaredReadBytes",
   ]), "node snapshot");
@@ -139,6 +139,10 @@ export function validateNodeSnapshot(value, expectedNode = null) {
   nonNegativeInteger(value.attempt, "node snapshot.attempt");
   nonNegativeInteger(value.revisions, "node snapshot.revisions");
   if (value.judgeFailures !== undefined) nonNegativeInteger(value.judgeFailures, "node snapshot.judgeFailures");
+  // The phase requirement ids the engine stamped onto the node when its result
+  // was accepted; optional on read so snapshots written before the stamp load
+  // unchanged.
+  if (value.requirementIds !== undefined) validateRequirementIdList(value.requirementIds, "node snapshot.requirementIds");
   // The review mode that governed the attempt's gate, recorded so a status
   // surface can tell an advisory finding from a below-threshold blocking one.
   if (value.review !== undefined && !REVIEW_MODES.has(/** @type {string} */ (value.review))) {
@@ -206,7 +210,7 @@ export function validateEvent(value) {
   assertObject(value, "event");
   rejectUnknown(value, new Set([
     "schemaVersion", "contractVersion", "at", "node", "from", "to", "type", "phase", "attempt", "runtime",
-    "role", "status", "currentRuntime", "errorCode", "error", "verdict", "summary", "revisions", "sourceIdentity", "packetHash", "override", "recovery", "invocationId", "unexpectedPaths", "unexpectedPathCount",
+    "role", "status", "currentRuntime", "errorCode", "error", "verdict", "summary", "revisions", "requirementIds", "sourceIdentity", "packetHash", "override", "recovery", "invocationId", "unexpectedPaths", "unexpectedPathCount",
   ]), "event");
   validateMetadata(value, "event");
   requireString(value.at, "event.at");
@@ -230,8 +234,23 @@ export function validateEvent(value) {
     }
   }
   if (value.unexpectedPathCount !== undefined) nonNegativeInteger(value.unexpectedPathCount, "event.unexpectedPathCount");
+  if (value.requirementIds !== undefined) validateRequirementIdList(value.requirementIds, "event.requirementIds");
   return /** @type {EventRecord} */ (value);
 }
+/**
+ * The requirement ids a node inherited from its phase, stamped by the engine
+ * and carried beside the result on both the snapshot and the transition event.
+ * Bounded like every persisted list: at most 64 ids of at most 128 bytes.
+ *
+ * @param {unknown} value
+ * @param {string} label
+ */
+function validateRequirementIdList(value, label) {
+  if (!Array.isArray(value) || value.length > 64) {
+    throw new TypeError(`${label} must be an array of at most 64 requirement ids`);
+  }
+  for (const [index, id] of value.entries()) boundedString(id, `${label}[${index}]`, 128);
+}
 /**
  * @param {unknown} value
  * @param {string} label

package/src/engine/settle.mjs

@@ -181,6 +181,9 @@ export async function settleDone(contract, node, state, runDir, lock, states, ca
         const retryNote = candidateRetryNote(/** @type {{verificationEvidence?: {candidate?: unknown}}} */ (transaction).verificationEvidence?.candidate);
         transition(runDir, state, "done", {
           ...patch,
+          // The engine carries the node's inherited requirement ids back with
+          // the accepted result; the worker never declares them.
+          ...(node.requirementIds?.length ? { requirementIds: node.requirementIds } : {}),
           ...(retryNote ? { gate: withCandidateRetryNote(/** @type {import("../contract/index.mjs").GateResult|null|undefined} */ (patch.gate ?? state.gate), retryNote) } : {}),
           integratedHead: transaction.candidateSha,
           worktree: { ...(state.worktree ?? {}), status: "removed", commit: transaction.attemptSha, baseSha: transaction.previousRunRefTip },

package/src/engine/state.mjs

@@ -121,6 +121,7 @@ export function appendTransitionEvent(runDir, state, from, to, details = {}, loc
   if (state.gate?.verdict) event.verdict = state.gate.verdict;
   if (state.gate?.summary) event.summary = state.gate.summary;
   if (state.revisions) event.revisions = state.revisions;
+  if (state.requirementIds?.length) event.requirementIds = state.requirementIds;
   const invocation = state.invocations?.at(-1);
   if (invocation?.id) event.invocationId = invocation.id;
   validateEvent(event);

package/src/plan/freeze.mjs

@@ -36,6 +36,32 @@ function packageVersion() {
   return JSON.parse(readFileSync(packageJsonPath, "utf8")).version;
 }
 
+/**
+ * Nodes inherit the requirement ids of the phase they belong to: the frozen
+ * contract preserves them per node, so the engine can stamp them onto the
+ * node's accepted result without the worker packet or the worker ever
+ * declaring one. A node whose phase has no declaration, or declares none,
+ * carries none. Nodes are re-listed rather than mutated in place, so the
+ * caller's plan keeps the shape it was reviewed with.
+ *
+ * @param {unknown} nodes
+ * @param {PlanPhase[]} phases
+ * @returns {unknown} the node list with the inherited ids stamped on
+ */
+function stampPhaseRequirementIds(nodes, phases) {
+  if (!Array.isArray(nodes)) return nodes;
+  const byPhase = new Map(
+    phases
+      .filter((phase) => phase.requirementIds.length > 0)
+      .map((phase) => [phase.id, phase.requirementIds]),
+  );
+  return nodes.map((node) => {
+    const phase = typeof node?.phase === "string" ? node.phase : undefined;
+    const inherited = phase === undefined ? undefined : byPhase.get(phase);
+    return inherited ? { ...node, requirementIds: [...inherited] } : node;
+  });
+}
+
 /**
  * Validate `plan` as a contract and, only once it is valid, write it and a
  * sibling plan.json naming its digest and provenance. `plan` supplies
@@ -69,6 +95,9 @@ export function freezePlan(plan, { outDir, provenance, phases }) {
     schemaVersion: PROTOCOL_SCHEMA_VERSION,
     contractVersion: CONTRACT_VERSION,
     ...plan,
+    // Listed again, not mutated in place, so the caller's plan object keeps
+    // the shape it was reviewed with.
+    ...(phaseDeclarations ? { nodes: stampPhaseRequirementIds(plan.nodes, phaseDeclarations) } : {}),
   });
   writeJsonAtomic(contractPath, raw);
   try {

package/src/plan/sizing.mjs

@@ -145,6 +145,18 @@ function foldNodeInto(nodes, child, parent) {
   const parentReads = Array.isArray(parent.taskPacket.readFiles) ? /** @type {string[]} */ (parent.taskPacket.readFiles) : null;
   const childReads = Array.isArray(child.taskPacket.readFiles) ? /** @type {string[]} */ (child.taskPacket.readFiles) : [];
   if (parentReads !== null || childReads.length > 0) parent.taskPacket.readFiles = dedupe([...(parentReads ?? []), ...childReads]);
+  // The merged node inherits the importers either node had acknowledged and
+  // the turns both expected. Found 2026-09-21 in review with the
+  // state-location session: a fold that kept only the parent's
+  // acknowledgements sent the merged node to scope closure without the
+  // child's, so it failed for the fold rather than for the work, and the
+  // over-cap flag read one node's expectation for two nodes' worth of work.
+  const parentAcks = Array.isArray(parent.taskPacket.scopeAcknowledged) ? /** @type {string[]} */ (parent.taskPacket.scopeAcknowledged) : [];
+  const childAcks = Array.isArray(child.taskPacket.scopeAcknowledged) ? /** @type {string[]} */ (child.taskPacket.scopeAcknowledged) : [];
+  if (parentAcks.length > 0 || childAcks.length > 0) parent.taskPacket.scopeAcknowledged = dedupe([...parentAcks, ...childAcks]);
+  const parentTurns = typeof parent.expectedTurns === "number" ? parent.expectedTurns : null;
+  const childTurns = typeof child.expectedTurns === "number" ? child.expectedTurns : null;
+  if (parentTurns !== null || childTurns !== null) parent.expectedTurns = (parentTurns ?? 0) + (childTurns ?? 0);
   if (typeof parent.objective === "string" && typeof child.objective === "string" && child.objective !== parent.objective) {
     parent.objective = `${parent.objective} Also: ${child.objective}`;
   }