@deftai/directive-core 0.104.0 → 0.106.0

package/dist/session/verify-session-ritual.js

@@ -1,5 +1,8 @@
-import { existsSync } from "node:fs";
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
 import { readCorePackageVersion } from "../engine-version.js";
+import { hasArtifactSuffix } from "../layout/resolve.js";
+import { readPlanSequence } from "../plan-sequence/store.js";
 import { formatFrameworkCommand } from "../render/framework-commands.js";
 import { checkActiveCliAgainstTarget, } from "./active-cli.js";
 import { defaultGitRunner, gitHead, gitIsAncestor, worktreePath } from "./git.js";
@@ -17,6 +20,64 @@ export const GATED_ENTRYPOINT_COMMANDS = {
     doctor: ["doctor"],
     cache_fresh: ["verify:cache-fresh"],
 };
+/** Explicit skip flag threaded through the gated `cache_fresh` argv (#3507). */
+export const SKIP_DRIFT_PROBE_FLAG = "--skip-drift-probe";
+/** Explicit work-selection flag threaded through the gated `cache_fresh` argv (#3507). */
+export const WORK_SELECTION_FLAG = "--work-selection";
+/** Distinct ritual-state field — never `deferred_reason` (#3507). */
+export const DRIFT_PROBE_SKIPPED_NO_WORK_SELECTION = "skipped-no-work-selection";
+function hasActiveStoryArtifact(projectRoot) {
+    for (const dirName of ["xbrief", "vbrief"]) {
+        const activeDir = join(projectRoot, dirName, "active");
+        try {
+            for (const entry of readdirSync(activeDir, { withFileTypes: true })) {
+                if (entry.isFile() && hasArtifactSuffix(entry.name))
+                    return true;
+            }
+        }
+        catch {
+            /* missing or unreadable active folder is not work selection */
+        }
+    }
+    return false;
+}
+function hasUnexhaustedPlanSequence(projectRoot) {
+    try {
+        const sequence = readPlanSequence(projectRoot);
+        if (sequence === null || sequence.exhausted === true)
+            return null;
+        return sequence.sequence_kind === "triage" ? "triage-queue" : "ordered-plan";
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Default work-selection detector for the gated `cache_fresh` seam (#3507).
+ * Active story xBRIEF (scope:activate residue), unexhausted ordered-plan /
+ * triage sequence. `--for-issue` is a positive evaluate override, not this
+ * detector — the gated argv never carries it.
+ */
+export function detectWorkSelection(projectRoot) {
+    if (hasActiveStoryArtifact(projectRoot)) {
+        return { inPlay: true, kind: "active-story" };
+    }
+    const planKind = hasUnexhaustedPlanSequence(projectRoot);
+    if (planKind !== null) {
+        return { inPlay: true, kind: planKind };
+    }
+    return { inPlay: false, kind: "none" };
+}
+export function resolveGatedEntrypointCommand(stepName, projectRoot, detect = detectWorkSelection) {
+    const base = [...GATED_ENTRYPOINT_COMMANDS[stepName]];
+    if (stepName !== "cache_fresh")
+        return base;
+    const selection = detect(projectRoot);
+    if (selection.inPlay) {
+        return [...base, WORK_SELECTION_FLAG];
+    }
+    return [...base, SKIP_DRIFT_PROBE_FLAG];
+}
 function truthy(raw) {
     return new Set(["1", "true", "yes", "on"]).has((raw ?? "").trim().toLowerCase());
 }
@@ -25,6 +86,7 @@ function stepPasses(step) {
         return false;
     if (step.deferred_reason)
         return true;
+    // `drift_probe` is a distinct diagnostic; it must never satisfy a step (#3507).
     return step.ok === true;
 }
 function failedStepMessage(tierName, stepName, step) {
@@ -50,8 +112,31 @@ export function formatRitualRecoveryInstruction(tier = "cold") {
     return (`Recovery: run ${ready} ` +
         `(one-shot: session:start + gated ritual + cache recovery as needed).`);
 }
-function runGatedStep(projectRoot, payload, stepName, runner, now) {
-    const command = [...GATED_ENTRYPOINT_COMMANDS[stepName]];
+/**
+ * Sanctioned audited defer copy for gated `cache_fresh` failure (#3506 / #3507).
+ * Independent of the #3507 work-selection argv seam — defer is still the
+ * operator-audited escape, not the drift-probe skip.
+ */
+export function formatCacheFreshDeferSoftPath() {
+    const cmd = formatFrameworkCommand(["session:start", "--", "--defer", "cache_fresh=<reason>"]);
+    return `Soft path (audited): \`${cmd}\`.`;
+}
+function applyCacheFreshDriftProbeField(payload, command) {
+    if (command.includes(SKIP_DRIFT_PROBE_FLAG)) {
+        payload.drift_probe = DRIFT_PROBE_SKIPPED_NO_WORK_SELECTION;
+        return;
+    }
+    if (payload.drift_probe === DRIFT_PROBE_SKIPPED_NO_WORK_SELECTION) {
+        delete payload.drift_probe;
+    }
+}
+function shouldRearmDriftProbe(payload, projectRoot, detect) {
+    if (payload.drift_probe !== DRIFT_PROBE_SKIPPED_NO_WORK_SELECTION)
+        return false;
+    return detect(projectRoot).inPlay;
+}
+function runGatedStep(projectRoot, payload, stepName, runner, now, detect = detectWorkSelection) {
+    const command = resolveGatedEntrypointCommand(stepName, projectRoot, detect);
     const { code, stdout, stderr } = runner(command, projectRoot);
     const message = stdout.trim() || stderr.trim() || `${command[0]} exited ${code}`;
     const gated = payload.gated_steps ?? {};
@@ -63,6 +148,9 @@ function runGatedStep(projectRoot, payload, stepName, runner, now) {
         command,
     });
     payload.gated_steps = gated;
+    if (stepName === "cache_fresh") {
+        applyCacheFreshDriftProbeField(payload, command);
+    }
     try {
         writeRitualState(projectRoot, payload);
     }
@@ -353,6 +441,7 @@ export function verifySessionRitual(projectRoot, options = {}) {
         payload.gated_steps = gated;
         const runCmd = options.runner ?? defaultRitualRunner;
         const forced = new Set(options.forceGatedSteps ?? []);
+        const detect = options.detectWorkSelection ?? detectWorkSelection;
         for (const stepName of GATED_STEPS) {
             const step = gated[stepName];
             if (step?.deferred_reason && stepName !== "agent_hooks")
@@ -360,9 +449,11 @@ export function verifySessionRitual(projectRoot, options = {}) {
             // Hook readiness is a live mutation prerequisite, not a cacheable doctor
             // result. Re-run it at every gated boundary so registration/shim drift
             // cannot remain hidden behind an earlier green ritual record.
-            if (stepName !== "agent_hooks" && stepPasses(step) && !forced.has(stepName))
+            const rearmDrift = stepName === "cache_fresh" && shouldRearmDriftProbe(payload, projectRoot, detect);
+            if (stepName !== "agent_hooks" && stepPasses(step) && !forced.has(stepName) && !rearmDrift) {
                 continue;
-            const writeError = runGatedStep(projectRoot, payload, stepName, runCmd, instant);
+            }
+            const writeError = runGatedStep(projectRoot, payload, stepName, runCmd, instant, detect);
             if (writeError !== null) {
                 return {
                     code: 2,
@@ -465,6 +556,7 @@ export function emitVerifyJson(result) {
         would_fail_code: result.wouldFailCode,
         posture: result.posture,
         ritual_state_required: result.ritualStateRequired,
+        recovery_tier: result.recoveryTier ?? null,
     });
 }
 export function emitBypassWarning(result) {

package/dist/slash/openclaw-deposit.js

@@ -10,11 +10,12 @@
  *
  * ⊗ Fake project `.openclaw/commands/` file emitter.
  */
-import { existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { detectOpenClaw, isEscapingSkillSymlink, listInScopeSkillsDirs, } from "../doctor/openclaw-skills.js";
-import { containedWrite } from "../fs/contained-write.js";
+import { containedMkdir, containedRemove, containedRename, containedWrite, } from "../fs/contained-write.js";
+import { isPortRecordMode } from "../fs/mutation-ledger.js";
 import { readPlanPolicy } from "../policy/plan-extensions.js";
 import { loadProjectDefinition } from "../policy/resolve.js";
 import { generateOpenClawSkillArtifacts, isManagedOpenClawL2Skill, listOpenClawManagedSkillSlugs, } from "./openclaw-adapter.js";
@@ -122,7 +123,7 @@ function writeSkillArtifact(skillsDir, artifact) {
             return "preserved";
         }
     }
-    mkdirSync(skillDir, { recursive: true });
+    containedMkdir({ root: skillsDir, target: skillDir });
     // Re-check after mkdir: concurrent symlink plant is fail-closed.
     if (skillDirLstatKind(skillDir) === "symlink" && isEscapingSkillSymlink(skillsDir, skillDir)) {
         return "preserved";
@@ -137,11 +138,11 @@ function writeSkillArtifact(skillsDir, artifact) {
             data: artifact.skillMarkdown,
             mode: "replace",
         });
-        renameSync(tmp, skillFile);
+        containedRename({ root: skillsDir, from: tmp, to: skillFile, mutation: false });
     }
     catch (err) {
         try {
-            rmSync(tmp, { force: true });
+            containedRemove({ root: skillsDir, target: tmp, mutation: false });
         }
         catch {
             /* best-effort */
@@ -172,8 +173,9 @@ function stripManagedSkills(skillsDir) {
         if (!isManagedOpenClawL2Skill(raw))
             continue;
         try {
-            rmSync(skillDir, { recursive: true, force: true });
-            removed.push(skillDir);
+            if (containedRemove({ root: skillsDir, target: skillDir, recursive: true }).removed) {
+                removed.push(skillDir);
+            }
         }
         catch {
             /* best-effort */
@@ -221,7 +223,8 @@ export function depositOpenClawL2ProductCommands(options = {}) {
     const preservedCustomPaths = [];
     if (!policy) {
         for (const skillsDir of skillsDirs) {
-            mkdirSync(skillsDir, { recursive: true });
+            if (!isPortRecordMode())
+                mkdirSync(skillsDir, { recursive: true });
             removedPaths.push(...stripManagedSkills(skillsDir));
         }
         if (removedPaths.length > 0) {
@@ -242,7 +245,8 @@ export function depositOpenClawL2ProductCommands(options = {}) {
     }
     const artifacts = generateOpenClawSkillArtifacts();
     for (const skillsDir of skillsDirs) {
-        mkdirSync(skillsDir, { recursive: true });
+        if (!isPortRecordMode())
+            mkdirSync(skillsDir, { recursive: true });
         for (const artifact of artifacts) {
             const outcome = writeSkillArtifact(skillsDir, artifact);
             const abs = join(skillsDir, artifact.slug);

package/dist/slice/constants.d.ts

@@ -1,5 +1,5 @@
-/** Default slices log path relative to project root. */
-export declare const DEFAULT_SLICES_LOG_REL_PATH = "vbrief/.eval/slices.jsonl";
+/** Default slices log path relative to an xbrief-layout project root (#1703). */
+export declare const DEFAULT_SLICES_LOG_REL_PATH = "xbrief/.triage-cache/slices.jsonl";
 export declare const ENV_PROJECT_ROOT = "DEFT_PROJECT_ROOT";
 export declare const ENV_PROJECT_REPO = "DEFT_PROJECT_REPO";
 export declare const DEFAULT_ACTOR = "manual:operator";

package/dist/slice/constants.js

@@ -1,5 +1,5 @@
-/** Default slices log path relative to project root. */
-export const DEFAULT_SLICES_LOG_REL_PATH = "vbrief/.eval/slices.jsonl";
+/** Default slices log path relative to an xbrief-layout project root (#1703). */
+export const DEFAULT_SLICES_LOG_REL_PATH = "xbrief/.triage-cache/slices.jsonl";
 export const ENV_PROJECT_ROOT = "DEFT_PROJECT_ROOT";
 export const ENV_PROJECT_REPO = "DEFT_PROJECT_REPO";
 export const DEFAULT_ACTOR = "manual:operator";

package/dist/slice/existing.js

@@ -1,6 +1,7 @@
 import { ContainedWriteError } from "../fs/contained-write.js";
 import { call as scmCall } from "../scm/call.js";
 import { pyRepr } from "../scm/py-format.js";
+import { triageCacheRelPath } from "../triage/cache-path.js";
 import { DEFAULT_ACTOR, DEFAULT_EXPECTED_CLOSE_SIGNAL, DEFAULT_ROLE, WAVE_FLAG_RE, } from "./constants.js";
 import { IssueValidationError, SliceRecordError } from "./errors.js";
 import { pythonJsonPretty } from "./json.js";
@@ -171,6 +172,10 @@ export function summariseWaves(waveMap, totalChildren) {
         .map((waveN) => `wave-${waveN}=${placedByWave.get(waveN)}`);
     return `${parts.length} wave(s): ${parts.join(", ")}`;
 }
+/** Layout-aware display path for the slices log actually read or written (#3386). */
+function slicesLogDisplayPath(projectRoot) {
+    return triageCacheRelPath(projectRoot, "slices.jsonl");
+}
 function duplicateMessage(umbrella, duplicate) {
     return (`slice:record-existing: umbrella #${umbrella} already has a matching record (slice_id=${String(duplicate.slice_id)}, ` +
         `actor=${String(duplicate.actor)}). Re-run with --force to write a second record.`);
@@ -295,7 +300,7 @@ export function runRecordExisting(args, waveMap, deps = {}) {
         const waveSummary = summariseWaves(waveMap, children.length);
         return {
             exitCode: 0,
-            stdout: `Wrote vbrief/.eval/slices.jsonl entry for umbrella ` +
+            stdout: `Wrote ${slicesLogDisplayPath(resolved.projectRoot)} entry for umbrella ` +
                 `#${args.umbrella} (${children.length} children, ${waveSummary}). ` +
                 `slice_id=${outcome.sliceId}\n`,
             stderr: "",
@@ -320,6 +325,7 @@ export function runList(args) {
     if (resolved.exitCode !== 0) {
         return { exitCode: 2, stdout: "", stderr: `${formatMissingRootError()}\n` };
     }
+    const logDisplay = slicesLogDisplayPath(resolved.projectRoot);
     const records = readAll({ path: slicesPath(resolved.projectRoot) });
     if (args.asJson) {
         return { exitCode: 0, stdout: `${pythonJsonPretty(records)}\n`, stderr: "" };
@@ -327,11 +333,11 @@ export function runList(args) {
     if (records.length === 0) {
         return {
             exitCode: 0,
-            stdout: "slice:list: no records found in vbrief/.eval/slices.jsonl (file absent or empty).\n",
+            stdout: `slice:list: no records found in ${logDisplay} (file absent or empty).\n`,
             stderr: "",
         };
     }
-    const lines = [`slice:list: ${records.length} record(s) in vbrief/.eval/slices.jsonl`];
+    const lines = [`slice:list: ${records.length} record(s) in ${logDisplay}`];
     for (const record of records) {
         const umbrella = record.umbrella ?? "?";
         const actor = record.actor ?? "?";

package/dist/slice/lock.d.ts

@@ -1,9 +1,24 @@
+/** 10× occupancy heartbeat TTL. Off-Linux PID reuse / stalled holder reclaim. */
+export declare const STALE_LOCK_HARD_CAP_MS: number;
 export interface LockDeps {
     readonly sleepMs?: (ms: number) => void;
     readonly now?: () => number;
 }
+export interface HeldLock {
+    readonly lockPath: string;
+    readonly pid: number;
+    readonly token: string;
+    readonly acquiredAt: number;
+}
+export interface LockRecord {
+    readonly pid: number | null;
+    readonly token: string;
+    readonly acquiredAt: number | null;
+}
+export declare function parseLockRecord(lockPath: string): LockRecord;
+export declare function assertAppendLockOwned(held: HeldLock): void;
 /** Serialise appenders across threads AND processes (sidecar lock file). */
-export declare function withAppendLock<T>(logPath: string, fn: () => T, deps?: LockDeps): T;
+export declare function withAppendLock<T>(logPath: string, fn: (held: HeldLock) => T, deps?: LockDeps): T;
 /** Public alias mirroring Python append_lock. */
 export declare const appendLock: typeof withAppendLock;
 //# sourceMappingURL=lock.d.ts.map

package/dist/slice/lock.js

@@ -1,12 +1,127 @@
-import { closeSync, existsSync, mkdirSync, openSync, unlinkSync, writeSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeSync, } from "node:fs";
 import { dirname } from "node:path";
 const threadLocked = { held: false };
+/** 10× occupancy heartbeat TTL. Off-Linux PID reuse / stalled holder reclaim. */
+export const STALE_LOCK_HARD_CAP_MS = 20 * 60 * 1000 * 10;
 function defaultSleep(ms) {
     const end = Date.now() + ms;
     while (Date.now() < end) {
         /* spin */
     }
 }
+export function parseLockRecord(lockPath) {
+    try {
+        const lines = readFileSync(lockPath, { encoding: "utf8" }).trim().split(/\r?\n/);
+        const pidRaw = Number(lines[0]);
+        const pid = Number.isInteger(pidRaw) && pidRaw > 0 ? pidRaw : null;
+        if (lines.length >= 3) {
+            const acquiredRaw = Number(lines[2]);
+            return {
+                pid,
+                token: lines[1] ?? "",
+                acquiredAt: Number.isInteger(acquiredRaw) && acquiredRaw > 0 ? acquiredRaw : null,
+            };
+        }
+        const acquiredRaw = Number(lines[1]);
+        return {
+            pid,
+            token: "",
+            acquiredAt: Number.isInteger(acquiredRaw) && acquiredRaw > 0 ? acquiredRaw : null,
+        };
+    }
+    catch {
+        return { pid: null, token: "", acquiredAt: null };
+    }
+}
+export function assertAppendLockOwned(held) {
+    const rec = parseLockRecord(held.lockPath);
+    if (rec.pid !== held.pid || rec.token !== held.token || rec.token.length === 0) {
+        throw new Error(`lock compromised: ${held.lockPath}`);
+    }
+}
+function processExists(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code !== "ESRCH";
+    }
+}
+function linuxPidStartedAfter(pid, acquiredAt) {
+    try {
+        const stat = readFileSync(`/proc/${pid}/stat`, { encoding: "utf8" });
+        const closeParen = stat.lastIndexOf(")");
+        if (closeParen < 0)
+            return false;
+        const startTicks = Number(stat.slice(closeParen + 2).split(" ")[19]);
+        if (!Number.isFinite(startTicks))
+            return false;
+        const btime = /(?:^|\n)btime (\d+)/.exec(readFileSync("/proc/stat", { encoding: "utf8" }));
+        if (btime === null)
+            return false;
+        const startMs = Number(btime[1]) * 1000 + (startTicks * 1000) / 100;
+        return startMs > acquiredAt + 1000;
+    }
+    catch {
+        return false;
+    }
+}
+function lockMtimeMs(lockPath) {
+    try {
+        return statSync(lockPath).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
+function isAbandoned(rec, now, lockPath) {
+    if (rec.pid === null) {
+        const mtime = lockMtimeMs(lockPath);
+        return mtime !== null && now - mtime > STALE_LOCK_HARD_CAP_MS;
+    }
+    if (!processExists(rec.pid))
+        return true;
+    if (rec.acquiredAt !== null && linuxPidStartedAfter(rec.pid, rec.acquiredAt))
+        return true;
+    if (rec.acquiredAt !== null && now - rec.acquiredAt > STALE_LOCK_HARD_CAP_MS)
+        return true;
+    return false;
+}
+function recordsMatch(a, b) {
+    return a.pid === b.pid && a.token === b.token && a.acquiredAt === b.acquiredAt;
+}
+/** Atomic rename reclaim: one waiter wins; losers see ENOENT. */
+function tryReclaimAbandonedOwner(lockPath, now) {
+    const observed = parseLockRecord(lockPath);
+    if (!isAbandoned(observed, now, lockPath))
+        return false;
+    const quarantine = `${lockPath}.reclaim.${process.pid}.${randomUUID()}`;
+    try {
+        renameSync(lockPath, quarantine);
+    }
+    catch {
+        return false;
+    }
+    const quarantined = parseLockRecord(quarantine);
+    if (recordsMatch(observed, quarantined)) {
+        try {
+            unlinkSync(quarantine);
+        }
+        catch {
+            /* already gone */
+        }
+        return true;
+    }
+    try {
+        renameSync(quarantine, lockPath);
+    }
+    catch {
+        /* best-effort restore */
+    }
+    return false;
+}
 /** Serialise appenders across threads AND processes (sidecar lock file). */
 export function withAppendLock(logPath, fn, deps = {}) {
     const sleepMs = deps.sleepMs ?? defaultSleep;
@@ -18,13 +133,18 @@ export function withAppendLock(logPath, fn, deps = {}) {
     }
     threadLocked.held = true;
     let fd;
+    let held;
+    let reclaimedStale = false;
     try {
         const deadline = now() + 30_000;
         while (true) {
             try {
                 fd = openSync(lockPath, "wx");
-                writeSync(fd, Buffer.from("\0"));
-                break;
+                const token = randomUUID();
+                const acquiredAt = now();
+                writeSync(fd, Buffer.from(`${process.pid}\n${token}\n${acquiredAt}\n`));
+                held = { lockPath, pid: process.pid, token, acquiredAt };
+                return fn(held);
             }
             catch (err) {
                 const code = err.code;
@@ -32,26 +152,32 @@ export function withAppendLock(logPath, fn, deps = {}) {
                     throw err;
                 }
                 if (now() > deadline) {
+                    if (!reclaimedStale && tryReclaimAbandonedOwner(lockPath, now())) {
+                        reclaimedStale = true;
+                        continue;
+                    }
                     throw new Error(`timed out acquiring lock for ${logPath}`);
                 }
                 sleepMs(20);
             }
         }
-        return fn();
     }
     finally {
         if (fd !== undefined) {
             closeSync(fd);
         }
-        threadLocked.held = false;
-        try {
-            if (existsSync(lockPath)) {
-                unlinkSync(lockPath);
+        if (held !== undefined) {
+            try {
+                assertAppendLockOwned(held);
+                if (existsSync(lockPath)) {
+                    unlinkSync(lockPath);
+                }
+            }
+            catch {
+                /* not ours anymore */
             }
         }
-        catch {
-            /* best-effort */
-        }
+        threadLocked.held = false;
     }
 }
 /** Public alias mirroring Python append_lock. */

package/dist/story-ready/evaluate.d.ts

@@ -20,6 +20,8 @@ export interface EvaluateOptions {
     readonly projectRoot?: string;
     /** Skip parent-lineage check (tests / opt-out). Default false. */
     readonly skipParentLineage?: boolean;
+    /** Skip project-invariant coverage (#3425). Default false. */
+    readonly skipProjectInvariants?: boolean;
 }
 /**
  * Pure evaluator — returns exit code + human message. Faithful to

package/dist/story-ready/evaluate.js

@@ -1,5 +1,6 @@
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
+import { evaluateProjectInvariantsGate, resolveProjectRootForInvariants, } from "../preflight/project-invariants-gate.js";
 import { evaluateParentLineage, formatParentLineageLine, } from "../scope/parent-lineage.js";
 import { parseAllocationSection, SOLO_KIND, SWARM_COHORT_KIND, VALID_DISPATCH_KINDS, } from "./allocation.js";
 export const ACTIVE_FOLDER = "active";
@@ -168,6 +169,18 @@ export function evaluate(vbriefPath, options = {}) {
                 `\n${formatParentLineageLine(lineage)}`,
         };
     }
+    const invariants = evaluateProjectInvariantsGate(vbriefCheck.payload, {
+        projectRoot: resolveProjectRootForInvariants(vbriefCheck.path, options.projectRoot),
+        skip: options.skipProjectInvariants === true,
+    });
+    if (!invariants.ok) {
+        return {
+            exitCode: 1,
+            dispatchKind: null,
+            parentLineage: lineage,
+            message: `not ready: ${invariants.message}`,
+        };
+    }
     const lineageNote = lineage.applicable
         ? `parent lineage OK (${lineage.parent_requirement_ids.length} req IDs` +
             (lineage.negative_invariant_ids.length > 0

package/dist/swarm/complete-cohort.d.ts

@@ -45,9 +45,12 @@ export declare function completeCohort(args: {
     emitJson?: boolean;
     /** Per-story delivery evidence; without it code-bearing stories fail closed (#3041). */
     delivery?: CohortDeliveryContext | null;
+    /** Optional launch allocation plan id so close-out reads this cohort's occupancy slot. */
+    allocationPlanId?: string | null;
 }): {
     exitCode: number;
     stdout: string;
     stderr: string;
+    sweep: SweepResult | null;
 };
 //# sourceMappingURL=complete-cohort.d.ts.map