@deftai/directive-core 0.107.0 → 0.109.0

package/dist/intake/clause-derivation.js

@@ -6,7 +6,7 @@
  * the missing derive step.
  */
 import { ENV_RUN_SUMMARY_PATH, RunSummaryEmitter, } from "../run-summary/index.js";
-import { deriveAcceptanceClauses, readAcceptanceClauses, serializeAcceptanceClauses, } from "../verify-ac/clauses.js";
+import { collectPlanItemAcceptanceSurface, deriveAcceptanceClauses, readAcceptanceClauses, serializeAcceptanceClauses, } from "../verify-ac/clauses.js";
 /** One-line remediation when a stamp has no statement-traceable clause (#3398). */
 export const CLAUSE_STAMP_IMPLEMENTATION_ONLY_REMEDIATION = "derive clauses from the statement's testable constraints";
 export const MISSING_AMBIGUITY_ATTESTATION_CAUSE = "missing_ambiguity_attestation";
@@ -72,7 +72,11 @@ export function collectTaskStatementFromPlan(plan) {
                 continue;
             }
             const narrative = asRecord(rec.narrative);
-            const text = narrative?.Acceptance;
+            const declared = narrative?.Acceptance;
+            // #3826: criteria commonly live in item.title with an empty narrative object.
+            // Reading only narrative.Acceptance left them out of the statement entirely,
+            // so a clause derived from a title could not trace back to it.
+            const text = isNonEmptyString(declared) ? declared : rec.title;
             if (isNonEmptyString(text)) {
                 parts.push(text.trim());
             }
@@ -296,7 +300,9 @@ export function applyClauseDerivationToPlan(plan, options = {}) {
             notice: "",
         };
     }
-    const clauses = deriveAcceptanceClauses(collectTaskStatementFromPlan(plan));
+    const clauses = deriveAcceptanceClauses(collectTaskStatementFromPlan(plan), {
+        itemSurface: collectPlanItemAcceptanceSurface(plan),
+    });
     if (clauses.length === 0) {
         return { applied: false, clauses: [], notice: "" };
     }

package/dist/intake/issue-ingest.d.ts

@@ -1,5 +1,5 @@
 import { type ScanFlag } from "../cache/scanner.js";
-import { type IssueComment as ShapeIssueComment } from "../umbrella-current-shape/index.js";
+import { type CurrentShapeNullReason, type IssueComment as ShapeIssueComment } from "../umbrella-current-shape/index.js";
 import { LEGACY_ARTIFACT_SUFFIX, LEGACY_INFO_ROOT_KEY, MIGRATED_ARTIFACT_SUFFIX, MIGRATED_INFO_ROOT_KEY } from "../xbrief-migrate/constants.js";
 import { type ScmCallFn } from "./reconcile-issues.js";
 /** Reference type pointing at the canonical current-shape comment permalink (#1870). */
