@sema-agent/core 5.60.0 → 5.61.0

package/dist/core/memory-engine/consolidation.js

@@ -265,6 +265,8 @@ function planShapeInvalid(raw, planId) {
     if (freezeRefused !== undefined && (!Array.isArray(freezeRefused) || !freezeRefused.every((x) => typeof x === "string"))) {
         return "malformed freezeRefusedInputIds";
     }
+    if (p["mintExposure"] !== undefined && p["mintExposure"] !== "partitioned")
+        return "malformed mintExposure echo";
     if ((p["v"] === 2) !== (freezeRefused !== undefined)) {
         return p["v"] === 2 ? "v2 plan without its freezeRefusedInputIds member" : "freezeRefusedInputIds on a v1 plan";
     }
@@ -360,4 +362,4 @@ export class ConsolidationRefusedError extends Error {
 export function productAddPatch(product) {
     return { op: "add", id: product.id, entry: product, guard: "absent" };
 }
-export const CONSOLIDATION_RUN_STOP_REASONS = ["converged", "fuse_residue", "max_cycles", "parked", "refused", "driver_failed"];
+export const CONSOLIDATION_RUN_STOP_REASONS = ["converged", "fuse_residue", "max_cycles", "parked", "refused", "driver_failed", "mint_invalidated"];

package/dist/core/memory-engine/distiller.d.ts

@@ -64,6 +64,17 @@ export declare const LLM_DISTILLER_CONTRACTS: Record<string, LlmDistillerContrac
  * archived). The shipping rule this alias exists to make auditable: a change to the product prompt
  * is a NEW `version` (pd-2, …) and must produce rig readings BEFORE it ships — the contract-hash
  * pin in the test suite reds on any silent byte drift under an unchanged version id.
+ *
+ * STANDING OBLIGATION on pd-2 (design/376-C1, ruled — mandatory, not optional): the next contract
+ * version MUST carry, as its FIRST A/B item, the root-elimination arm for the shared-grouping
+ * influence channel — the clean arm's writing pass without the grouping-authored `intent` (the
+ * template's own "(none stated)" arm) and without the `key` name fallback, which empties the one
+ * byte path an unattributed candidate has into a clean product and retires most of the D-1b guard
+ * machinery. The A/B must publish an EXPLICIT continuation verdict, one of three states — switch
+ * (root elimination ships) / hold (guard form stays, with readings) / redirect — it may not be
+ * left hanging. The exposure-partitioned topology itself deliberately did NOT bump this version
+ * (the candidate-set composition is topology, not wording; the wording axis stays single-variable
+ * for exactly this A/B).
  */
 export declare const MEMORY_DISTILLER_CONTRACT_V1: LlmDistillerContract;
 /**
@@ -223,6 +234,20 @@ export interface LlmConsolidationPlanProduct {
      *  alone, exactly as they always did (the archived-readings compatibility arm). */
     inputRevs?: Record<string, string>;
 }
