@sema-agent/core 5.60.1 → 5.62.0

package/dist/core/hooks.js

@@ -841,7 +841,7 @@ export async function runToolGate(input) {
             ? { origin: orgAskOrigin !== undefined ? `org_${orgAskOrigin}` : "policy" }
             : undefined;
         if (suspendAsk && decision.action === "ask") {
-            const suspended = await suspendAsk(req, currentInput, safety, undefined, realApprovalOf(decision), decision.action === "ask" ? decision.persistedRuleShadowed : undefined, decision.action === "ask" ? decision.decisionReason : undefined, decision.action === "ask" ? decision.probeReason : undefined, decision.action === "ask" ? decision.probeCause : undefined, decision.action === "ask" ? decision.segmentCoverage : undefined);
+            const suspended = await suspendAsk(req, currentInput, safety, undefined, realApprovalOf(decision), decision.action === "ask" ? decision.persistedRuleShadowed : undefined, decision.action === "ask" ? decision.decisionReason : undefined, decision.action === "ask" ? decision.probeReason : undefined, decision.action === "ask" ? decision.probeCause : undefined, decision.action === "ask" ? decision.segmentCoverage : undefined, decision.action === "ask" ? decision.matchedAskRule : undefined);
             if (suspended) {
                 if ("parkFailed" in suspended)
                     parkFailed = suspended.parkFailed;
@@ -860,7 +860,7 @@ export async function runToolGate(input) {
                     req.args = outcome.presentedInput;
                 }
                 if (suspendAsk && outcome.parkDeclined && parkFailed === undefined) {
-                    const suspended = await suspendAsk(req, currentInput, safety, true, realApprovalOf(decision), decision.action === "ask" ? decision.persistedRuleShadowed : undefined, decision.action === "ask" ? decision.decisionReason : undefined, decision.action === "ask" ? decision.probeReason : undefined, decision.action === "ask" ? decision.probeCause : undefined, decision.action === "ask" ? decision.segmentCoverage : undefined);
+                    const suspended = await suspendAsk(req, currentInput, safety, true, realApprovalOf(decision), decision.action === "ask" ? decision.persistedRuleShadowed : undefined, decision.action === "ask" ? decision.decisionReason : undefined, decision.action === "ask" ? decision.probeReason : undefined, decision.action === "ask" ? decision.probeCause : undefined, decision.action === "ask" ? decision.segmentCoverage : undefined, decision.action === "ask" ? decision.matchedAskRule : undefined);
                     if (suspended) {
                         if ("parkFailed" in suspended)
                             parkFailed = suspended.parkFailed;
@@ -892,7 +892,7 @@ export async function runToolGate(input) {
                 askDenyResolution = resolved.resolution;
             decision = resolved;
             if (resolved.action === "deny" && resolved.approverUnavailable === true && suspendAsk && parkFailed === undefined) {
-                const suspended = await suspendAsk(req, currentInput, safety, true, realApprovalOf(askBeforeResolve), askBeforeResolve.action === "ask" ? askBeforeResolve.persistedRuleShadowed : undefined, askBeforeResolve.action === "ask" ? askBeforeResolve.decisionReason : undefined, askBeforeResolve.action === "ask" ? askBeforeResolve.probeReason : undefined, askBeforeResolve.action === "ask" ? askBeforeResolve.probeCause : undefined, askBeforeResolve.action === "ask" ? askBeforeResolve.segmentCoverage : undefined);
+                const suspended = await suspendAsk(req, currentInput, safety, true, realApprovalOf(askBeforeResolve), askBeforeResolve.action === "ask" ? askBeforeResolve.persistedRuleShadowed : undefined, askBeforeResolve.action === "ask" ? askBeforeResolve.decisionReason : undefined, askBeforeResolve.action === "ask" ? askBeforeResolve.probeReason : undefined, askBeforeResolve.action === "ask" ? askBeforeResolve.probeCause : undefined, askBeforeResolve.action === "ask" ? askBeforeResolve.segmentCoverage : undefined, askBeforeResolve.action === "ask" ? askBeforeResolve.matchedAskRule : undefined);
                 if (suspended) {
                     if ("parkFailed" in suspended)
                         parkFailed = suspended.parkFailed;

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

@@ -56,11 +56,24 @@ export interface ConsolidationDriverRunRow {
     outcome?: ConsolidationRunStopReason;
     settledAt?: number;
     stopDetail?: string;
-    /** The minted plan's replayable half (mint ONCE per run; each cycle filters, never re-mints). */
+    /** The minted plan's replayable half (mint ONCE per run; each cycle filters, never re-mints).
+     *  design/376-C1: `mintExposure` + `servedCandidates` ride the cache — the attestation threads
+     *  onto every cycle's proposal, the roster feeds the cross-cycle invalidation predicate. Rows
+     *  cached before the fields existed replay UN-attested with no roster check (run-level fold —
+     *  exactly the treatment their whole-library prompts earned). */
     planCache?: {
         maxInputsPerProduct: number;
         products: LlmConsolidationPlanProduct[];
+        mintExposure?: "partitioned";
+        servedCandidates?: Array<{
+            id: string;
+            rev: string;
+            marked: boolean;
+        }>;
     };
+    /** design/376-C1 A-5 disclosure — marked candidates withheld from the clean arm's prompts at
+     *  mint time (present ⇔ the partition engaged over a marked library). */
+    withheldFromCleanArm?: number;
     /** The archived mint transcript's file name under {@link CONSOLIDATION_DRIVER_PLANS_DIR}. */
     planArchive?: string;
     /** COMMITTED cycles only (the store moved): a refused/fuse-blocked/zero-delta cycle row does
@@ -181,6 +194,11 @@ export interface ConsolidationRunReceipt {
         name: string;
         targets: number;
     }>;
+    /** design/376-C1 A-5 disclosure — marked candidates withheld from the clean arm's prompts
+     *  (present ⇔ the partitioned mint engaged over a marked library). A host reading a clean
+     *  product's silence about some fact key should know the current value may sit in a withheld
+     *  (marked, handle-faced) row. */
+    withheldFromCleanArm?: number;
     planArchive?: string;
     /** Advisory notices minted for this run (the `_incomplete` disclosure when not converged). */
     notices: EngineNotice[];

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

@@ -4,7 +4,7 @@ import { atomicWriteFileSync, ensureDirExists, lockedStrictUpdate, readStrictSid
 import { inlineUntrusted } from "../untrusted-text.js";
 import { CONSOLIDATION_FORCE_THROTTLE_FLOOR_MS, screenConsolidationOptions, supersessionFuseCeiling, } from "./consolidation.js";
 import { memoryConsolidationIncompleteNotice } from "./engine.js";
-import { CONSOLIDATION_DRIVE_ABORT, CONSOLIDATION_SNAPSHOT_PARKED, MEMORY_DISTILLER_CONTRACT_V1, driveConsolidationToFixpoint, isAliasModelId, llmPlanDistiller, mintLlmConsolidationPlan, } from "./distiller.js";
+import { CONSOLIDATION_DRIVE_ABORT, CONSOLIDATION_SNAPSHOT_PARKED, MEMORY_DISTILLER_CONTRACT_V1, driveConsolidationToFixpoint, isAliasModelId, llmPlanDistiller, mintExposurePartitionedPlan, mintLlmConsolidationPlan, normalizedCandidateRev, } from "./distiller.js";
 export const CONSOLIDATION_DRIVER_RUNS_FILE = "distiller-runs.json";
 export const CONSOLIDATION_DRIVER_PLANS_DIR = "distiller-plans";
 function coerceRunsFile(raw) {
@@ -71,6 +71,15 @@ class DriverMintFailure extends Error {
         this.detail = detail;
     }
 }
+class MintInvalidated extends Error {
+    detail;
+    residue;
+    constructor(detail, residue = []) {
+        super(detail);
+        this.detail = detail;
+        this.residue = residue;
+    }
+}
 const codeOf = (err) => {
     const c = err?.code;
     return typeof c === "string" ? c : undefined;
@@ -173,6 +182,7 @@ export async function runMemoryConsolidationDriver(engine, scope, opts) {
             repairs: { ...run.repairs },
             writeFailures: [...run.writeFailures],
             residue: run.residue ?? [],
+            ...(run.withheldFromCleanArm !== undefined ? { withheldFromCleanArm: run.withheldFromCleanArm } : {}),
             ...(run.planArchive !== undefined ? { planArchive: run.planArchive } : {}),
             notices,
             ...(announceFailures.length > 0 ? { announceFailures: [...announceFailures] } : {}),
@@ -187,7 +197,7 @@ export async function runMemoryConsolidationDriver(engine, scope, opts) {
         if (run.planCache === undefined) {
             let minted;
             try {
-                minted = await mintLlmConsolidationPlan({
+                minted = await mintExposurePartitionedPlan({
                     candidates,
                     chat: opts.chat,
                     model: opts.model,
@@ -230,10 +240,50 @@ export async function runMemoryConsolidationDriver(engine, scope, opts) {
                 throw new DriverMintFailure(`the mint needed structural repairs on ${dropped} of ${total} member claim(s) (${(ratio * 100).toFixed(1)}% > mintRepairBudget ${(mintRepairBudget * 100).toFixed(1)}%) — a plan repaired this much does not represent the model's intent, and committing it would fold entries the harness chose, not the model (hallucinated ${plan.minting.repairs.hallucinatedMembers}, duplicate ${plan.minting.repairs.duplicateMembers}, nonInteger ${plan.minting.repairs.nonIntegerMembers}; emptied groups ${plan.minting.repairs.emptyGroups}, oversize ${plan.minting.repairs.oversizeGroups.length})`);
             }
             run.planArchive = distillerPlanArchiveName(run.runId, run.attempt);
-            run.planCache = { maxInputsPerProduct: plan.maxInputsPerProduct, products: plan.products };
+            run.planCache = {
+                maxInputsPerProduct: plan.maxInputsPerProduct,
+                products: plan.products,
+                ...(plan.mintExposure !== undefined ? { mintExposure: plan.mintExposure } : {}),
+                ...(plan.servedCandidates !== undefined ? { servedCandidates: plan.servedCandidates } : {}),
+            };
+            if (plan.withheldFromCleanArm !== undefined)
+                run.withheldFromCleanArm = plan.withheldFromCleanArm;
             writeDriverRun(controlDir, run);
             archiveDistillerPlan(controlDir, run.runId, plan, run.attempt);
         }
+        const roster = run.planCache?.servedCandidates;
+        if (roster !== undefined && roster.length > 0) {
+            const offeredNow = new Map();
+            for (const c of candidates) {
+                if (typeof c?.entry?.id === "string")
+                    offeredNow.set(c.entry.id, { rev: normalizedCandidateRev(c.entry.rev), marked: c.marked === true });
+            }
+            let ownFold;
+            const violations = [];
+            for (const rowR of roster) {
+                const off = offeredNow.get(rowR.id);
+                if (off !== undefined) {
+                    if (off.rev !== rowR.rev)
+                        violations.push(`${rowR.id}: rev moved since the mint`);
+                    else if (off.marked !== rowR.marked)
+                        violations.push(`${rowR.id}: marked flag flipped since the mint (${String(rowR.marked)} -> ${String(off.marked)})`);
+                    continue;
+                }
+                ownFold ??= collectRunFoldEvidence(engine, scope, run.requestId);
+                if (ownFold.unreadable !== undefined)
+                    continue;
+                if (!ownFold.targets.has(rowR.id))
+                    violations.push(`${rowR.id}: left the candidate set without a fold this run's plans attest (deleted, excluded, or folded by another writer)`);
+            }
+            if (violations.length > 0) {
+                const residue = (run.planCache?.products ?? []).flatMap((p) => {
+                    const live = (p.inputIds ?? []).filter((id) => offeredNow.has(id));
+                    return live.length > 0 ? [{ name: p.name, targets: live.length }] : [];
+                });
+                delete run.planCache;
+                throw new MintInvalidated(`the mint's served-world roster failed the cross-cycle re-check (${violations.length} row(s)): ${violations.slice(0, 5).join("; ")}${violations.length > 5 ? "; …" : ""} — the cached plan is discarded; committed cycles stand and a fresh run re-mints over the current library`, residue);
+            }
+        }
         const offered = new Map();
         for (const c of candidates)
             if (typeof c?.entry?.id === "string")
@@ -304,6 +354,7 @@ export async function runMemoryConsolidationDriver(engine, scope, opts) {
             }
         }
     };
+    const cyclesSeen = [];
     let drive;
     try {
         drive = await driveConsolidationToFixpoint(engine, scope, {
@@ -315,6 +366,7 @@ export async function runMemoryConsolidationDriver(engine, scope, opts) {
             maxCycles: opts.maxCycles ?? 64,
             takeSnapshot,
             onCycle: (row) => {
+                cyclesSeen.push(row);
                 if (row.committed.products > 0 || row.committed.superseded > 0)
                     run.cyclesDone += 1;
                 run.entriesSuperseded = (run.entriesSuperseded ?? 0) + row.committed.superseded;
@@ -330,6 +382,17 @@ export async function runMemoryConsolidationDriver(engine, scope, opts) {
             announce([`memory consolidation driver run ${run.runId} for scope ${inlineUntrusted(scope, 80)} FAILED before any write: ${inlineUntrusted(err.detail, 300)}`]);
             return settle("driver_failed", undefined, err.detail);
         }
+        if (err instanceof MintInvalidated) {
+            announce([`memory consolidation driver run ${run.runId} for scope ${inlineUntrusted(scope, 80)} MINT INVALIDATED: ${inlineUntrusted(err.detail, 300)}`]);
+            if (run.residue === undefined && err.residue.length > 0)
+                run.residue = err.residue;
+            const partial = {
+                cycles: cyclesSeen,
+                productsCommitted: cyclesSeen.reduce((a, c) => a + c.committed.products, 0),
+                entriesSuperseded: cyclesSeen.reduce((a, c) => a + c.committed.superseded, 0),
+            };
+            return settle("mint_invalidated", partial, err.detail);
+        }
         throw err;
     }
     const writeResidue = run.writeFailures.map((w) => ({ name: w.key, targets: w.members }));
@@ -372,6 +435,15 @@ export async function runMemoryConsolidationDriver(engine, scope, opts) {
     }
     if (driverResidue.length > 0)
         run.residue = [...(drive.stop?.fuseBlocked ?? []), ...driverResidue];
+    const plannedAtStop = (run.planCache?.products ?? []).some((p) => (p.inputIds?.length ?? 0) > 0);
+    if (plannedAtStop) {
+        const evidence = collectRunFoldEvidence(engine, scope, run.requestId);
+        if (evidence.unreadable !== undefined) {
+            announce([
+                `memory consolidation driver run ${run.runId} for scope ${inlineUntrusted(scope, 80)}: plan ${evidence.unreadable} — one of THIS run's own cycles — answered ${evidence.unreadableState} (control-plane damage on run-owned evidence, not a transient race); the run stops non-converged with the damage disclosed, and a fresh run re-mints over the current bytes`,
+            ]);
+        }
+    }
     const stop = drive.stop;
     if (stop?.fuseBlocked !== undefined)
         return settle("fuse_residue", drive, stop.reason);

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

@@ -247,7 +247,13 @@ export interface ConsolidationGateRow {
      *  cycle token; a newer snapshot replaces it, and commit refuses a token that no longer
      *  matches). `candidates`: the served (incremental) id → rev set — the edge-target legality
      *  domain; `eligible`: the FULL eligible id → rev map at snapshot time (the next fingerprint on
-     *  completion); `marked`: any served candidate carried a committed external-origin marker. */
+     *  completion); `marked`: any served candidate carried a committed external-origin marker;
+     *  `markedIds` (additive, design/376-C1 D-1b): WHICH served candidates carried it — the
+     *  attested freeze's world-movement baseline (a candidate marked NOW but absent here turned
+     *  marked after the snapshot ⇒ the mint's clean-arm premise is stale). Absent on rows written
+     *  before the field existed: an attested freeze over such a row takes the conservative arm
+     *  (ANY currently-marked served candidate refuses stale — no baseline means no proof the mark
+     *  predates the mint, and refusing to re-mint beats guessing). */
     snapshot?: {
         token: string;
         at: number;
@@ -255,6 +261,7 @@ export interface ConsolidationGateRow {
         candidates: Record<string, string>;
         eligible: Record<string, string>;
         marked: boolean;
+        markedIds?: string[];
     };
 }
 interface ConsolidationGateFile {
@@ -326,7 +333,10 @@ export type ConsolidationIntent = {
     type?: string;
 };
 /** §1.1 — one proposed product (driver output = DATA, zero carriage authority: origin/distilled
- *  in a proposal do not exist as fields — the engine computes both at freeze). */
+ *  in a proposal do not exist as fields — the engine computes both at freeze). The design/376-C1
+ *  attestation does not breach this invariant: `mintExposure` on the PROPOSAL declares how the
+ *  prompts were composed, it carries no origin value and can never set one — the engine still
+ *  computes every origin itself (per product under attestation, run-level otherwise). */
 export interface ConsolidationProductProposal {
     name?: string;
     description?: string;
@@ -342,6 +352,25 @@ export interface ConsolidationProposal {
     scope: string;
     products: ConsolidationProductProposal[];
     intents?: ConsolidationIntent[];
+    /**
+     * design/376-C1 D-2 — the HOST-CODE attestation about prompt composition: `"partitioned"`
+     * declares that the proposal was minted under exposure-partitioned calls, i.e. every all-clean
+     * declared product's authoring chain was served NO byte of any committed-origin (marked) entry
+     * (the clean arm's grouping/writing calls saw the clean subset only — mechanical isolation,
+     * auditable from the archived transcript). The freeze folds origin PER PRODUCT only under this
+     * attestation; absent (or any other spelling — refused structurally, closed set), the freeze
+     * keeps the run-level single-value fold: any marked candidate in the served set marks EVERY
+     * product (today's safe default, and the permanent default for foreign minters).
+     *
+     * Trust plane, stated in full: this is a host-code attestation, NOT driver/model output — the
+     * drive re-assembles the proposal it commits (`{ scope, products, mintExposure }`), so model
+     * output can never populate it. Attesting falsely is a HOST defect outside the threat model,
+     * the same plane as a mis-declared `ToolSpec.contentOrigin` — and unlike most host mistakes it
+     * stays auditable after the fact: the archived clean-arm grouping prompt must contain zero
+     * marked-entry bytes, a mechanical check any reader can re-run against any plan that claims
+     * this attestation.
+     */
+    mintExposure?: "partitioned";
 }
 export type ConsolidationDirectedState = "pending" | "applied" | "satisfied" | "conflict";
 export interface ConsolidationDirectedPatch {
@@ -379,7 +408,15 @@ export interface ConsolidationPlanFile {
     /** r3-1 — the ENGINE-VISIBLE-SET fold fact this run froze under (authority = what the engine
      *  served, never the proposal's declaration). */
     visibleMarked: boolean;
+    /** The RUN-LEVEL single-value fold, when it applied (design/376-C1 D-6): present ⇔ this plan
+     *  froze UN-attested over a marked served set, and this one value rides every product. An
+     *  attested (per-product) plan omits it — each product's origin lives in its own frozen bytes
+     *  below, and a single plan-level value would misdescribe a mixed plan. */
     foldedOrigin?: MemoryEntryOrigin;
+    /** design/376-C1 D-6 — the proposal's accepted attestation, echoed for audit (informational:
+     *  apply is byte-faithful to `products` and never re-reads this; a reader that predates the
+     *  field ignores it and replays correctly, which is why the plan version does NOT bump). */
+    mintExposure?: "partitioned";
     /** Frozen products — FULL entry bytes (id/frontmatter incl. distilled + origin/body/rev). */
     products: MemoryEntry[];
     productStates: Record<string, "pending" | "applied" | "conflict">;
@@ -479,16 +516,26 @@ export declare function productAddPatch(product: MemoryEntry): NotePatch;
  *                       inputs edited mid-run) settles here TOO — committed cycles stand
  *                       (add-only, no rollback), the residue is named, and a fresh run re-mints
  *                       over the current bytes. The clean `converged` label never covers a
- *                       driver-side residue.
+ *                       driver-side residue;
+ *  - `mint_invalidated` — design/376-C1 D-1b (driver layer): the mint's served-world ROSTER
+ *                       failed the cross-cycle re-check — a served candidate moved rev, flipped
+ *                       its marked flag, or left the candidate set without a fold this run's own
+ *                       plans attest. The cached plan is discarded (its prompts were composed
+ *                       over a world that no longer stands — replaying it could publish clean
+ *                       products whose authoring chain silently absorbed the moved row's
+ *                       influence); committed cycles stand (add-only, no rollback), and the host
+ *                       re-runs to re-mint over the current bytes (immediately or next window —
+ *                       host policy).
  * Extending this set is a consumer-visible closed-set expansion (release-note duty: every
- * downstream that pinned the enumeration becomes a named party).
+ * downstream that pinned the enumeration becomes a named party — `mint_invalidated` was the
+ * design/376-C1 add, named on its release).
  *
  * The type DERIVES from the array (never `satisfies` beside it): the array exists precisely for
  * downstream enumeration, and two independent declarations would let a new union arm skip the
  * array with no compile error — the derived form makes an edit to either side a type error at
  * the other.
  */
-export declare const CONSOLIDATION_RUN_STOP_REASONS: readonly ["converged", "fuse_residue", "max_cycles", "parked", "refused", "driver_failed"];
+export declare const CONSOLIDATION_RUN_STOP_REASONS: readonly ["converged", "fuse_residue", "max_cycles", "parked", "refused", "driver_failed", "mint_invalidated"];
 /** See the doc on {@link CONSOLIDATION_RUN_STOP_REASONS} — the single source this derives from. */
 export type ConsolidationRunStopReason = (typeof CONSOLIDATION_RUN_STOP_REASONS)[number];
 export {};

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

@@ -475,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[];
 }
@@ -510,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;
 }