@@ -42,6 +42,11 @@ export declare function mapIngestCommentsToShapeComments(comments: readonly Issu
 export declare function selectIngestCurrentShape(comments: readonly IssueComment[]): (ShapeIssueComment & {
     pass: number;
 }) | null;
+/**
+ * Classify why `selectIngestCurrentShape` returned null so ingest can report a
+ * reason instead of silently omitting the CurrentShape narrative (#3934).
+ */
+export declare function describeIngestCurrentShapeNull(comments: readonly IssueComment[]): CurrentShapeNullReason;
 /** Count maintainer current-shape comments (lint surface for !=1). */
 export declare function countIngestCurrentShapeComments(comments: readonly IssueComment[]): number;
 export declare function bodyControlCharacterLabels(body: string): string[];

package/dist/intake/issue-ingest.js

@@ -2,6 +2,7 @@ import { lstatSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSyn
 import { basename, dirname, join, resolve } from "node:path";
 import { cacheGet } from "../cache/operations.js";
 import { scan } from "../cache/scanner.js";
+import { assertCompletedArcAllowsIngest, DesignCritiqueIngestBlockedError, } from "../design-critique/completed-arc-record.js";
 import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
 import { hasArtifactSuffix, resolveLifecycleRoot } from "../layout/resolve.js";
 import { captureAndAttachLiteralAcceptance } from "../literal-acceptance/index.js";
@@ -10,7 +11,7 @@ import { stampAcceptanceFromLiteralCapture } from "../product-first-done-gate/in
 import { call } from "../scm/call.js";
 import { resolveProjectRoot } from "../scope/project-context.js";
 import { resolveProjectRepo } from "../slice/project-context.js";
-import { countMaintainerCurrentShapeComments, mapIssueCommentEntry, RAW_ISSUE_COMMENTS_KEY, selectCurrentShapeComment, } from "../umbrella-current-shape/index.js";
+import { countMaintainerCurrentShapeComments, describeCurrentShapeNull, mapIssueCommentEntry, RAW_ISSUE_COMMENTS_KEY, selectCurrentShapeComment, } from "../umbrella-current-shape/index.js";
 import { slugify, TODAY } from "../vbrief-build/build.js";
 import { EMITTED_VBRIEF_VERSION } from "../vbrief-build/constants.js";
 import { stampDerivedClausesOnAcceptance } from "../verify-ac/clauses.js";
@@ -65,6 +66,13 @@ export function mapIngestCommentsToShapeComments(comments) {
 export function selectIngestCurrentShape(comments) {
     return selectCurrentShapeComment(mapIngestCommentsToShapeComments(comments));
 }
+/**
+ * Classify why `selectIngestCurrentShape` returned null so ingest can report a
+ * reason instead of silently omitting the CurrentShape narrative (#3934).
+ */
+export function describeIngestCurrentShapeNull(comments) {
+    return describeCurrentShapeNull(mapIngestCommentsToShapeComments(comments));
+}
 /** Count maintainer current-shape comments (lint surface for !=1). */
 export function countIngestCurrentShapeComments(comments) {
     return countMaintainerCurrentShapeComments(mapIngestCommentsToShapeComments(comments));
@@ -408,6 +416,17 @@ export function buildIssueVbrief(issue, status, repoUrl, options = {}) {
         // Scan shape body under the same fail-closed contract as Overview (#2306).
         narratives.CurrentShape = scanUntrustedIngestText(number, currentShape.body);
     }
+    else {
+        // #3934: a thread whose only shape comments failed the #2307 authorship
+        // filter is otherwise indistinguishable from a thread that never had one,
+        // so a cache-reading agent falls back to the stale body. The note is
+        // framework-authored and carries comment ids plus normalized author
+        // associations only -- no comment text -- so it needs no quarantine scan.
+        const shapeNullReason = describeIngestCurrentShapeNull(commentThread);
+        if (shapeNullReason.kind === "non-maintainer-shape") {
+            narratives.CurrentShapeUnavailable = shapeNullReason.message;
+        }
+    }
     if (labelNames.length > 0) {
         narratives.Labels = labelNames.join(", ");
     }
@@ -639,7 +658,8 @@ export function fetchSingleIssue(repo, number, options = {}) {
         return null;
     }
     if (result.returncode !== 0) {
-        process.stderr.write(`Error: gh CLI failed fetching #${number}: ${result.stderr.trim()}\n`);
+        const invoked = result.args?.[0] ?? "gh";
+        process.stderr.write(`Error: ${invoked} failed fetching #${number}: ${result.stderr.trim()}\n`);
         return null;
     }
     try {
@@ -703,6 +723,41 @@ function resolveIngestProjectRoot(vbriefDir, cwd) {
     }
     return null;
 }
+function issueLabelNames(issue) {
+    const labels = issue.labels;
+    if (!Array.isArray(labels))
+        return [];
+    const names = [];
+    for (const lbl of labels) {
+        if (typeof lbl === "string") {
+            names.push(lbl);
+            continue;
+        }
+        if (lbl !== null && typeof lbl === "object" && !Array.isArray(lbl)) {
+            const name = lbl.name;
+            if (typeof name === "string")
+                names.push(name);
+        }
+    }
+    return names;
+}
+function threadCommentsFromIssue(issue) {
+    const raw = issue[ISSUE_COMMENT_THREAD_KEY];
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const entry of raw) {
+        if (entry === null || typeof entry !== "object" || Array.isArray(entry))
+            continue;
+        const rec = entry;
+        const id = Number(rec.id);
+        if (!Number.isSafeInteger(id) || id <= 0)
+            continue;
+        const body = typeof rec.body === "string" ? rec.body : "";
+        out.push({ id, body });
+    }
+    return out;
+}
 export function ingestOne(issue, options) {
     const number = Number(issue.number);
     const refs = options.existingRefs ?? scanProvenanceRefs(options.vbriefDir);
@@ -719,6 +774,11 @@ export function ingestOne(issue, options) {
         cwd: options.cwd,
         cacheRoot: options.cacheRoot,
     });
+    assertCompletedArcAllowsIngest({
+        issueNumber: number,
+        labels: issueLabelNames(enriched),
+        comments: threadCommentsFromIssue(enriched),
+    });
     const emissionLayout = resolveIngestEmissionLayout(options.vbriefDir);
     const [vbrief, folder] = buildIssueVbrief(enriched, options.status, options.repoUrl, {
         infoRootKey: emissionLayout.infoRootKey,
@@ -774,6 +834,7 @@ export function ingestBulk(issues, options) {
         duplicate: [],
         dryrun: [],
         failed: [],
+        blocked: [],
         notices: [],
     };
     for (const issue of filtered) {
@@ -790,6 +851,11 @@ export function ingestBulk(issues, options) {
                 process.stderr.write(`${exc.message}\n`);
                 continue;
             }
+            if (exc instanceof DesignCritiqueIngestBlockedError) {
+                summary.blocked.push(`#${exc.issueNumber}`);
+                process.stderr.write(`${exc.message}\n`);
+                continue;
+            }
             throw exc;
         }
         const [result, path, msg] = ingested;
@@ -861,7 +927,8 @@ export function issueIngestMain(args) {
         const duplicate = summary.duplicate;
         const dryrun = summary.dryrun;
         const failed = summary.failed ?? [];
-        process.stdout.write(`issue:ingest bulk summary: ${created.length} created, ${duplicate.length} duplicate, ${dryrun.length} dry-run, ${failed.length} refused (total considered: ${summary.total})\n`);
+        const blocked = summary.blocked ?? [];
+        process.stdout.write(`issue:ingest bulk summary: ${created.length} created, ${duplicate.length} duplicate, ${dryrun.length} dry-run, ${failed.length} refused, ${blocked.length} blocked (total considered: ${summary.total})\n`);
         for (const entry of created) {
             process.stdout.write(`  CREATED ${entry}\n`);
         }
@@ -877,8 +944,16 @@ export function issueIngestMain(args) {
         for (const entry of failed) {
             process.stdout.write(`  REFUSED ${entry} (quarantine scanner hard-fail; nothing written)\n`);
         }
+        for (const entry of blocked) {
+            process.stdout.write(`  BLOCKED ${entry} (design-critique completed-arc record; nothing written)\n`);
+        }
         // #2306: fail closed on any quarantine hard-fail in the batch.
-        return failed.length > 0 ? 2 : 0;
+        // Design-critique protocol holds are exit 1, not the scanner fatal path.
+        if (failed.length > 0)
+            return 2;
+        if (blocked.length > 0)
+            return 1;
+        return 0;
     }
     const issue = fetchIssue(repo, args.number, { cwd: projectRoot });
     if (issue === null) {
@@ -901,6 +976,10 @@ export function issueIngestMain(args) {
             process.stderr.write(`${exc.message}\n`);
             return 2;
         }
+        if (exc instanceof DesignCritiqueIngestBlockedError) {
+            process.stderr.write(`${exc.message}\n`);
+            return 1;
+        }
         throw exc;
     }
     process.stdout.write(`${msg}\n`);

package/dist/intake/platform-capabilities.d.ts

@@ -1,11 +1,18 @@
 /** Minimal runtime capability probe for github_auth_modes (#1557a / #1784). */
+import { type ManagedRuntimeProbe } from "../platform/cursor-managed-runtime.js";
 export declare const RUNTIME_MODE_LOCAL_UNSANDBOXED = "local-unsandboxed";
 export declare const RUNTIME_MODE_CURSOR_NATIVE_SANDBOX = "cursor-native-sandbox";
 export declare const RUNTIME_MODE_CLOUD_HEADLESS = "cloud-headless";
 export declare const KNOWN_RUNTIME_MODES: Set<string>;
 export interface RuntimeCapabilityReport {
     readonly runtimeMode: string;
+    /** Stable id naming why `runtimeMode` was chosen; surfaced by scm:status (#3859). */
+    readonly runtimeModeReason?: string;
 }
-export declare function probeRuntimeCapabilities(environ?: NodeJS.ProcessEnv): RuntimeCapabilityReport;
-export declare function getPlatformCapabilities(): RuntimeCapabilityReport;
+export interface ProbeRuntimeCapabilityOptions {
+    /** Injectable managed-runtime probe (#3859). Defaults to the metadata read. */
+    readonly managedRuntimeProbe?: ManagedRuntimeProbe;
+}
+export declare function probeRuntimeCapabilities(environ?: NodeJS.ProcessEnv, options?: ProbeRuntimeCapabilityOptions): RuntimeCapabilityReport;
+export declare function getPlatformCapabilities(options?: ProbeRuntimeCapabilityOptions): RuntimeCapabilityReport;
 //# sourceMappingURL=platform-capabilities.d.ts.map

package/dist/intake/platform-capabilities.js

@@ -1,4 +1,5 @@
 /** Minimal runtime capability probe for github_auth_modes (#1557a / #1784). */
+import { hasExplicitHostGhSelection, probeManagedRuntime, RUNTIME_REASON_CI_MARKER, RUNTIME_REASON_CURSOR_MARKER_AMBIGUOUS, RUNTIME_REASON_CURSOR_SANDBOX_MARKER, RUNTIME_REASON_EXPLICIT_HOST_GH, RUNTIME_REASON_MANAGED_RUNTIME_PROBE, RUNTIME_REASON_NO_RUNTIME_MARKER, } from "../platform/cursor-managed-runtime.js";
 export const RUNTIME_MODE_LOCAL_UNSANDBOXED = "local-unsandboxed";
 export const RUNTIME_MODE_CURSOR_NATIVE_SANDBOX = "cursor-native-sandbox";
 export const RUNTIME_MODE_CLOUD_HEADLESS = "cloud-headless";
@@ -11,24 +12,52 @@ const TRUTHY = new Set(["1", "true", "yes", "on"]);
 function isTruthy(value) {
     return value !== undefined && TRUTHY.has(value.trim().toLowerCase());
 }
-function classifyRuntimeMode(environ = process.env) {
+/**
+ * Classify the execution runtime.
+ *
+ * Ordering is load-bearing (#3859):
+ *   1. CI markers, so a CI runner is never reclassified by a Cursor signal.
+ *   2. A positive Cursor managed-runtime read, above every other Cursor signal.
+ *   3. Cursor native sandbox.
+ *   4. A Cursor marker with no managed read leaves the runtime AMBIGUOUS. Only
+ *      an explicit operator/dispatcher selection resolves it to local; absent
+ *      that, the verdict is unchanged from before #3859.
+ */
+function classifyRuntimeMode(environ = process.env, options = {}) {
     for (const key of ["GROK_BUILD", "GITHUB_ACTIONS", "CI", "BUILDKITE", "DEFT_AGENT_RUNTIME"]) {
         if (isTruthy(environ[key])) {
-            return RUNTIME_MODE_CLOUD_HEADLESS;
+            return { mode: RUNTIME_MODE_CLOUD_HEADLESS, reason: RUNTIME_REASON_CI_MARKER };
         }
     }
+    const managedProbe = options.managedRuntimeProbe ?? probeManagedRuntime;
+    if (managedProbe(environ).verdict === "managed") {
+        return {
+            mode: RUNTIME_MODE_CLOUD_HEADLESS,
+            reason: RUNTIME_REASON_MANAGED_RUNTIME_PROBE,
+        };
+    }
     if (isTruthy(environ.CURSOR_SANDBOX) || isTruthy(environ.CURSOR_SANDBOX_LANDLOCK_STATUS)) {
-        return RUNTIME_MODE_CURSOR_NATIVE_SANDBOX;
+        return {
+            mode: RUNTIME_MODE_CURSOR_NATIVE_SANDBOX,
+            reason: RUNTIME_REASON_CURSOR_SANDBOX_MARKER,
+        };
     }
     if (isTruthy(environ.CURSOR_AGENT) || isTruthy(environ.CURSOR_COMPOSER)) {
-        return RUNTIME_MODE_CLOUD_HEADLESS;
+        if (hasExplicitHostGhSelection(environ)) {
+            return { mode: RUNTIME_MODE_LOCAL_UNSANDBOXED, reason: RUNTIME_REASON_EXPLICIT_HOST_GH };
+        }
+        return {
+            mode: RUNTIME_MODE_CLOUD_HEADLESS,
+            reason: RUNTIME_REASON_CURSOR_MARKER_AMBIGUOUS,
+        };
     }
-    return RUNTIME_MODE_LOCAL_UNSANDBOXED;
+    return { mode: RUNTIME_MODE_LOCAL_UNSANDBOXED, reason: RUNTIME_REASON_NO_RUNTIME_MARKER };
 }
-export function probeRuntimeCapabilities(environ = process.env) {
-    return { runtimeMode: classifyRuntimeMode(environ) };
+export function probeRuntimeCapabilities(environ = process.env, options = {}) {
+    const { mode, reason } = classifyRuntimeMode(environ, options);
+    return { runtimeMode: mode, runtimeModeReason: reason };
 }
-export function getPlatformCapabilities() {
-    return probeRuntimeCapabilities();
+export function getPlatformCapabilities(options = {}) {
+    return probeRuntimeCapabilities(process.env, options);
 }
 //# sourceMappingURL=platform-capabilities.js.map

package/dist/intake/reconcile-issues.js

@@ -3,12 +3,12 @@ import { mkdirSync, readdirSync, readFileSync, renameSync, statSync, writeFileSy
 import { join, resolve } from "node:path";
 import { assertProjectionContained, assertWriteTargetSafe, ProjectionContainmentError, } from "../fs/projection-containment.js";
 import { hasArtifactSuffix, resolveLifecycleRoot } from "../layout/resolve.js";
+import { missingEnvelopeMessage, stampExistingEnvelopes } from "../lifecycle/brief-envelope.js";
 import { call } from "../scm/call.js";
 import { updateDecomposedChildBackReferences } from "../scope/decomposed-refs.js";
 import { resolveProjectRoot } from "../scope/project-context.js";
 import { resolveProjectRepo } from "../slice/project-context.js";
 import { FOLDER_ALLOWED_STATUSES } from "../vbrief-validate/constants.js";
-import { LEGACY_INFO_ROOT_KEY, MIGRATED_INFO_ROOT_KEY } from "../xbrief-migrate/constants.js";
 export const LIFECYCLE_FOLDERS = [
     "proposed",
     "pending",
@@ -713,14 +713,13 @@ export function applyLifecycleFixes(vbriefDir, report, projectRoot = null) {
         plan.status = terminalStatus;
         const stamp = utcNowIso();
         // Stamp `updated` into whichever info envelope the file already uses (#2346).
-        // Canonical v0.8 briefs use `xBRIEFInfo`; stamping `vBRIEFInfo` unconditionally
-        // appended a stray, version-less `vBRIEFInfo` block that then failed
-        // `vbrief:validate` ('vBRIEFInfo.version' must be one of ..., got 'undefined').
-        // Legacy briefs (or files without either envelope) keep the `vBRIEFInfo` key.
-        const infoKey = MIGRATED_INFO_ROOT_KEY in data ? MIGRATED_INFO_ROOT_KEY : LEGACY_INFO_ROOT_KEY;
-        const info = (data[infoKey] ?? {});
-        data[infoKey] = info;
-        info.updated = stamp;
+        // A file carrying neither envelope is already invalid; creating one here hid
+        // that cause behind a manufactured version-less `vBRIEFInfo` (#3933), so the
+        // sweep now refuses it by name and leaves the artifact in place.
+        if (stampExistingEnvelopes(data, stamp).length === 0) {
+            failures.push(missingEnvelopeMessage(relPath));
+            continue;
+        }
         plan.updated = stamp;
         propagateItemStatus(plan.items, terminalStatus, stamp);
         try {
@@ -780,12 +779,13 @@ export function repairCompletedStatusDrift(vbriefDir, drift, projectRoot = null)
             continue;
         }
         const stamp = utcNowIso();
+        // Same envelope policy as the closed-issue sweep above (#3933).
+        if (stampExistingEnvelopes(data, stamp).length === 0) {
+            failures.push(missingEnvelopeMessage(entry.rel_path));
+            continue;
+        }
         plan.status = "completed";
         plan.updated = stamp;
-        const infoKey = MIGRATED_INFO_ROOT_KEY in data ? MIGRATED_INFO_ROOT_KEY : LEGACY_INFO_ROOT_KEY;
-        const info = (data[infoKey] ?? {});
-        data[infoKey] = info;
-        info.updated = stamp;
         propagateItemStatus(plan.items, "completed", stamp);
         try {
             writeFileSync(src, `${JSON.stringify(data, null, 2)}\n`, "utf8");

package/dist/lifecycle/brief-envelope.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared document-envelope policy for lifecycle mutators (#3933).
+ *
+ * A brief carries one document envelope: `xBRIEFInfo` on canonical v0.8
+ * artifacts, `vBRIEFInfo` on legacy v0.6 ones. A mutator stamps whichever
+ * envelope the artifact already has and creates none. Creating one on a v0.8
+ * brief appends a version-less `vBRIEFInfo`, and `validateVbriefSchema`
+ * resolves `vBRIEFInfo` first, so the manufactured block wins and the brief the
+ * mutator just wrote fails validation (#2346 / #2862 / #3933).
+ */
+import { LEGACY_INFO_ROOT_KEY, MIGRATED_INFO_ROOT_KEY } from "../xbrief-migrate/constants.js";
+export type BriefEnvelopeKey = typeof MIGRATED_INFO_ROOT_KEY | typeof LEGACY_INFO_ROOT_KEY;
+/** Envelope keys in canonical order: v0.8 first, legacy v0.6 second. */
+export declare const BRIEF_ENVELOPE_KEYS: readonly BriefEnvelopeKey[];
+/** Envelope keys the artifact already carries as JSON objects. */
+export declare function presentEnvelopeKeys(data: Record<string, unknown>): BriefEnvelopeKey[];
+/**
+ * Stamp `updated` on every envelope the artifact already carries; create none.
+ * Returns the stamped keys so a caller can refuse an envelope-less artifact by
+ * name instead of manufacturing one.
+ */
+export declare function stampExistingEnvelopes(data: Record<string, unknown>, nowIso: string): BriefEnvelopeKey[];
+/** Refusal naming both accepted envelopes, for a caller-supplied subject (#3933). */
+export declare function missingEnvelopeMessage(subject: string): string;
+//# sourceMappingURL=brief-envelope.d.ts.map

package/dist/lifecycle/brief-envelope.js

@@ -0,0 +1,42 @@
+/**
+ * Shared document-envelope policy for lifecycle mutators (#3933).
+ *
+ * A brief carries one document envelope: `xBRIEFInfo` on canonical v0.8
+ * artifacts, `vBRIEFInfo` on legacy v0.6 ones. A mutator stamps whichever
+ * envelope the artifact already has and creates none. Creating one on a v0.8
+ * brief appends a version-less `vBRIEFInfo`, and `validateVbriefSchema`
+ * resolves `vBRIEFInfo` first, so the manufactured block wins and the brief the
+ * mutator just wrote fails validation (#2346 / #2862 / #3933).
+ */
+import { LEGACY_INFO_ROOT_KEY, MIGRATED_INFO_ROOT_KEY } from "../xbrief-migrate/constants.js";
+/** Envelope keys in canonical order: v0.8 first, legacy v0.6 second. */
+export const BRIEF_ENVELOPE_KEYS = [
+    MIGRATED_INFO_ROOT_KEY,
+    LEGACY_INFO_ROOT_KEY,
+];
+/** Envelope keys the artifact already carries as JSON objects. */
+export function presentEnvelopeKeys(data) {
+    return BRIEF_ENVELOPE_KEYS.filter((key) => {
+        const env = data[key];
+        return typeof env === "object" && env !== null && !Array.isArray(env);
+    });
+}
+/**
+ * Stamp `updated` on every envelope the artifact already carries; create none.
+ * Returns the stamped keys so a caller can refuse an envelope-less artifact by
+ * name instead of manufacturing one.
+ */
+export function stampExistingEnvelopes(data, nowIso) {
+    const stamped = presentEnvelopeKeys(data);
+    for (const key of stamped) {
+        data[key].updated = nowIso;
+    }
+    return stamped;
+}
+/** Refusal naming both accepted envelopes, for a caller-supplied subject (#3933). */
+export function missingEnvelopeMessage(subject) {
+    return (`${subject} carries neither \`${MIGRATED_INFO_ROOT_KEY}\` (v0.8) nor ` +
+        `\`${LEGACY_INFO_ROOT_KEY}\` (v0.6) -- malformed. Lifecycle mutators refuse ` +
+        "rather than create one (#3933).");
+}
+//# sourceMappingURL=brief-envelope.js.map

package/dist/lifecycle/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./brief-envelope.js";
 export * from "./completed-consistency.js";
 export * from "./completed-tracked-on-delivery.js";
 export * from "./completed-write-guard.js";

package/dist/lifecycle/index.js

@@ -1,3 +1,4 @@
+export * from "./brief-envelope.js";
 export * from "./completed-consistency.js";
 export * from "./completed-tracked-on-delivery.js";
 export * from "./completed-write-guard.js";

package/dist/literal-acceptance/evaluate.js

@@ -189,16 +189,25 @@ export function evaluateLiteralAcceptanceFromPlan(plan, options = {}) {
     // Rejected stated commands are fail-closed for completion (#3267 Greptile conf residual).
     // A safety-rejected shell-shaped acceptance line is not "optional diagnostic" — operators
     // must promote a safe alternative or remove the stated command from the task statement.
+    const mergedRejected = [];
+    const seenRejected = new Set();
+    for (const row of [...(result.rejected ?? []), ...resolved.rejected]) {
+        const key = `${row.command}\0${row.reason}`;
+        if (seenRejected.has(key))
+            continue;
+        seenRejected.add(key);
+        mergedRejected.push(row);
+    }
     let ok = result.ok;
     let code = result.code;
-    let message = appendRejectedNote(result.message, resolved.rejected);
-    if (resolved.rejected.length > 0) {
+    let message = appendRejectedNote(result.message, mergedRejected);
+    if (mergedRejected.length > 0) {
         ok = false;
         if (code === 0)
             code = 1;
-        const ledger = formatRejectedLedger(resolved.rejected);
+        const ledger = formatRejectedLedger(mergedRejected);
         message =
-            `Literal acceptance-command gate FAILED (#3267): ${resolved.rejected.length} ` +
+            `Literal acceptance-command gate FAILED (#3267): ${mergedRejected.length} ` +
                 `safety-rejected stated command(s) block completion until resolved ` +
                 `(promote a safe alternative or remove from the task statement).\n` +
                 ledger +
@@ -212,7 +221,7 @@ export function evaluateLiteralAcceptanceFromPlan(plan, options = {}) {
         ...result,
         ok,
         code,
-        rejected: resolved.rejected,
+        rejected: mergedRejected,
         advisoryRejected: resolved.advisoryRejected,
         transcriptPromptSkipped: resolved.transcriptPromptSkipped,
         message,

package/dist/literal-acceptance/index.d.ts

@@ -6,7 +6,7 @@
  */
 export { attachLiteralAcceptanceCommands, type CaptureLiteralAcceptanceResult, captureAndAttachLiteralAcceptance, captureLiteralAcceptanceCommands, captureLiteralAcceptanceCommandsDetailed, formatRejectedLedger, hasStructuredAcceptanceCommands, INLINE_PROSE_MENTION_REASON, isInlineProseMention, isProseDerivedRejection, readNotAcceptanceCommands, readStoredLiteralAcceptanceCommands, readStoredLiteralAcceptanceDetailed, } from "./capture.js";
 export { appendLiteralAcceptanceAdvisory, type EvaluateLiteralAcceptanceOptions, evaluateLiteralAcceptanceFromPath, evaluateLiteralAcceptanceFromPlan, formatLiteralAcceptanceAdvisory, isLiteralAcceptanceRequiredAtCeremonyDepth, LITERAL_ACCEPTANCE_ADVISORY_MARKER, type ResolvedLiteralAcceptance, resolveLiteralAcceptanceCommands, resolveLiteralAcceptanceDetailed, stripLiteralAcceptanceAdvisory, } from "./evaluate.js";
-export { defaultLiteralAcceptanceRunner, runLiteralAcceptanceCommand, runLiteralAcceptanceCommands, } from "./run.js";
+export { defaultLiteralAcceptanceRunner, isSafetyRefusalRun, runLiteralAcceptanceCommand, runLiteralAcceptanceCommands, } from "./run.js";
 export { type CommandSafetyResult, evaluateCommandSafety, evaluateNoopDenylist, evaluateStampAcceptanceSafety, isExecutableLiteralSource, isNoopRefusalReason, isVerbatimStatementSpan, NOOP_ACCEPTANCE_REMEDIATION, REJECTED_NOOP_OUTCOME, type RejectedNoopOutcome, type StampAcceptanceCommand, type StampAcceptanceSafetyInput, type StampAcceptanceSafetyResult, type StampSourceRung, } from "./safety.js";
 export { EXECUTABLE_LITERAL_SOURCES, LITERAL_ACCEPTANCE_METADATA_KEY, LITERAL_ACCEPTANCE_METADATA_KEY_CAMEL, LITERAL_ACCEPTANCE_NOT_COMMANDS_METADATA_KEY, LITERAL_ACCEPTANCE_REJECTED_METADATA_KEY, type LiteralAcceptanceCommand, type LiteralAcceptanceGateResult, type LiteralAcceptanceRunner, type LiteralAcceptanceRunResult, type LiteralAcceptanceSource, type RejectedLiteralCommand, } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/literal-acceptance/index.js

@@ -6,7 +6,7 @@
  */
 export { attachLiteralAcceptanceCommands, captureAndAttachLiteralAcceptance, captureLiteralAcceptanceCommands, captureLiteralAcceptanceCommandsDetailed, formatRejectedLedger, hasStructuredAcceptanceCommands, INLINE_PROSE_MENTION_REASON, isInlineProseMention, isProseDerivedRejection, readNotAcceptanceCommands, readStoredLiteralAcceptanceCommands, readStoredLiteralAcceptanceDetailed, } from "./capture.js";
 export { appendLiteralAcceptanceAdvisory, evaluateLiteralAcceptanceFromPath, evaluateLiteralAcceptanceFromPlan, formatLiteralAcceptanceAdvisory, isLiteralAcceptanceRequiredAtCeremonyDepth, LITERAL_ACCEPTANCE_ADVISORY_MARKER, resolveLiteralAcceptanceCommands, resolveLiteralAcceptanceDetailed, stripLiteralAcceptanceAdvisory, } from "./evaluate.js";
-export { defaultLiteralAcceptanceRunner, runLiteralAcceptanceCommand, runLiteralAcceptanceCommands, } from "./run.js";
+export { defaultLiteralAcceptanceRunner, isSafetyRefusalRun, runLiteralAcceptanceCommand, runLiteralAcceptanceCommands, } from "./run.js";
 export { evaluateCommandSafety, evaluateNoopDenylist, evaluateStampAcceptanceSafety, isExecutableLiteralSource, isNoopRefusalReason, isVerbatimStatementSpan, NOOP_ACCEPTANCE_REMEDIATION, REJECTED_NOOP_OUTCOME, } from "./safety.js";
 export { EXECUTABLE_LITERAL_SOURCES, LITERAL_ACCEPTANCE_METADATA_KEY, LITERAL_ACCEPTANCE_METADATA_KEY_CAMEL, LITERAL_ACCEPTANCE_NOT_COMMANDS_METADATA_KEY, LITERAL_ACCEPTANCE_REJECTED_METADATA_KEY, } from "./types.js";
 //# sourceMappingURL=index.js.map

package/dist/literal-acceptance/run.d.ts

@@ -6,6 +6,8 @@
  * Self-chosen verification is supplementary — this gate only runs stored literals.
  */
 import type { LiteralAcceptanceCommand, LiteralAcceptanceGateResult, LiteralAcceptanceRunner, LiteralAcceptanceRunResult } from "./types.js";
+/** True when the row is a pre-execution safety refusal, not a product measurement (#3615). */
+export declare function isSafetyRefusalRun(run: Pick<LiteralAcceptanceRunResult, "exitCode" | "detail">): boolean;
 /** Default shell runner: exact command string via platform shell. */
 export declare function defaultLiteralAcceptanceRunner(input: {
     readonly command: string;

package/dist/literal-acceptance/run.js

@@ -9,6 +9,13 @@ import { spawnSync } from "node:child_process";
 import { isAbsolute, resolve } from "node:path";
 import { isInlineProseMention } from "./capture.js";
 import { evaluateCommandSafety, isExecutableLiteralSource } from "./safety.js";
+/** True when the row is a pre-execution safety refusal, not a product measurement (#3615). */
+export function isSafetyRefusalRun(run) {
+    return run.exitCode === 2 && /^refused:\s*/i.test(run.detail);
+}
+function safetyRefusalReason(run) {
+    return run.detail.replace(/^refused:\s*/i, "").trim();
+}
 /** Default shell runner: exact command string via platform shell. */
 export function defaultLiteralAcceptanceRunner(input) {
     // Windows: cmd.exe /c; POSIX: shell true uses sh -c. Exact string preserved.
@@ -173,6 +180,7 @@ export function runLiteralAcceptanceCommands(commands, options) {
         };
     }
     const runs = [];
+    const rejected = [];
     for (const cmd of executable) {
         if (typeof cmd.command !== "string" || cmd.command.trim().length === 0) {
             return {
@@ -181,9 +189,18 @@ export function runLiteralAcceptanceCommands(commands, options) {
                 message: "Literal acceptance-command gate config error: empty command entry (#3267)",
                 commands,
                 runs,
+                rejected: rejected.length > 0 ? rejected : undefined,
             };
         }
-        runs.push(runLiteralAcceptanceCommand(cmd, options));
+        const run = runLiteralAcceptanceCommand(cmd, options);
+        runs.push(run);
+        if (isSafetyRefusalRun(run)) {
+            rejected.push({
+                command: run.command,
+                reason: safetyRefusalReason(run),
+                sourceSpan: cmd.sourceSpan ?? null,
+            });
+        }
     }
     const failed = runs.filter((r) => !r.ok);
     if (failed.length === 0) {
@@ -213,6 +230,7 @@ export function runLiteralAcceptanceCommands(commands, options) {
             lines.join("\n"),
         commands,
         runs,
+        rejected: rejected.length > 0 ? rejected : undefined,
     };
 }
 function truncate(s, max) {

package/dist/orphan-active/candidate-scope.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Candidate diff ownership for the merge-chokepoint orphan run (#3893).
+ *
+ * The unscoped sweep enumerates every running brief under `active/`. Composed
+ * on `check:merge` that gives one stranded brief merge authority over every
+ * open PR, and N stranded briefs make N single-brief lifecycle PRs mutually
+ * unmergeable — each leaves the other orphan. The pre-merge run cannot see the
+ * residue its own candidate is about to create either: that candidate's linked
+ * PR still reads `merged_at: null` while the gate runs.
+ *
+ * Scoping the merge run to the candidate's own diff removes the coupling
+ * without touching the detector. Repo-wide truth stays enforced at the
+ * delivery tip (HEAD on the delivery line falls back to the full sweep) and
+ * after merge (`--issue N`, #3429).
+ */
+import { type GitRunner } from "../session/git.js";
+export type CandidateScope = {
+    readonly kind: "diff";
+    /** Ref the candidate was diffed against (e.g. `origin/master`). */
+    readonly baseRef: string;
+    /** Absolute, platform-normalized brief paths this candidate owns. */
+    readonly paths: ReadonlySet<string>;
+} | {
+    readonly kind: "sweep";
+    /** Why this run stayed repo-wide; always printed with the verdict. */
+    readonly reason: string;
+};
+export interface CandidateScopeOptions {
+    /** Explicit base ref; defaults to `origin/<deliveryBranch>` then the branch. */
+    readonly baseRef?: string | null;
+    readonly runGit?: GitRunner;
+}
+/**
+ * One comparable form for a git path and a readdir path.
+ *
+ * Only the directory is canonicalized: the file itself may be a deletion in
+ * the candidate diff and no longer exist on disk.
+ */
+export declare function normalizeScopePath(path: string): string;
+/**
+ * Base ref for the candidate diff: explicit override, else `origin/<branch>`,
+ * else the local delivery branch. Null when none resolves.
+ */
+export declare function resolveCandidateBaseRef(projectRoot: string, override: string | null | undefined, runGit: GitRunner): string | null;
+/**
+ * Brief paths under `activeDir` that the candidate's own diff touches.
+ *
+ * Falls back to the repo-wide sweep — never to a narrower scan — when git,
+ * the base ref, or the diff is unavailable, so the flag cannot silently
+ * shrink what a merge gate looks at.
+ */
+export declare function resolveCandidateScope(projectRoot: string, activeDir: string, options?: CandidateScopeOptions): CandidateScope;
+//# sourceMappingURL=candidate-scope.d.ts.map