+/** design/376-C1 §2.2 — one arm's mint accounting inside an exposure-partitioned plan (usage
+ *  "两臂合计+分列": the merged plan's top-level `minting` carries the totals, these rows carry the
+ *  per-arm split PLUS each arm's verbatim grouping prompt — the clean arm's prompt bytes are the
+ *  C1-G5 audit face: any reader can mechanically verify zero marked-entry bytes reached it). */
+export interface LlmConsolidationPlanArm {
+    arm: "clean" | "marked";
+    candidateCount: number;
+    calls: number;
+    promptTokens: number;
+    completionTokens: number;
+    retries: number;
+    truncations: number;
+    groupingPrompt: string;
+}
 export interface LlmConsolidationPlan {
     kind: "llm-consolidation-plan";
     contractVersion: string;
@@ -233,6 +258,27 @@ export interface LlmConsolidationPlan {
     maxInputsPerProduct: number;
     candidateCount: number;
     products: LlmConsolidationPlanProduct[];
+    /** design/376-C1 D-2 — present ⇔ this plan was minted by {@link mintExposurePartitionedPlan}
+     *  (clean/marked candidates partitioned into physically separate call chains). The DRIVE threads
+     *  this onto the committed proposal, where it is the engine's per-product-fold attestation.
+     *  Absent on every plan minted before the field existed — those replay UN-attested (run-level
+     *  fold, the safe default), which is exactly right for prompts composed over the whole library. */
+    mintExposure?: "partitioned";
+    /** design/376-C1 D-1b — the mint's served-world roster: every candidate actually RENDERED into
+     *  some arm's grouping call, with the rev and marked flag it was served at. The driver's
+     *  cross-cycle invalidation predicate compares each row against the fresh snapshot
+     *  (offered ∧ same rev ∧ same marked, or departed-with-own-fold-evidence) — any other state
+     *  means the world the prompts were composed over no longer stands. A single withheld marked
+     *  row (markedCount = 1, no marked arm) is deliberately NOT in the roster: no call ever saw it. */
+    servedCandidates?: Array<{
+        id: string;
+        rev: string;
+        marked: boolean;
+    }>;
+    /** design/376-C1 A-5 disclosure — how many marked candidates were withheld from the CLEAN arm's
+     *  prompts (= the marked candidate count when the partition engaged). Present ⇔ partitioned
+     *  mint over a library with at least one marked row. */
+    withheldFromCleanArm?: number;
     minting: {
         calls: number;
         groupingAttempts: number;
@@ -264,6 +310,10 @@ export interface LlmConsolidationPlan {
             model: string | null;
             answer: string;
         }>;
+        /** Per-arm split of a partitioned mint (see {@link LlmConsolidationPlanArm}); absent on
+         *  single-call-chain plans, INCLUDING the zero-marked degenerate of the partitioned mint
+         *  (whose bytes must stay identical to the plain mint's, modulo the attestation echo). */
+        arms?: LlmConsolidationPlanArm[];
     };
 }
 export type MintLlmConsolidationPlanResult = {
@@ -280,7 +330,7 @@ export type MintLlmConsolidationPlanResult = {
  * it answered is returned inside the plan so the run can be re-read, re-scored and disputed from
  * the archive alone.
  */
-export declare function mintLlmConsolidationPlan({ candidates, chat, model, baseUrl, maxInputsPerProduct, contract, onProgress, }: {
+export declare function mintLlmConsolidationPlan({ candidates, chat, model, baseUrl, maxInputsPerProduct, contract, onProgress, armLabel, }: {
     candidates: readonly DistillerCandidate[];
     chat: DistillerChatFn;
     /** The requested model id, recorded into the plan (audit anchor). Alias spellings refuse. */
@@ -298,7 +348,44 @@ export declare function mintLlmConsolidationPlan({ candidates, chat, model, base
         done: number;
         of: number;
     }) => void) | null;
+    /** design/376-C1 — the partitioned mint's TRANSCRIPT arm tag (`grouping.clean#1` /
+     *  `writing.marked#1:key#1` label forms). Prompt bytes are untouched — this names calls in the
+     *  archive only, and stays compatible with `planParseRepairs`' `startsWith("grouping")` phase
+     *  split and its `#N` retry grammar. Absent ⇒ the historical label forms, byte-identical. */
+    armLabel?: "clean" | "marked";
 }): Promise<MintLlmConsolidationPlanResult>;
+/** ONE rev sentinel for every face that RECORDS or RE-CHECKS a candidate's rev (the mint roster
+ *  below, the driver's cross-cycle roster re-check, the replay's offered map). The snapshot
+ *  interface is structural — a host-supplied engine can hand entries whose rev is not a string at
+ *  runtime — and the recording and re-checking sides MUST agree on the fallback, or a rev-less
+ *  candidate compares unequal to its own roster row and self-invalidates the mint it was just
+ *  served into (a paid mint discarded on its own cycle, re-minted and re-discarded forever). */
+export declare const normalizedCandidateRev: (rev: unknown) => string;
+/**
+ * design/376-C1 §2.2 — mint an EXPOSURE-PARTITIONED fold plan: candidates are bisected on the
+ * snapshot's per-candidate `marked` flag and each subset is minted through its own physically
+ * separate call chain, so no clean product's authoring chain (grouping intent included) is ever
+ * served a marked entry's bytes. This is what makes the engine's per-product fold SOUND — the
+ * attestation the plan carries (`mintExposure: "partitioned"`) is the freeze's gate, and this
+ * function is the single source the product driver and every bench adapter share.
+ *
+ *  - CLEAN arm: `mintLlmConsolidationPlan` over the clean subset — contract, templates, retries,
+ *    sampling all byte-identical to the plain mint (dl-3 恒等; only the candidate-set composition
+ *    moves, which is topology, not wording — no prompt-contract version bump, D-10/A-10).
+ *  - MARKED arm: the same contract over the marked subset, minted only at `markedCount ≥ 2`
+ *    (design C1-B): a single marked row has no group to fold and simply stays where it is — an
+ *    index handle row loses no discoverability by standing still. Withheld rows are disclosed
+ *    (`withheldFromCleanArm`) and kept OUT of the served roster (no call saw them).
+ *  - ZERO-marked degenerate: exactly ONE arm over exactly the full set with the HISTORICAL
+ *    transcript labels — byte-identical to the plain mint modulo the attestation echo and the
+ *    roster (C1-G1's identity claim).
+ *  - Either arm failing fails the WHOLE mint (one mint, one verdict; both arms' calls ride the
+ *    failure transcript). This widens nothing: under the run-level mint a hostile marked row
+ *    already sat inside the single grouping call and could fail it whole.
+ *  - Cross-arm group structure is impossible by construction: each arm's `sanitizeLlmGroups`
+ *    valid map is built over that arm's own 1..N numbering.
+ */
+export declare function mintExposurePartitionedPlan(args: Parameters<typeof mintLlmConsolidationPlan>[0]): Promise<MintLlmConsolidationPlanResult>;
 /** The distiller signature the drive consumes: `(candidates, snapshot, scope) -> proposal`.
  *  At runtime only `entry.id` is load-bearing for the replay filter — test/bench stubs that hand
  *  partial entry shapes are tolerated by the reads, the type states the engine's real snapshot.
@@ -321,6 +408,7 @@ export declare function llmPlanDistiller(plan: {
     products?: ReadonlyArray<Pick<LlmConsolidationPlanProduct, "name" | "description" | "type" | "body" | "inputIds"> & {
         inputRevs?: Record<string, string>;
     }>;
+    mintExposure?: "partitioned";
 } | undefined | null): ConsolidationDistillFn;
 export interface FuseSchedule<P> {
     schedule: "next-fit-decreasing";

package/dist/core/memory-engine/distiller.js

@@ -252,12 +252,15 @@ export function sanitizeLlmGroups(groups, { candidateIds, maxInputsPerProduct =
     }
     return { groups: clean, repairs, claimedIds: [...claimed] };
 }
-export async function mintLlmConsolidationPlan({ candidates, chat, model, baseUrl, maxInputsPerProduct = DISTILLER_DEFAULT_MAX_INPUTS_PER_PRODUCT, contract = MEMORY_DISTILLER_CONTRACT_V1, onProgress = null, }) {
+function assertMintConfig(chat, model) {
     if (typeof chat !== "function")
         throw distillerConfigRefusal("mintLlmConsolidationPlan needs a chat function (the explicit model seat) — a distiller that silently skips would publish an empty plan as a model's answer.");
     if (typeof model !== "string" || model.trim() === "" || isAliasModelId(model)) {
         throw distillerConfigRefusal(`mintLlmConsolidationPlan needs an EXPLICIT model id, got ${JSON.stringify(model)} — an alias can be re-pointed upstream and would move the run with no trace in the plan.`);
     }
+}
+export async function mintLlmConsolidationPlan({ candidates, chat, model, baseUrl, maxInputsPerProduct = DISTILLER_DEFAULT_MAX_INPUTS_PER_PRODUCT, contract = MEMORY_DISTILLER_CONTRACT_V1, onProgress = null, armLabel, }) {
+    assertMintConfig(chat, model);
     const rows = candidates.map((c, i) => ({ n: i + 1, id: c?.entry?.id, rev: c?.entry?.rev, text: renderCandidate(i + 1, c) }));
     const missingId = rows.filter((r) => typeof r.id !== "string");
     if (missingId.length > 0)
@@ -277,7 +280,7 @@ export async function mintLlmConsolidationPlan({ candidates, chat, model, baseUr
     for (let attempt = 0; attempt <= contract.retries && groups === null; attempt++) {
         groupingAttempts += 1;
         const user = attempt === 0 ? groupingUser : `${groupingUser}\n\nYour previous answer could not be read: ${lastError}. Answer with one JSON object and nothing else.`;
-        const out = await record(`grouping#${attempt + 1}`, () => chat({ system: contract.grouping.system, user, maxTokens: contract.sampling.maxTokens.grouping, temperature: contract.sampling.temperature }));
+        const out = await record(`grouping${armLabel !== undefined ? `.${armLabel}` : ""}#${attempt + 1}`, () => chat({ system: contract.grouping.system, user, maxTokens: contract.sampling.maxTokens.grouping, temperature: contract.sampling.temperature }));
         if (out.finishReason === "length") {
             lastError = "the answer was cut off at the token limit";
             continue;
@@ -312,7 +315,7 @@ export async function mintLlmConsolidationPlan({ candidates, chat, model, baseUr
         let err = null;
         for (let attempt = 0; attempt <= contract.retries && written === null; attempt++) {
             const u = attempt === 0 ? user : `${user}\n\nYour previous answer could not be read: ${err}. Answer with one JSON object and nothing else.`;
-            const out = await record(`writing#${i + 1}:${g.key}#${attempt + 1}`, () => chat({ system: contract.writing.system, user: u, maxTokens: contract.sampling.maxTokens.writing, temperature: contract.sampling.temperature }));
+            const out = await record(`writing${armLabel !== undefined ? `.${armLabel}` : ""}#${i + 1}:${g.key}#${attempt + 1}`, () => chat({ system: contract.writing.system, user: u, maxTokens: contract.sampling.maxTokens.writing, temperature: contract.sampling.temperature }));
             if (out.finishReason === "length") {
                 err = "the answer was cut off at the token limit";
                 continue;
@@ -372,17 +375,103 @@ export async function mintLlmConsolidationPlan({ candidates, chat, model, baseUr
         },
     };
 }
+export const normalizedCandidateRev = (rev) => (typeof rev === "string" ? rev : "");
+const rosterOf = (list) => list.map((c) => ({ id: c.entry.id, rev: normalizedCandidateRev(c.entry.rev), marked: c.marked === true }));
+const armUsageOf = (arm, plan, candidateCount) => ({
+    arm,
+    candidateCount,
+    calls: plan.minting.calls,
+    promptTokens: plan.minting.usage.promptTokens,
+    completionTokens: plan.minting.usage.completionTokens,
+    retries: plan.minting.parseRepairs.retries,
+    truncations: plan.minting.parseRepairs.lengthCapped.length,
+    groupingPrompt: plan.minting.prompts.grouping,
+});
+export async function mintExposurePartitionedPlan(args) {
+    assertMintConfig(args.chat, args.model);
+    const { candidates, ...rest } = args;
+    const clean = (candidates ?? []).filter((c) => c?.marked !== true);
+    const marked = (candidates ?? []).filter((c) => c?.marked === true);
+    if (marked.length === 0) {
+        const res = await mintLlmConsolidationPlan({ ...rest, candidates: clean });
+        if (!res.ok)
+            return res;
+        return { ok: true, plan: { ...res.plan, mintExposure: "partitioned", servedCandidates: rosterOf(clean) } };
+    }
+    const cleanRes = clean.length > 0 ? await mintLlmConsolidationPlan({ ...rest, candidates: clean, armLabel: "clean" }) : undefined;
+    if (cleanRes !== undefined && !cleanRes.ok) {
+        return { ok: false, reason: `clean arm: ${cleanRes.reason}`, calls: cleanRes.calls };
+    }
+    const markedRes = marked.length >= 2 ? await mintLlmConsolidationPlan({ ...rest, candidates: marked, armLabel: "marked" }) : undefined;
+    if (markedRes !== undefined && !markedRes.ok) {
+        return { ok: false, reason: `marked arm: ${markedRes.reason}`, calls: [...(cleanRes?.plan.minting.transcript ?? []), ...markedRes.calls] };
+    }
+    const arms = [
+        ...(cleanRes !== undefined ? [{ res: cleanRes.plan, tag: "clean", count: clean.length }] : []),
+        ...(markedRes !== undefined ? [{ res: markedRes.plan, tag: "marked", count: marked.length }] : []),
+    ];
+    const served = [...(cleanRes !== undefined ? clean : []), ...(markedRes !== undefined ? marked : [])];
+    const transcript = arms.flatMap((a) => a.res.minting.transcript);
+    const sumRepairs = (k) => arms.reduce((n, a) => n + a.res.minting.repairs[k], 0);
+    const anchor = arms[0]?.res;
+    return {
+        ok: true,
+        plan: {
+            kind: "llm-consolidation-plan",
+            contractVersion: anchor?.contractVersion ?? (rest.contract ?? MEMORY_DISTILLER_CONTRACT_V1).version,
+            model: rest.model,
+            ...(rest.baseUrl !== undefined ? { baseUrl: rest.baseUrl } : {}),
+            mintedAt: anchor?.mintedAt ?? new Date().toISOString(),
+            maxInputsPerProduct: anchor?.maxInputsPerProduct ?? rest.maxInputsPerProduct ?? DISTILLER_DEFAULT_MAX_INPUTS_PER_PRODUCT,
+            candidateCount: (candidates ?? []).length,
+            products: arms.flatMap((a) => a.res.products),
+            mintExposure: "partitioned",
+            servedCandidates: rosterOf(served),
+            withheldFromCleanArm: marked.length,
+            minting: {
+                calls: transcript.length,
+                groupingAttempts: arms.reduce((n, a) => n + a.res.minting.groupingAttempts, 0),
+                groupingParseRepairs: arms.reduce((n, a) => n + a.res.minting.groupingParseRepairs, 0),
+                parseRepairs: planParseRepairs({ minting: { transcript } }),
+                repairs: {
+                    hallucinatedMembers: sumRepairs("hallucinatedMembers"),
+                    duplicateMembers: sumRepairs("duplicateMembers"),
+                    emptyGroups: sumRepairs("emptyGroups"),
+                    oversizeGroups: arms.flatMap((a) => a.res.minting.repairs.oversizeGroups),
+                    nonIntegerMembers: sumRepairs("nonIntegerMembers"),
+                },
+                writeFailures: arms.flatMap((a) => a.res.minting.writeFailures),
+                usage: {
+                    promptTokens: arms.reduce((n, a) => n + a.res.minting.usage.promptTokens, 0),
+                    completionTokens: arms.reduce((n, a) => n + a.res.minting.usage.completionTokens, 0),
+                },
+                prompts: {
+                    grouping: anchor?.minting.prompts.grouping ?? "",
+                    writingTemplate: (rest.contract ?? MEMORY_DISTILLER_CONTRACT_V1).writing.instructions,
+                    systems: {
+                        grouping: (rest.contract ?? MEMORY_DISTILLER_CONTRACT_V1).grouping.system,
+                        writing: (rest.contract ?? MEMORY_DISTILLER_CONTRACT_V1).writing.system,
+                    },
+                },
+                transcript,
+                ...(arms.length > 0 ? { arms: arms.map((a) => armUsageOf(a.tag, a.res, a.count)) } : {}),
+            },
+        },
+    };
+}
 export function llmPlanDistiller(plan) {
     const products = plan?.products ?? [];
+    const mintExposure = plan?.mintExposure === "partitioned" ? "partitioned" : undefined;
     return (candidates, _snapshot, scope) => {
         const offered = new Map();
         for (const x of (candidates ?? [])) {
             const id = x?.entry?.id ?? x?.id;
             if (typeof id === "string")
-                offered.set(id, typeof x?.entry?.rev === "string" ? x.entry.rev : undefined);
+                offered.set(id, normalizedCandidateRev(x?.entry?.rev));
         }
         return {
             scope,
+            ...(mintExposure !== undefined ? { mintExposure } : {}),
             products: products.map((p) => {
                 const ids = p.inputIds ?? [];
                 const live = ids.filter((id) => offered.has(id));
@@ -527,7 +616,7 @@ export async function driveConsolidationToFixpoint(engine, scope, opts) {
         let receipt;
         let commitError = null;
         try {
-            receipt = await engine.commitConsolidationPlan(snapshot.cycleToken, { scope, products: plan.picked }, { requestId: `${requestIdPrefix}-c${cycle}` });
+            receipt = await engine.commitConsolidationPlan(snapshot.cycleToken, { scope, products: plan.picked, ...(proposal.mintExposure !== undefined ? { mintExposure: proposal.mintExposure } : {}) }, { requestId: `${requestIdPrefix}-c${cycle}` });
         }
         catch (err) {
             commitError = err;

package/dist/core/memory-engine/engine.d.ts

@@ -406,12 +406,11 @@ export declare function memorySessionPollutedNotice(input: {
  * arithmetic would report a clean containment while a known failure sat in the report. Every
  * not-moved file does have an escalation row, so `escalated` is the superset and the honest clause.
  *
- * KNOWN GAP (adversarial-review round 1, P2 — registered, not closed here): the derived index is
- * contained by a different path (`restorePollutedIndex` captures and restores `MEMORY.md`) that mints
- * no rejection row, so a polluted session whose ONLY memory change was an index line produces no
- * `count` and no notice — its containment is disclosed by the harvest report's warnings alone. Closing
- * it needs a structured containment signal on `HarvestReport`, a public type this fix does not touch.
- * The wording therefore says "entry file(s)" rather than implying the whole containment.
+ * The derived index is contained by a different path (`restorePollutedIndex` captures and restores
+ * `MEMORY.md`) that mints no rejection row; that gap was CLOSED by the structured containment signal
+ * on `HarvestReport.containment` (indexRolledBack — see the containment block below), so an
+ * index-only polluted session now signals and notices instead of hiding in warnings prose. The
+ * wording says "entry file(s)" because index containment reports through its own signal.
  *
  * `reason` is optional because the mark record is read separately from the report: a record that cannot
  * be read must not turn a true "N files were withheld" into a lie about why.
@@ -476,6 +475,10 @@ export interface ConsolidationCommitReceipt {
         settled: string[];
         pending: string[];
     };
+    /** True ⇔ the RUN-LEVEL single-value fold applied to this plan (design/376-C1 D-6: an
+     *  un-attested freeze over a marked served set). An attested (exposure-partitioned) plan
+     *  answers false here even when some of its products carry origin — per-product outcomes live
+     *  in the plan summary's `markedProducts` and in each product's own committed bytes. */
     foldedOrigin: boolean;
     notices: EngineNotice[];
 }
@@ -511,6 +514,10 @@ export interface ConsolidationPlanSummary {
     state?: ConsolidationPlanFile["state"];
     createdAt?: number;
     products?: number;
+    /** design/376-C1 D-6 (additive) — how many of the plan's frozen products carry an origin marker
+     *  in their own bytes. Counts BOTH fold forms truthfully: a run-level plan's single value rides
+     *  every product, an attested plan marks exactly the products whose declared inputs were marked. */
+    markedProducts?: number;
     directed?: number;
     intents?: number;
 }

package/dist/core/memory-engine/engine.js

@@ -2596,7 +2596,7 @@ export class MemoryEngine {
             if (fresh.epoch !== epoch) {
                 throw new ConsolidationRefusedError("memory.consolidation_stale_snapshot", `memory consolidation refused: the ${JSON.stringify(scope)} watermark advanced during the snapshot read — retake the snapshot.`);
             }
-            fresh.snapshot = { token: cycleToken, at, epoch, candidates: candidateRevs, eligible: eligibleRevs, marked };
+            fresh.snapshot = { token: cycleToken, at, epoch, candidates: candidateRevs, eligible: eligibleRevs, marked, markedIds: candidates.filter((c) => c.marked).map((c) => c.entry.id) };
             let announce = false;
             if (opts.force !== undefined && fresh.lastForcedRequestId !== opts.force.requestId) {
                 fresh.lastForcedRequestId = opts.force.requestId;
@@ -2656,6 +2656,9 @@ export class MemoryEngine {
             else if (p.inputs.length > screened.maxInputsPerProduct)
                 reasons.push(`product #${i}: ${p.inputs.length} inputs > maxInputsPerProduct ${screened.maxInputsPerProduct}`);
         }
+        if (proposal.mintExposure !== undefined && proposal.mintExposure !== "partitioned") {
+            reasons.push(`mintExposure ${JSON.stringify(proposal.mintExposure)} is not a member of the closed attestation set {"partitioned"} — omit it (run-level fold) or spell it exactly`);
+        }
         if (proposal.products.length === 0 && intents.length === 0) {
             reasons.push("empty plan: zero products and zero directed intents — a plan with nothing to apply must not settle as a completed run (the vacuous completion would stamp the eligible set into the fingerprint and blind the incremental face)");
         }
@@ -2741,19 +2744,43 @@ export class MemoryEngine {
         }
         const activeSetSize = headers.filter((h) => !superseded.has(h.id) && !exclusions.has(h.id)).length;
         const ceiling = supersessionFuseCeiling(activeSetSize, screened);
+        const attested = proposal.mintExposure === "partitioned";
+        if (attested) {
+            const staleAxes = [];
+            const baseline = snapshot.markedIds !== undefined ? new Set(snapshot.markedIds) : undefined;
+            for (const [id, rev] of Object.entries(snapshot.candidates)) {
+                const h = headerById.get(id);
+                if (h === undefined)
+                    staleAxes.push(`served candidate ${id} left the committed listing`);
+                else if (h.rev !== rev)
+                    staleAxes.push(`served candidate ${id} moved rev since the snapshot`);
+                else if (exclusions.has(id))
+                    staleAxes.push(`served candidate ${id} entered the challenge/latch exclusion set`);
+                else if (h.exposure !== undefined && (baseline === undefined || !baseline.has(id))) {
+                    staleAxes.push(baseline === undefined
+                        ? `served candidate ${id} is marked and the snapshot row predates the markedIds baseline — no proof the mark predates the mint (conservative arm)`
+                        : `served candidate ${id} turned marked since the snapshot`);
+                }
+            }
+            if (staleAxes.length > 0) {
+                throw new ConsolidationRefusedError("memory.consolidation_stale_snapshot", `memory consolidation refused: the attested (exposure-partitioned) mint's clean-arm premise is stale — the ${JSON.stringify(scope)} world moved between snapshot and freeze; retake the snapshot and re-mint`, staleAxes);
+            }
+        }
         let visibleMarked = snapshot.marked;
-        if (!visibleMarked) {
+        if (!attested && !visibleMarked) {
             const inputIds = [...new Set(proposal.products.flatMap((p) => p.inputs.map((i2) => i2.id)))];
             const committedInputs = await face.getByIds(inputIds);
             visibleMarked = committedInputs.some((e) => committedOriginOf(e.frontmatter) !== undefined);
         }
-        const foldedOrigin = visibleMarked ? { taint: "external", cause: "derived", at } : undefined;
+        const foldedOrigin = !attested && visibleMarked ? { taint: "external", cause: "derived", at } : undefined;
+        const productMarked = (p) => p.inputs.some((i2) => headerById.get(i2.id)?.exposure !== undefined);
         for (let i = 0; i < proposal.products.length; i++) {
             const p = proposal.products[i];
             if (!isInstructionEntry({ ...(p.type !== undefined ? { type: p.type } : {}) }))
                 continue;
-            if (visibleMarked) {
-                wholeReasons.push(`product #${i}: instruction-form product (type ${JSON.stringify(p.type)}) refused — the run's visible set contains marked content (the laundering hard gate, G7/G26; no option opens this arm)`);
+            const hardArm = attested ? productMarked(p) : visibleMarked;
+            if (hardArm) {
+                wholeReasons.push(`product #${i}: instruction-form product (type ${JSON.stringify(p.type)}) refused — ${attested ? "the product's declared inputs contain marked content" : "the run's visible set contains marked content"} (the laundering hard gate, G7/G26; no option opens this arm)`);
             }
             else if (!screened.allowInstructionProducts) {
                 wholeReasons.push(`product #${i}: instruction-form product (type ${JSON.stringify(p.type)}) refused — instruction-form consolidation products are refused unconditionally by default (a consolidation must not mint privileged entries out of ordinary notes); the host escape hatch is consolidation.allowInstructionProducts: true`);
@@ -2784,6 +2811,7 @@ export class MemoryEngine {
             }
             const id = uuidv7();
             const slug = deriveProductSlug(p.name, `consolidated-${id.slice(0, 8)}`);
+            const productOrigin = attested ? (productMarked(p) ? { taint: "external", cause: "derived", at } : undefined) : foldedOrigin;
             const entry = {
                 id,
                 slug,
@@ -2792,7 +2820,7 @@ export class MemoryEngine {
                     name: p.name ?? slug,
                     ...(p.description !== undefined ? { description: p.description } : {}),
                     ...(p.type !== undefined ? { type: p.type } : {}),
-                    ...(foldedOrigin !== undefined ? { origin: { ...foldedOrigin } } : {}),
+                    ...(productOrigin !== undefined ? { origin: { ...productOrigin } } : {}),
                     distilled: {
                         planId,
                         at,
@@ -2917,6 +2945,7 @@ export class MemoryEngine {
             epoch: snapshot.epoch,
             visibleMarked,
             ...(foldedOrigin !== undefined ? { foldedOrigin } : {}),
+            ...(attested ? { mintExposure: "partitioned" } : {}),
             products: assembled,
             productStates: Object.fromEntries(assembled.map((e) => [e.id, "pending"])),
             ...(freezeRefusedInputIds.length > 0 ? { freezeRefusedInputIds } : {}),
@@ -2924,7 +2953,21 @@ export class MemoryEngine {
             intents: intents.map((it) => ({ requestId: it.requestId, state: "pending" })),
             state: "open",
             audit: [
-                { at, event: "frozen", requestId: input.requestId, ...(refusedProducts.length > 0 ? { detail: `${refusedProducts.length} product(s) refused at freeze: ${refusedProducts.map((r) => `#${r.index}: ${r.reason}`).join(" | ")}` } : {}) },
+                {
+                    at,
+                    event: "frozen",
+                    requestId: input.requestId,
+                    ...((() => {
+                        const parts = [];
+                        if (attested) {
+                            const markedProducts = assembled.filter((e) => e.frontmatter.origin !== undefined).length;
+                            parts.push(`attested exposure-partitioned mint: ${markedProducts} marked / ${assembled.length - markedProducts} clean product(s)`);
+                        }
+                        if (refusedProducts.length > 0)
+                            parts.push(`${refusedProducts.length} product(s) refused at freeze: ${refusedProducts.map((r) => `#${r.index}: ${r.reason}`).join(" | ")}`);
+                        return parts.length > 0 ? { detail: parts.join("; ") } : {};
+                    })()),
+                },
             ],
         };
         writeConsolidationPlan(this.controlDir, plan);
@@ -3492,7 +3535,7 @@ export class MemoryEngine {
             if (read.state === "absent")
                 continue;
             const p = read.plan;
-            out.push({ planId, scope: p.scope, state: p.state, createdAt: p.createdAt, products: p.products.length, directed: p.directed.length, intents: p.intents.length });
+            out.push({ planId, scope: p.scope, state: p.state, createdAt: p.createdAt, products: p.products.length, markedProducts: p.products.filter((e) => e.frontmatter?.origin !== undefined).length, directed: p.directed.length, intents: p.intents.length });
         }
         return out;
     }

package/dist/core/memory-engine/index.d.ts

@@ -9,7 +9,7 @@ export { readV2HeaderHints, isInstructionEntry, type V2HeaderHints } from "./hea
 export { parseEntryFile, serializeEntryFile, computeEntryRev, entryFromFile, committedOriginOf, originEquals, ambiguousOriginRepresentation, type ParsedEntryFile } from "./frontmatter.js";
 export { committedDistilledOf, distilledEquals } from "./frontmatter.js";
 export { CONSOLIDATION_DEFAULTS, ConsolidationRefusedError, MEMORY_SEARCH_SUPERSEDED_TAG, consolidationTypeEligible, deriveSupersededSet, memorySupersededNote, readIntentCredentials, supersessionFuseCeiling, type ConsolidationGateRead, type ConsolidationGateRow, type ConsolidationIntent, type ConsolidationIntentCredentialRow, type ConsolidationLeaseSeat, type ConsolidationProductProposal, type ConsolidationProposal, type MemoryConsolidationOptions, CONSOLIDATION_RUN_STOP_REASONS, type ConsolidationRunStopReason, } from "./consolidation.js";
-export { DISTILLER_DEFAULT_MAX_INPUTS_PER_PRODUCT, LLM_DISTILLER_CONTRACT, LLM_DISTILLER_CONTRACT_DL2, LLM_DISTILLER_CONTRACT_DL3, LLM_DISTILLER_CONTRACTS, MEMORY_DISTILLER_CONTRACT_V1, contractGroupingDiff, driveConsolidationToFixpoint, isAliasModelId, llmPlanDistiller, mintLlmConsolidationPlan, openAiCompatChatSeat, parseJsonAnswer, planParseRepairs, sanitizeLlmGroups, scheduleUnderFuse, type ConsolidationDistillFn, type ConsolidationDriveCycleRow, type ConsolidationDriveEngine, type ConsolidationDriveResult, type ConsolidationFoldState, type DistillerCandidate, type DistillerChatAnswer, type DistillerChatFn, type DistillerChatRequest, type FuseSchedule, type LlmConsolidationPlan, type LlmConsolidationPlanProduct, type LlmDistillerContract, type MintLlmConsolidationPlanResult, type PlanParseRepairs, type SanitizedLlmGroups, } from "./distiller.js";
+export { DISTILLER_DEFAULT_MAX_INPUTS_PER_PRODUCT, LLM_DISTILLER_CONTRACT, LLM_DISTILLER_CONTRACT_DL2, LLM_DISTILLER_CONTRACT_DL3, LLM_DISTILLER_CONTRACTS, MEMORY_DISTILLER_CONTRACT_V1, contractGroupingDiff, driveConsolidationToFixpoint, isAliasModelId, llmPlanDistiller, mintExposurePartitionedPlan, mintLlmConsolidationPlan, openAiCompatChatSeat, parseJsonAnswer, planParseRepairs, sanitizeLlmGroups, scheduleUnderFuse, type ConsolidationDistillFn, type ConsolidationDriveCycleRow, type ConsolidationDriveEngine, type ConsolidationDriveResult, type ConsolidationFoldState, type DistillerCandidate, type DistillerChatAnswer, type DistillerChatFn, type DistillerChatRequest, type FuseSchedule, type LlmConsolidationPlan, type LlmConsolidationPlanArm, type LlmConsolidationPlanProduct, type LlmDistillerContract, type MintLlmConsolidationPlanResult, type PlanParseRepairs, type SanitizedLlmGroups, } from "./distiller.js";
 export { CONSOLIDATION_DRIVER_PLANS_DIR, CONSOLIDATION_DRIVER_RUNS_FILE, archiveDistillerPlan, readConsolidationDriverRun, runMemoryConsolidationDriver, type ConsolidationDriverEngine, type ConsolidationDriverRunRow, type ConsolidationRunReceipt, type RunMemoryConsolidationOptions, } from "./consolidation-driver.js";
 export type { OriginClearanceRow, OriginClearanceEvent } from "./origin-clearance.js";
 export { MEMORY_ORIGIN_CAUSES } from "./types.js";

package/dist/core/memory-engine/index.js

@@ -9,7 +9,7 @@ export { readV2HeaderHints, isInstructionEntry } from "./header-hints.js";
 export { parseEntryFile, serializeEntryFile, computeEntryRev, entryFromFile, committedOriginOf, originEquals, ambiguousOriginRepresentation } from "./frontmatter.js";
 export { committedDistilledOf, distilledEquals } from "./frontmatter.js";
 export { CONSOLIDATION_DEFAULTS, ConsolidationRefusedError, MEMORY_SEARCH_SUPERSEDED_TAG, consolidationTypeEligible, deriveSupersededSet, memorySupersededNote, readIntentCredentials, supersessionFuseCeiling, CONSOLIDATION_RUN_STOP_REASONS, } from "./consolidation.js";
-export { DISTILLER_DEFAULT_MAX_INPUTS_PER_PRODUCT, LLM_DISTILLER_CONTRACT, LLM_DISTILLER_CONTRACT_DL2, LLM_DISTILLER_CONTRACT_DL3, LLM_DISTILLER_CONTRACTS, MEMORY_DISTILLER_CONTRACT_V1, contractGroupingDiff, driveConsolidationToFixpoint, isAliasModelId, llmPlanDistiller, mintLlmConsolidationPlan, openAiCompatChatSeat, parseJsonAnswer, planParseRepairs, sanitizeLlmGroups, scheduleUnderFuse, } from "./distiller.js";
+export { DISTILLER_DEFAULT_MAX_INPUTS_PER_PRODUCT, LLM_DISTILLER_CONTRACT, LLM_DISTILLER_CONTRACT_DL2, LLM_DISTILLER_CONTRACT_DL3, LLM_DISTILLER_CONTRACTS, MEMORY_DISTILLER_CONTRACT_V1, contractGroupingDiff, driveConsolidationToFixpoint, isAliasModelId, llmPlanDistiller, mintExposurePartitionedPlan, mintLlmConsolidationPlan, openAiCompatChatSeat, parseJsonAnswer, planParseRepairs, sanitizeLlmGroups, scheduleUnderFuse, } from "./distiller.js";
 export { CONSOLIDATION_DRIVER_PLANS_DIR, CONSOLIDATION_DRIVER_RUNS_FILE, archiveDistillerPlan, readConsolidationDriverRun, runMemoryConsolidationDriver, } from "./consolidation-driver.js";
 export { MEMORY_ORIGIN_CAUSES } from "./types.js";
 export { memoryBackendContract, assertMemoryBackendSearchEquivalence, } from "./memory-backend-contract.js";

package/dist/core/runner/prepare-task.d.ts

@@ -1490,9 +1490,12 @@ export interface RunInternals {
      *  `TaskStream.detach(toolCallId)`; the hands Bash tool threads `signalFor(toolCallId)` into env.exec. */
     detachHub?: import("../tool-detach.js").ToolDetachHub;
     onTaskNotification?: (notification: TaskNotificationPayload, 
-    /** CC injection priority (design/116 §7, re-anchored 2026-08-05): every priority delivers at
-     *  the next turn boundary (arrival order, consecutive frames batch); "later" (default) vs
-     *  "next" now differs only on the park/uplink forwarding path. */
+    /** Injection tier (design/373 — the ladder is LIVE): "next" = the running turn's next boundary
+     *  (arrival order, consecutive frames batch); "later" = the run's would-otherwise-stop seat
+     *  (never folded into work in progress); "now" = class-head + earliest natural boundary on this
+     *  lane (interrupt authority belongs to the steer face, never to notifications). Internal
+     *  producers declare their tier explicitly (§3.7 census — completion-class lanes are "next");
+     *  the parameterless default "later" serves the external verb's omitting callers only. */
     opts?: {
         priority?: import("../task-notification.js").SystemInjectionPriority;
     }) => void;

package/dist/core/runner/prepare-task.js

@@ -3965,6 +3965,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         : undefined,
                     resourceLedger: resourceLedgerOut,
                     ...(spec.durableApproval !== undefined ? { durableApproval: { ...spec.durableApproval } } : {}),
+                    ...(spec.principal ? { principal: spec.principal } : {}),
                 };
                 if (!(await commitSuspendSaga(token, cp, suspendableEnv, remoteHandle)).ok)
                     return false;