@sema-agent/core 5.60.1 → 5.61.0

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;
 }

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/runtask.js

@@ -50,7 +50,7 @@ import { RunnerSharedToolResultStore } from "../tool-result-store.js";
 import { formatDiagnosticsBlock } from "../lsp-diagnostics.js";
 import { checkToolPolicyProjection, constraintChainDigest, constraintChainEntryOf, isApprovalSettledBy, refuseOutOfContractDecision, screenApproverAttribution, toolPolicyNameSets } from "../tool-policy.js";
 import { defaultTaskRegistry } from "../task-registry.js";
-import { discloseDroppedPending, isDelegatedAgentTerminal, isSystemInjectionPriority, PendingSessionNotifications, renderTaskNotificationXml, SYSTEM_INJECTION_PRIORITIES, SystemInjectionQueue, taskNotificationDedupKey } from "../task-notification.js";
+import { discloseDroppedPending, isDelegatedAgentTerminal, isSystemInjectionPriority, isTerminalTaskNotification, PendingSessionNotifications, renderTaskNotificationXml, SYSTEM_INJECTION_PRIORITIES, SystemInjectionQueue, taskNotificationDedupKey } from "../task-notification.js";
 import { ToolDetachHub } from "../tool-detach.js";
 import { createPeerInboundChainRef, createPeerSelfRef } from "../../agents/peer-admission.js";
 import { workflowSizeGuidelineChangeNotice } from "../../orchestration/workflow-size-guideline.js";
