@deftai/directive-core 0.108.0 → 0.109.0

package/dist/cache/operations.js

@@ -107,7 +107,7 @@ export function cachePut(source, key, raw, options = {}) {
     const rawSize = Buffer.byteLength(rawText, "utf8");
     // #1870 Greptile P2: account for current-shape sidecar bytes in cap + meta
     // so usage does not underreport by the cumulative sidecar size.
-    const plannedSidecar = buildCurrentShapeSidecar(raw);
+    const plannedSidecar = buildCurrentShapeSidecar(raw).sidecar;
     const plannedSidecarText = plannedSidecar !== null
         ? `${pythonJsonDump({
             ...plannedSidecar,

package/dist/check/gate-lists.d.ts

@@ -15,6 +15,20 @@ export type CheckGateSpec = string | {
  * xbrief/completed instead of skipping (#3357).
  */
 export declare const PRODUCT_FIRST_AC_GATE: CheckGateSpec;
+/**
+ * Candidate-scoped orphan-active for check aggregates (#3893).
+ *
+ * The unscoped sweep on the merge chokepoint gave a brief stranded by one
+ * merge authority over every other open PR, and N stranded briefs made N
+ * single-brief lifecycle PRs mutually unmergeable. It was never preventive for
+ * the candidate either: that candidate's linked PR still reads
+ * `merged_at: null` while its own gate runs.
+ *
+ * Bare `verify:orphan-active` stays repo-wide for `deft doctor`, manual runs,
+ * swarm finalize, and the after-merge `--issue N` DONE gate (#3429); the
+ * scoped form still falls back to the full sweep at the delivery tip.
+ */
+export declare const ORPHAN_ACTIVE_MERGE_GATE: CheckGateSpec;
 export declare function checkGateId(spec: CheckGateSpec): string;
 /** Args for `task … --taskfile <path>` (optional `--` + public CLI flags). */
 export declare function checkGateSpawnArgs(spec: CheckGateSpec, taskfilePath: string): string[];

package/dist/check/gate-lists.js

@@ -9,6 +9,23 @@ export const PRODUCT_FIRST_AC_GATE = {
     task: PRODUCT_AC_GATE_ID,
     args: ["--soft-missing-xbrief"],
 };
+/**
+ * Candidate-scoped orphan-active for check aggregates (#3893).
+ *
+ * The unscoped sweep on the merge chokepoint gave a brief stranded by one
+ * merge authority over every other open PR, and N stranded briefs made N
+ * single-brief lifecycle PRs mutually unmergeable. It was never preventive for
+ * the candidate either: that candidate's linked PR still reads
+ * `merged_at: null` while its own gate runs.
+ *
+ * Bare `verify:orphan-active` stays repo-wide for `deft doctor`, manual runs,
+ * swarm finalize, and the after-merge `--issue N` DONE gate (#3429); the
+ * scoped form still falls back to the full sweep at the delivery tip.
+ */
+export const ORPHAN_ACTIVE_MERGE_GATE = {
+    task: "verify:orphan-active",
+    args: ["--changed-only"],
+};
 export function checkGateId(spec) {
     return typeof spec === "string" ? spec : spec.task;
 }
@@ -62,8 +79,9 @@ export const FRAMEWORK_CHECK_GATES = [
     // --- Fast preflight (seconds–few min) — #3188 ---
     "verify:branch",
     "verify:encoding",
+    "verify:closing-keywords",
     "verify:cache-fresh",
-    "verify:orphan-active",
+    ORPHAN_ACTIVE_MERGE_GATE,
     "verify:completed-write-guard",
     "verify:license-sync",
     "verify:contract-drift",
@@ -73,7 +91,10 @@ export const FRAMEWORK_CHECK_GATES = [
     "verify:rule-ownership",
     "verify:biome-config",
     "verify:content-manifest",
+    // #3900 check 1: C1 declaration vs staged pack. Checks 2/3 compose C3/C2.
+    "verify:deposit-closure",
     "verify:skill-external-fetch-gate",
+    "verify:semantic-single-source",
     "verify:cursor-tier1",
     "verify:openclaw-tier1",
     "verify:go-freeze",
@@ -82,7 +103,9 @@ export const FRAMEWORK_CHECK_GATES = [
     // #3145: test/source boundary + approved-scope provenance + consumer gate composition
     "verify:test-boundary",
     "verify:scope-provenance",
-    "verify:consumer-check-contract",
+    // #3893: fail-closed on merge-chokepoint gate scoping for the composition
+    // this repo owns; consumer deposits stay warn-only until `deft update`.
+    { task: "verify:consumer-check-contract", args: ["--framework-source"] },
     // #3362: dead-surface detector (warn-only this release; no --enforce)
     "verify:telemetry-coverage",
     "verify:vbrief-conformance",
@@ -111,7 +134,7 @@ export const CONSUMER_CHECK_GATES = [
     "verify:branch",
     "verify:cache-fresh",
     "verify:wip-cap",
-    "verify:orphan-active",
+    ORPHAN_ACTIVE_MERGE_GATE,
     "verify:completed-write-guard",
     "doctor",
     "toolchain:check-consumer",

package/dist/check/session-completed-ac.d.ts

@@ -8,7 +8,7 @@
 /** One remediation when check cannot target the just-completed brief (#3357). */
 export declare const SESSION_COMPLETED_AC_REMEDIATION = "Run task verify:ac -- xbrief/completed/<just-completed>.xbrief.json (a story completed this session; check must not soft-skip) (#3357)";
 /** Project-relative marker written by scope:complete for this session (#3357). */
-export declare const SESSION_COMPLETED_MARKER_REL: readonly [".deft", "last-completed.json"];
+export declare const SESSION_COMPLETED_MARKER_REL: readonly [".deft", "cache", "last-completed.json"];
 export interface SessionCompletedMarker {
     readonly path: string;
     readonly sessionId: string;

package/dist/check/session-completed-ac.js

@@ -13,7 +13,7 @@ import { parseTimestamp } from "../session/time.js";
 /** One remediation when check cannot target the just-completed brief (#3357). */
 export const SESSION_COMPLETED_AC_REMEDIATION = "Run task verify:ac -- xbrief/completed/<just-completed>.xbrief.json (a story completed this session; check must not soft-skip) (#3357)";
 /** Project-relative marker written by scope:complete for this session (#3357). */
-export const SESSION_COMPLETED_MARKER_REL = [".deft", "last-completed.json"];
+export const SESSION_COMPLETED_MARKER_REL = [".deft", "cache", "last-completed.json"];
 function asRecord(value) {
     if (typeof value === "object" && value !== null && !Array.isArray(value)) {
         return value;

package/dist/consumer-check-contract/evaluate.d.ts

@@ -10,6 +10,20 @@
 import { type CheckGateSpec } from "../check/gate-lists.js";
 /** Gates that #3145 requires on consumer check composition (beyond baseline). */
 export declare const REQUIRED_CONSUMER_ENFORCEMENT_GATES: readonly string[];
+/**
+ * Gates whose composition on a check aggregate must carry a scoping argument
+ * (#3893).
+ *
+ * `verify:orphan-active` is repo-wide by default. Composed unscoped on a merge
+ * chokepoint it fails a candidate for residue another merge stranded, and N
+ * stranded briefs make N single-brief lifecycle PRs mutually unmergeable. It is
+ * not preventive for the candidate either: that candidate's linked PR still
+ * reads `merged_at: null` while its own gate runs.
+ *
+ * Fail-closed under `--framework-source`, where this repo owns the composition;
+ * a warning elsewhere while `deft update` re-deposits the Taskfile.
+ */
+export declare const MERGE_CHOKEPOINT_SCOPED_GATE_ARGS: ReadonlyMap<string, string>;
 export interface ConsumerCheckContractFinding {
     readonly gateId: string;
     readonly surface: "check-task" | "ci-workflow" | "verify-taskfile";
@@ -150,11 +164,44 @@ export declare function stripTaskBodyComments(body: string): string;
 export declare function taskBodyInvokesCheckOrchestrator(body: string): boolean;
 /** True when the check / check:consumer / check:framework-source task invokes orchestrator. */
 export declare function taskfileInvokesCheckOrchestrator(text: string): boolean;
+/** One `deps:` entry plus the YAML nested under it (`vars:` and friends). */
+export interface CheckDepEntry {
+    readonly name: string;
+    readonly body: string;
+}
+/**
+ * Extract `deps:` entries from a go-task task definition, keeping each entry's
+ * nested body so an argument-carrying dep (#3893) is distinguishable from a
+ * bare one. Best-effort line parser.
+ */
+export declare function extractCheckDepEntries(taskfileText: string, taskName: string): CheckDepEntry[];
 /**
  * Extract dependency task names from a go-task task definition body snippet.
  * Best-effort line parser for `deps:` list entries.
  */
 export declare function extractCheckDeps(taskfileText: string, taskName: string): string[];
+/**
+ * Drop a YAML trailing comment and surrounding quotes from a scalar value.
+ * Honours double-quoted `\\"` escapes and single-quoted `''` doubling, so a
+ * value carrying a quote is not truncated before the argument that follows.
+ */
+export declare function parseYamlScalar(raw: string): string;
+/**
+ * Effective `CLI_ARGS` value for a `deps:` entry, or null when it sets none.
+ *
+ * Reads the key itself rather than the entry text, so the required argument
+ * appearing in a comment, a sibling variable, or a descriptive value cannot
+ * stand in for the argument the gate actually receives (#3893).
+ */
+export declare function depEntryCliArgs(body: string): string | null;
+/**
+ * True when the effective `CLI_ARGS` token list carries `requiredArg`.
+ *
+ * Exact token only: the guarded verbs accept the bare flag, so an equals form
+ * like `--changed-only=0` would exit 2 on an unrecognized argument while the
+ * contract reported the composition healthy.
+ */
+export declare function cliArgsCarry(cliArgs: string | null, requiredArg: string): boolean;
 /**
  * Evaluate whether required enforcement gates are composed into consumer check/CI.
  */

package/dist/consumer-check-contract/evaluate.js

@@ -17,6 +17,22 @@ export const REQUIRED_CONSUMER_ENFORCEMENT_GATES = [
     "verify:scope-provenance",
     "verify:consumer-check-contract",
 ];
+/**
+ * Gates whose composition on a check aggregate must carry a scoping argument
+ * (#3893).
+ *
+ * `verify:orphan-active` is repo-wide by default. Composed unscoped on a merge
+ * chokepoint it fails a candidate for residue another merge stranded, and N
+ * stranded briefs make N single-brief lifecycle PRs mutually unmergeable. It is
+ * not preventive for the candidate either: that candidate's linked PR still
+ * reads `merged_at: null` while its own gate runs.
+ *
+ * Fail-closed under `--framework-source`, where this repo owns the composition;
+ * a warning elsewhere while `deft update` re-deposits the Taskfile.
+ */
+export const MERGE_CHOKEPOINT_SCOPED_GATE_ARGS = new Map([
+    ["verify:orphan-active", "--changed-only"],
+]);
 /**
  * Relative path forms accepted for the deft-install canonical Taskfile include
  * (init-deposit `MINIMAL_TASKFILE` / `CANONICAL_TASKFILE_INCLUDE`).
@@ -575,16 +591,18 @@ export function taskfileInvokesCheckOrchestrator(text) {
     return false;
 }
 /**
- * Extract dependency task names from a go-task task definition body snippet.
- * Best-effort line parser for `deps:` list entries.
+ * Extract `deps:` entries from a go-task task definition, keeping each entry's
+ * nested body so an argument-carrying dep (#3893) is distinguishable from a
+ * bare one. Best-effort line parser.
  */
-export function extractCheckDeps(taskfileText, taskName) {
+export function extractCheckDepEntries(taskfileText, taskName) {
     const lines = taskfileText.replace(/\r\n/g, "\n").split("\n");
-    const deps = [];
+    const entries = [];
     let inTask = false;
     let taskIndent = 0;
     let inDeps = false;
     let depsIndent = 0;
+    let current = null;
     const taskRe = new RegExp(`^${escapeRegExp(taskName)}\\s*:`);
     for (const raw of lines) {
         const stripped = raw.trim();
@@ -604,23 +622,142 @@ export function extractCheckDeps(taskfileText, taskName) {
         if (/^deps\s*:/.test(stripped)) {
             inDeps = true;
             depsIndent = indent;
+            current = null;
             continue;
         }
-        if (inDeps) {
-            if (indent <= depsIndent && !stripped.startsWith("-")) {
-                inDeps = false;
+        if (!inDeps)
+            continue;
+        if (indent <= depsIndent && !stripped.startsWith("-")) {
+            inDeps = false;
+            current = null;
+        }
+        else if (stripped.startsWith("-")) {
+            // - verify:branch  OR  - task: verify:branch
+            const m = stripped.match(/^-\s+task:\s*["']?([^"'#]+?)["']?\s*(?:#.*)?$/) ??
+                stripped.match(/^-\s+["']?([^"'#]+?)["']?\s*(?:#.*)?$/);
+            current = m?.[1] === undefined ? null : { name: m[1].trim(), lines: [] };
+            if (current !== null) {
+                entries.push(current);
             }
-            else if (stripped.startsWith("-")) {
-                // - verify:branch  OR  - task: verify:branch
-                const m = stripped.match(/^-\s+task:\s*["']?([^"'#]+?)["']?\s*(?:#.*)?$/) ??
-                    stripped.match(/^-\s+["']?([^"'#]+?)["']?\s*(?:#.*)?$/);
-                if (m?.[1]) {
-                    deps.push(m[1].trim());
+        }
+        else if (current !== null) {
+            // Keep indentation: the scoping check below needs to tell an immediate
+            // `vars:` property from deeper YAML (#3893).
+            current.lines.push(raw);
+        }
+    }
+    return entries.map((entry) => ({ name: entry.name, body: entry.lines.join("\n") }));
+}
+/**
+ * Extract dependency task names from a go-task task definition body snippet.
+ * Best-effort line parser for `deps:` list entries.
+ */
+export function extractCheckDeps(taskfileText, taskName) {
+    return extractCheckDepEntries(taskfileText, taskName).map((entry) => entry.name);
+}
+/**
+ * Drop a YAML trailing comment and surrounding quotes from a scalar value.
+ * Honours double-quoted `\\"` escapes and single-quoted `''` doubling, so a
+ * value carrying a quote is not truncated before the argument that follows.
+ */
+export function parseYamlScalar(raw) {
+    const text = raw.trim();
+    if (text.startsWith('"')) {
+        let out = "";
+        for (let i = 1; i < text.length; i += 1) {
+            const ch = text[i];
+            if (ch === "\\" && i + 1 < text.length) {
+                out += text[i + 1];
+                i += 1;
+                continue;
+            }
+            if (ch === '"')
+                return out;
+            out += ch;
+        }
+        return out;
+    }
+    if (text.startsWith("'")) {
+        let out = "";
+        for (let i = 1; i < text.length; i += 1) {
+            const ch = text[i];
+            if (ch === "'") {
+                if (text[i + 1] === "'") {
+                    out += "'";
+                    i += 1;
+                    continue;
                 }
+                return out;
             }
+            out += ch;
         }
+        return out;
     }
-    return deps;
+    const comment = text.indexOf(" #");
+    return (comment === -1 ? text : text.slice(0, comment)).trim();
+}
+/**
+ * Inline-flow `vars: { CLI_ARGS: ... }` scalar. Quote escapes are honoured so a
+ * value carrying a quote is not truncated before the argument that follows.
+ */
+const INLINE_CLI_ARGS_RE = /CLI_ARGS\s*:\s*("(?:\\.|[^"\\])*"|'(?:''|[^'])*'|[^,}]*)/;
+/**
+ * Effective `CLI_ARGS` value for a `deps:` entry, or null when it sets none.
+ *
+ * Reads the key itself rather than the entry text, so the required argument
+ * appearing in a comment, a sibling variable, or a descriptive value cannot
+ * stand in for the argument the gate actually receives (#3893).
+ */
+export function depEntryCliArgs(body) {
+    let varsIndent = null;
+    let propIndent = null;
+    let value = null;
+    for (const rawLine of body.split("\n")) {
+        const line = rawLine.trim();
+        if (line.length === 0 || line.startsWith("#"))
+            continue;
+        const indent = rawLine.length - rawLine.trimStart().length;
+        if (varsIndent !== null && indent <= varsIndent) {
+            varsIndent = null;
+            propIndent = null;
+        }
+        const varsBlock = /^vars\s*:\s*(.*)$/.exec(line);
+        if (varsBlock !== null) {
+            varsIndent = indent;
+            propIndent = null;
+            // Inline flow form: vars: { CLI_ARGS: "--changed-only" }
+            const inline = INLINE_CLI_ARGS_RE.exec(varsBlock[1] ?? "");
+            if (inline !== null) {
+                value = parseYamlScalar(inline[1] ?? "");
+            }
+            continue;
+        }
+        if (varsIndent === null)
+            continue;
+        propIndent ??= indent;
+        if (indent !== propIndent)
+            continue;
+        const cliArgs = /^CLI_ARGS\s*:\s*(.*)$/.exec(line);
+        if (cliArgs !== null) {
+            value = parseYamlScalar(cliArgs[1] ?? "");
+        }
+    }
+    return value;
+}
+/**
+ * True when the effective `CLI_ARGS` token list carries `requiredArg`.
+ *
+ * Exact token only: the guarded verbs accept the bare flag, so an equals form
+ * like `--changed-only=0` would exit 2 on an unrecognized argument while the
+ * contract reported the composition healthy.
+ */
+export function cliArgsCarry(cliArgs, requiredArg) {
+    if (cliArgs === null)
+        return false;
+    return cliArgs
+        .split(/\s+/)
+        .filter((token) => token.length > 0)
+        .some((token) => token === requiredArg);
 }
 function remediationForMissing(gateId, surface) {
     return (`Add \`${gateId}\` to the consumer ${surface} composition (Taskfile check deps ` +
@@ -712,12 +849,41 @@ export function evaluateConsumerCheckContract(projectRoot, options = {}) {
     }
     let anyAggregateDefined = false;
     for (const target of checkTargets) {
-        const deps = extractCheckDeps(rootTaskfile, target);
+        const entries = extractCheckDepEntries(rootTaskfile, target);
+        const deps = entries.map((entry) => entry.name);
         const body = extractTaskBody(rootTaskfile, target);
         const defined = deps.length > 0 || body.trim().length > 0;
         if (!defined)
             continue;
         anyAggregateDefined = true;
+        // Checked even on a trusted orchestrator body: a listed dep still runs, and
+        // unscoped on a merge chokepoint is the #3893 defect.
+        for (const [gateId, requiredArg] of MERGE_CHOKEPOINT_SCOPED_GATE_ARGS) {
+            // Every occurrence must carry the argument: a scoped entry followed by a
+            // bare duplicate still runs the repo-wide scan (#3893).
+            const listed = entries.filter((row) => row.name === gateId);
+            if (listed.length === 0)
+                continue;
+            if (listed.every((row) => cliArgsCarry(depEntryCliArgs(row.body), requiredArg)))
+                continue;
+            const finding = {
+                gateId,
+                surface: "check-task",
+                detail: `aggregate '${target}' composes ${gateId} without ${requiredArg}: an unscoped ` +
+                    "repo-wide lifecycle scan on a merge chokepoint fails a candidate for residue " +
+                    "another merge stranded (#3893)",
+                remediation: `Pass ${requiredArg} to ${gateId} in the '${target}' deps (go-task object form, ` +
+                    `vars: CLI_ARGS: "${requiredArg}"). Bare ${gateId} stays repo-wide for doctor, ` +
+                    "manual runs, and the after-merge --issue N run. " +
+                    "See content/docs/consumer-check-contract.md (#3893).",
+            };
+            if (options.frameworkSource === true) {
+                findings.push(finding);
+            }
+            else {
+                soft.push(finding);
+            }
+        }
         const trustThis = taskInvokesOrchestrator(target) && verifyDefinesRequired;
         if (trustThis)
             continue;

package/dist/delivery-attempt/evaluate.d.ts

@@ -4,7 +4,7 @@
  * Loads durable unit state and returns a single deterministic decision
  * before every delivery dispatch or retry.
  */
-import type { DeliveryUnitLedger, PreDispatchInput, PreDispatchResult } from "./types.js";
+import type { DeliveryBudgetPolicy, DeliveryUnitLedger, PreDispatchInput, PreDispatchResult } from "./types.js";
 /**
  * Evaluate whether a delivery dispatch may proceed.
  *
@@ -15,6 +15,14 @@ import type { DeliveryUnitLedger, PreDispatchInput, PreDispatchResult } from "./
  * That keeps bounded override quota for dispatches that truly need it.
  */
 export declare function evaluatePreDispatch(ledger: DeliveryUnitLedger, input: PreDispatchInput): PreDispatchResult;
+/**
+ * Elapsed budget for a run already queued or running (#3983).
+ * Pre-dispatch cannot see this case: an active attempt is DENY_DUPLICATE_ACTIVE.
+ */
+export declare function evaluateInFlight(ledger: DeliveryUnitLedger, input?: {
+    readonly now?: string;
+    readonly policy?: Partial<DeliveryBudgetPolicy>;
+}): PreDispatchResult;
 /**
  * Convenience: evaluate against ledger, and if blocked, return handoff suitable
  * for persistence via markBlocked + saveUnitLedger.

package/dist/delivery-attempt/evaluate.js

@@ -421,6 +421,75 @@ function evaluatePreDispatchNatural(ledger, input) {
         resume: null,
     });
 }
+/**
+ * Elapsed budget for a run already queued or running (#3983).
+ * Pre-dispatch cannot see this case: an active attempt is DENY_DUPLICATE_ACTIVE.
+ */
+export function evaluateInFlight(ledger, input = {}) {
+    const nowIso = utcIso(input.now);
+    const synthetic = {
+        scopeId: ledger.scopeId,
+        targetId: ledger.targetId,
+        workflowId: ledger.workflowId,
+        sourceRevision: ledger.lastSourceRevision ?? "in-flight",
+        trigger: "resume",
+        now: nowIso,
+        policy: input.policy,
+    };
+    const policy = mergePolicy(input.policy);
+    const active = activeAttempts(ledger);
+    if (active.length === 0) {
+        return result(synthetic, ledger, "ALLOW_FIRST_ATTEMPT", "no in-flight attempt", {
+            retryability: null,
+            fingerprint: null,
+            sameFailureCount: 0,
+            materialClass: "none",
+            resume: null,
+        });
+    }
+    const current = active[0];
+    if (current === undefined) {
+        return result(synthetic, ledger, "ALLOW_FIRST_ATTEMPT", "no in-flight attempt", {
+            retryability: null,
+            fingerprint: null,
+            sameFailureCount: 0,
+            materialClass: "none",
+            resume: null,
+        });
+    }
+    const startedMs = Date.parse(current.startedAt);
+    const nowMs = Date.parse(nowIso);
+    const liveSeconds = Number.isFinite(startedMs) && Number.isFinite(nowMs)
+        ? Math.max(0, (nowMs - startedMs) / 1000)
+        : 0;
+    const elapsed = ledger.totalElapsedSeconds + liveSeconds;
+    if (elapsed >= policy.maxElapsedSeconds) {
+        const resume = {
+            kind: "operator-override",
+            description: "elapsed budget exhausted on in-flight attempt; override or phase reset required",
+            satisfied: false,
+        };
+        return result(synthetic, ledger, "BLOCK_ELAPSED_BUDGET", "in-flight elapsed-time budget exhausted", {
+            retryability: ledger.lastFailure?.retryability ?? null,
+            fingerprint: ledger.lastFailure?.fingerprint ?? null,
+            sameFailureCount: 0,
+            materialClass: "none",
+            resume,
+            handoffLedger: {
+                ...ledger,
+                resumeCondition: resume,
+                blockedDecision: "BLOCK_ELAPSED_BUDGET",
+            },
+        });
+    }
+    return result(synthetic, ledger, "ALLOW_RESUME", "in-flight elapsed under budget", {
+        retryability: null,
+        fingerprint: null,
+        sameFailureCount: 0,
+        materialClass: "none",
+        resume: ledger.resumeCondition,
+    });
+}
 /**
  * Convenience: evaluate against ledger, and if blocked, return handoff suitable
  * for persistence via markBlocked + saveUnitLedger.

package/dist/delivery-attempt/index.d.ts

@@ -8,7 +8,7 @@
  * @see content/docs/delivery-attempt.md
  */
 export { type BeginAttemptOnDiskInput, beginAttemptOnDisk, type CompleteAttemptOnDiskInput, completeAttemptOnDisk, } from "./disk-begin.js";
-export { evaluateAndPrepareBlock, evaluatePreDispatch, } from "./evaluate.js";
+export { evaluateAndPrepareBlock, evaluateInFlight, evaluatePreDispatch, } from "./evaluate.js";
 export { buildFailureInfo, computeFailureFingerprint, type FingerprintInput, inferRetryability, normalizeFailureMessage, } from "./fingerprint.js";
 export { buildTerminalHandoff, defaultResumeFor, formatHandoffReport, nextSafeActionFor, redactHandoffForPersist, } from "./handoff.js";
 export { activeAttempts, beginAttempt, clearBlockIfResumed, completeAttempt, deliveryAttemptsDir, emptyUnitLedger, hasActiveAttempt, isUnitLockReclaimable, type LoadUnitLedgerResult, listUnitLedgers, loadOrCreateUnitLedger, loadUnitLedger, loadUnitLedgerResult, MemoryLedgerStore, markBlocked, newAttemptId, parseUnitLedger, recordOperatorOverride, saveUnitLedger, UNIT_LOCK_STALE_MS, unitLedgerFilename, unitLedgerPath, withUnitLock, } from "./ledger.js";

package/dist/delivery-attempt/index.js

@@ -8,7 +8,7 @@
  * @see content/docs/delivery-attempt.md
  */
 export { beginAttemptOnDisk, completeAttemptOnDisk, } from "./disk-begin.js";
-export { evaluateAndPrepareBlock, evaluatePreDispatch, } from "./evaluate.js";
+export { evaluateAndPrepareBlock, evaluateInFlight, evaluatePreDispatch, } from "./evaluate.js";
 export { buildFailureInfo, computeFailureFingerprint, inferRetryability, normalizeFailureMessage, } from "./fingerprint.js";
 export { buildTerminalHandoff, defaultResumeFor, formatHandoffReport, nextSafeActionFor, redactHandoffForPersist, } from "./handoff.js";
 export { activeAttempts, beginAttempt, clearBlockIfResumed, completeAttempt, deliveryAttemptsDir, emptyUnitLedger, hasActiveAttempt, isUnitLockReclaimable, listUnitLedgers, loadOrCreateUnitLedger, loadUnitLedger, loadUnitLedgerResult, MemoryLedgerStore, markBlocked, newAttemptId, parseUnitLedger, recordOperatorOverride, saveUnitLedger, UNIT_LOCK_STALE_MS, unitLedgerFilename, unitLedgerPath, withUnitLock, } from "./ledger.js";

package/dist/deposit/live-procedure-exclusions.d.ts

@@ -0,0 +1,18 @@
+/**
+ * C3 live-procedure exclusion declaration (#3602 / #3899).
+ *
+ * History, examples, and prohibitions are skipped by this list, not by
+ * matching prose patterns. A file that names a deleted Python script in
+ * order to forbid treating it as a live path must appear here as
+ * `prohibition` or C3 will mis-fire.
+ */
+export type LiveProcedureExclusionKind = "history" | "example" | "prohibition";
+export interface LiveProcedureExclusion {
+    /** POSIX path relative to a flattened consumer deposit root. */
+    readonly path: string;
+    readonly kind: LiveProcedureExclusionKind;
+    readonly reason: string;
+}
+export declare const LIVE_PROCEDURE_EXCLUSIONS: readonly LiveProcedureExclusion[];
+export declare function isDeclaredLiveProcedureExclusion(relativePath: string): boolean;
+//# sourceMappingURL=live-procedure-exclusions.d.ts.map