@@ -78,6 +78,7 @@ function nextHumanInputSeq(key) {
 function sameAcceptedSteerInput(a, b) {
     return (a.payload === b.payload &&
         a.trusted === b.trusted &&
+        a.priority === b.priority &&
         a.actor?.id === b.actor?.id &&
         a.actor?.hostAsserted === b.actor?.hostAsserted &&
         a.actor?.issuer === b.actor?.issuer);
@@ -1829,6 +1830,11 @@ export class Runner {
                         throw steeringError(`inputId "${LEGACY_PENDING_STEER_INPUT_ID}" is reserved for a pre-queue parked steer and cannot be supplied by a caller`, "steering.invalid_content");
                     }
                 }
+                const priorityIn = options?.priority;
+                if (priorityIn !== undefined && !isSystemInjectionPriority(priorityIn)) {
+                    throw steeringError(`priority must be one of ${SYSTEM_INJECTION_PRIORITIES.join("/")} when supplied`, "steering.invalid_content");
+                }
+                const priority = priorityIn ?? "next";
                 const actorIn = options?.actor;
                 const actor = actorIn === undefined ? undefined : snapshotActorAssertion(actorIn);
                 const projected = projectHumanInput({ text, actor, source: "steer" });
@@ -1837,6 +1843,7 @@ export class Runner {
                     text,
                     trusted,
                     inputId: effectiveInputId,
+                    ...(priorityIn !== undefined ? { priority } : {}),
                     ...(actor !== undefined ? { actor } : {}),
                 };
                 let payload;
@@ -1872,7 +1879,7 @@ export class Runner {
                         throw steeringError("the task is not running");
                     payload = trusted ? formatHookFeedback(projected, h.reminderMark) : frameMidTurnUserInput(projected);
                     mintsAFrame = payload.trim().length !== 0;
-                    replay = { payload, trusted, ...(actor !== undefined ? { actor } : {}) };
+                    replay = { payload, trusted, priority, ...(actor !== undefined ? { actor } : {}) };
                     if (typeof inputId === "string") {
                         const prior = acceptedSteerInputs.get(inputId);
                         if (prior !== undefined) {
@@ -1885,9 +1892,32 @@ export class Runner {
                             return;
                         }
                     }
-                    try {
-                        await h.harness.steer(payload, { provenance: "engine-note", callerAuthored: true, parkRecord, ...(actor !== undefined ? { actor } : {}) });
+                    const injectFramed = async () => {
+                        const noteOptions = { provenance: "engine-note", callerAuthored: true, parkRecord, ...(actor !== undefined ? { actor } : {}) };
+                        if (priority === "later") {
+                            await h.harness.followUp(payload, noteOptions);
+                            noteAccepted(h);
+                            return;
+                        }
+                        const frame = await h.harness.steer(payload, { ...noteOptions, ...(priority === "now" ? { immediate: true } : {}) });
                         noteAccepted(h);
+                        if (priority === "now" && frame !== undefined && h.harness.interruptTurn(frame)) {
+                            deliverEngineNotice(this.deps.onNotice, {
+                                code: "task.turn_interrupted",
+                                message: "a caller-provenance steer with priority \"now\" interrupted the running turn: in-flight work was cut at " +
+                                    "a manufactured boundary (finished tool calls keep their real results; never-started ones settle as " +
+                                    "interrupted) and the run continues with the steer at the queue head.",
+                                detail: {
+                                    inputId: effectiveInputId,
+                                    sessionId: h.sessionId,
+                                    ...(actor?.id !== undefined ? { actorId: actor.id } : {}),
+                                    ...(spec.taskId !== undefined ? { taskId: spec.taskId } : {}),
+                                },
+                            });
+                        }
+                    };
+                    try {
+                        await injectFramed();
                         return;
                     }
                     catch (e) {
@@ -1897,8 +1927,7 @@ export class Runner {
                     const birthDeadline = Date.now() + READY_TIMEOUT_MS;
                     while (resultValue === undefined && !h.loop.ended && Date.now() < birthDeadline) {
                         try {
-                            await h.harness.steer(payload, { provenance: "engine-note", callerAuthored: true, parkRecord, ...(actor !== undefined ? { actor } : {}) });
-                            noteAccepted(h);
+                            await injectFramed();
                             return;
                         }
                         catch (e2) {
@@ -1938,9 +1967,14 @@ export class Runner {
                 if (input.source !== undefined && typeof input.source !== "string") {
                     throw notifyError("input.source must be a string when present", "notify.invalid_payload");
                 }
-                if (opts?.priority !== undefined && !isSystemInjectionPriority(opts.priority)) {
+                const priorityIn = opts?.priority;
+                if (priorityIn !== undefined && !isSystemInjectionPriority(priorityIn)) {
                     throw notifyError(`opts.priority must be one of ${SYSTEM_INJECTION_PRIORITIES.join("/")} when present`, "notify.invalid_payload");
                 }
+                const priority = priorityIn;
+                if (priority === "now") {
+                    throw notifyError('priority "now" (turn interrupt) is not a notification-lane power — it belongs to the steer face; use "next" for earliest-boundary delivery', "notify.invalid_priority");
+                }
                 const payload = {
                     task_id: input.task_id,
                     task_type: "external",
@@ -1954,7 +1988,7 @@ export class Runner {
                 if (!h || notifyRef.inject === undefined) {
                     throw notifyError("the task is not running", "notify.not_running");
                 }
-                notifyRef.inject(payload, opts);
+                notifyRef.inject(payload, priority !== undefined ? { priority } : undefined);
             },
             compact: async (opts) => {
                 if (resultValue)
@@ -2050,7 +2084,7 @@ export class Runner {
         let descendantAnchorDisclosed = false;
         const parkTaskNotification = (payload, priority) => {
             if (notificationSessionId !== undefined)
-                this.pendingSessionNotifications.pend(notificationSessionId, payload);
+                this.pendingSessionNotifications.pend(notificationSessionId, payload, priority);
             if (!isDelegatedAgentTerminal(payload))
                 return;
             const uplink = internals?.parentNotify;
@@ -2065,7 +2099,7 @@ export class Runner {
             }
             const rootAnchor = internals?.rootSessionId;
             if (rootAnchor !== undefined && rootAnchor !== notificationSessionId) {
-                this.pendingSessionNotifications.pend(rootAnchor, payload);
+                this.pendingSessionNotifications.pend(rootAnchor, payload, priority);
                 return;
             }
             if (internals?.parentSessionId !== undefined && !descendantAnchorDisclosed) {
@@ -2074,10 +2108,17 @@ export class Runner {
             }
         };
         const unsubscribeTaskNotifications = taskNotificationQueue.subscribe((item) => {
-            queue.push({ type: "task_notification", notification: item.payload, ...notificationIdent() });
+            queue.push({ type: "task_notification", notification: item.payload, priority: item.priority, ...notificationIdent() });
             if (notificationHarness && prepared.batchHaltRef.current === undefined) {
                 const xml = renderTaskNotificationXml(item.payload);
-                const deliver = notificationHarness.steer(xml, { provenance: "engine-note", enginePayload: item.payload });
+                const noteOptions = {
+                    provenance: "engine-note",
+                    enginePayload: item.payload,
+                    ...(item.payload.task_type !== "external" && isTerminalTaskNotification(item.payload) ? { capPreferred: true } : {}),
+                };
+                const deliver = item.priority === "later"
+                    ? notificationHarness.followUp(xml, noteOptions)
+                    : notificationHarness.steer(xml, { ...noteOptions, ...(item.priority === "now" ? { immediate: true } : {}) });
                 void deliver.then(() => item.onDisposition?.("queued"), () => {
                     parkTaskNotification(item.payload, item.priority);
                     item.onDisposition?.("parked");
@@ -2090,18 +2131,7 @@ export class Runner {
         });
         const upstreamTaskNotification = internals?.onTaskNotification;
         const deliveredAtTurnOpen = new Set();
-        let priorityNowDisclosed = false;
         const injectTaskNotification = (notification, opts) => {
-            if (opts?.priority === "now" && !priorityNowDisclosed) {
-                priorityNowDisclosed = true;
-                deliverEngineNotice(this.deps.onNotice, {
-                    code: "task.injection_priority_unimplemented",
-                    message: `a notification was injected with priority "now", which this engine does not implement: all injection ` +
-                        `priorities deliver at the NEXT turn boundary and none aborts the running turn. The notification is ` +
-                        `delivered — only the interrupting semantics are absent.`,
-                    detail: { priority: "now", ...(spec.taskId !== undefined ? { taskId: spec.taskId } : {}), sessionId: prepared.sessionId },
-                });
-            }
             if (deliveredAtTurnOpen.has(taskNotificationDedupKey(notification)))
                 return Promise.resolve("dropped_duplicate");
             if (!notificationLaneLive) {
@@ -2196,16 +2226,17 @@ export class Runner {
             const pendingIdle = this.pendingSessionNotifications.drain(prepared.sessionId);
             if (pendingIdle !== undefined) {
                 for (const payload of discloseDroppedPending(pendingIdle)) {
+                    const parkedPriority = pendingIdle.priorities?.get(payload);
                     deliveredAtTurnOpen.add(taskNotificationDedupKey(payload));
-                    queue.push({ type: "task_notification", notification: payload, ...ident() });
+                    queue.push({ type: "task_notification", notification: payload, ...(parkedPriority !== undefined ? { priority: parkedPriority } : {}), ...ident() });
                     void prepared.harness.nextTurn(renderTaskNotificationXml(payload), { provenance: "engine-note", enginePayload: payload }).catch(() => {
-                        this.pendingSessionNotifications.pend(prepared.sessionId, payload);
+                        this.pendingSessionNotifications.pend(prepared.sessionId, payload, parkedPriority);
                     });
                 }
             }
         }
         const loopLatch = { ended: false, userInterrupted: false };
-        onReady({ harness: prepared.harness, abortController: prepared.abortController, loop: loopLatch, reminderMark: prepared.reminderMark });
+        onReady({ harness: prepared.harness, abortController: prepared.abortController, loop: loopLatch, reminderMark: prepared.reminderMark, sessionId: prepared.sessionId });
         const stats = { turns: 0, tokens: 0, toolCalls: 0, promptTokens: 0, totalInputTokens: 0, cachedTokens: 0, cacheWriteTokens: 0, cacheWriteTokensLong: 0, outputTokens: 0, costMicroUsd: 0 };
         prepared.liveSpendRef.get = () => ({ costMicroUsd: stats.costMicroUsd, tokens: stats.tokens, turns: stats.turns, walltimeMs: Math.round(performance.now() - rs.telemetry.taskStartMonotonic) });
         if (resume &&