@sema-agent/core 7.0.0 → 7.0.2

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

@@ -457,37 +457,47 @@ export class MemoryEngine {
                 return "unpersisted";
             }
         }
-        let outcome;
+        let raw;
         try {
-            outcome = this.captureRecords.mark(sessionId, record);
+            raw = this.captureRecords.mark(sessionId, record);
         }
         catch {
-            outcome = "unpersisted";
+            raw = "unpersisted";
         }
-        if (outcome !== "unpersisted" && !this.captureOptOutSessions.has(sessionId))
-            this.captureOptOutSessions.set(sessionId, record);
-        return outcome;
+        const settle = (outcome) => {
+            if (outcome !== "unpersisted" && !this.captureOptOutSessions.has(sessionId))
+                this.captureOptOutSessions.set(sessionId, record);
+            return outcome;
+        };
+        return raw instanceof Promise ? raw.then(settle, () => "unpersisted") : settle(raw);
     }
     sessionCaptureOptOut(sessionId) {
-        return this.sessionCaptureOptOutOrFault(sessionId).record;
+        const r = this.sessionCaptureOptOutOrFault(sessionId);
+        return r instanceof Promise ? r.then((s) => s.record) : r.record;
     }
     sessionCaptureOptOutOrFault(sessionId) {
         const inProcess = this.captureOptOutSessions.get(sessionId);
         if (inProcess !== undefined)
             return { record: inProcess, fault: false };
+        let raw;
         try {
-            const record = this.captureRecords.read(sessionId);
-            return record !== undefined ? { record, fault: false } : { fault: false };
+            raw = this.captureRecords.read(sessionId);
         }
         catch {
             return { fault: true };
         }
+        const fold = (record) => record !== undefined ? { record, fault: false } : { fault: false };
+        return raw instanceof Promise ? raw.then(fold, () => ({ fault: true })) : fold(raw);
     }
     listCaptureOptOutSessions() {
-        const out = new Set(Object.keys(this.captureRecords.list()));
-        for (const id of this.captureOptOutSessions.keys())
-            out.add(id);
-        return out;
+        const raw = this.captureRecords.list();
+        const fold = (rows) => {
+            const out = new Set(Object.keys(rows));
+            for (const id of this.captureOptOutSessions.keys())
+                out.add(id);
+            return out;
+        };
+        return raw instanceof Promise ? raw.then(fold) : fold(raw);
     }
     async sweepSessionCaptureResidue(handle) {
         const out = { swept: [], restored: [], failures: [] };
@@ -1546,7 +1556,7 @@ export class MemoryEngine {
             warnings: [],
         };
         const writeScope = handle.writeScope;
-        const captureRead = opts?.sessionId !== undefined ? this.sessionCaptureOptOutOrFault(opts.sessionId) : { fault: false };
+        const captureRead = opts?.sessionId !== undefined ? await this.sessionCaptureOptOutOrFault(opts.sessionId) : { fault: false };
         const captureOptOut = captureRead.record;
         if (writeScope === null || opts?.admitNothing !== undefined || captureOptOut !== undefined || captureRead.fault) {
             try {
@@ -2194,7 +2204,7 @@ export class MemoryEngine {
                     return report;
                 }
             }
-            const preCommitRead = lineageSessionId !== undefined ? this.sessionCaptureOptOutOrFault(lineageSessionId) : { fault: false, record: undefined };
+            const preCommitRead = lineageSessionId !== undefined ? await this.sessionCaptureOptOutOrFault(lineageSessionId) : { fault: false, record: undefined };
             if (preCommitRead.record !== undefined || preCommitRead.fault) {
                 if (lineageArmed) {
                     try {
@@ -2796,7 +2806,7 @@ export class MemoryEngine {
             return false;
         return frozenToken === undefined || held.token === frozenToken;
     }
-    consolidationEligibility(headers) {
+    async consolidationEligibility(headers) {
         let exclusions;
         try {
             exclusions = this.readChallengeExclusions();
@@ -2823,7 +2833,7 @@ export class MemoryEngine {
         }
         let optOutSessions;
         try {
-            optOutSessions = this.listCaptureOptOutSessions();
+            optOutSessions = await this.listCaptureOptOutSessions();
         }
         catch (err) {
             throw new ConsolidationRefusedError("memory.consolidation_governance_unreadable", `memory consolidation refused: the capture opt-out roster cannot be trusted (fail-closed): ${err instanceof Error ? err.message : String(err)}`);
@@ -2874,7 +2884,7 @@ export class MemoryEngine {
         }
         const face = this.committedAuditFace();
         const headers = await face.listHeaders([scope]);
-        const { eligible } = this.consolidationEligibility(headers);
+        const { eligible } = await this.consolidationEligibility(headers);
         const fingerprint = opts.full === true ? undefined : row?.fingerprint;
         const candidateIds = [];
         for (const [id, h] of eligible) {
@@ -3040,7 +3050,7 @@ export class MemoryEngine {
         const at = this.now();
         const face = this.committedAuditFace();
         const headers = await face.listHeaders([scope]);
-        const { exclusions, superseded } = this.consolidationEligibility(headers);
+        const { exclusions, superseded } = await this.consolidationEligibility(headers);
         const headerById = new Map(headers.map((h) => [h.id, h]));
         const wholeReasons = [];
         for (let i = 0; i < proposal.products.length; i++) {
@@ -3921,6 +3931,67 @@ export class MemoryEngine {
         }
         return await b.listScopes();
     }
+    async sessionMemoryStatus(sessionId) {
+        const out = {};
+        const capture = await this.sessionCaptureOptOutOrFault(sessionId);
+        if (capture.fault) {
+            out.optOutSource = "fault";
+        }
+        else if (capture.record !== undefined) {
+            out.captureOptedOut = true;
+            out.optOutSource = "record";
+        }
+        else {
+            out.captureOptedOut = false;
+        }
+        let mine;
+        try {
+            const committed = readLineageRecord(this.controlDir).committed;
+            const ids = new Set();
+            let lastAt;
+            for (const [entryId, sessions] of Object.entries(committed)) {
+                const c = sessions[sessionId];
+                if (c === undefined)
+                    continue;
+                ids.add(entryId);
+                if (lastAt === undefined || c.lastAt > lastAt)
+                    lastAt = c.lastAt;
+            }
+            mine = ids;
+            out.committedCount = ids.size;
+            if (lastAt !== undefined)
+                out.lastCaptureAt = lastAt;
+        }
+        catch {
+        }
+        if (mine !== undefined) {
+            if (mine.size === 0) {
+                out.foldedCount = 0;
+            }
+            else {
+                try {
+                    const enumeration = await this.listMemoryScopes();
+                    if (enumeration.supported) {
+                        const face = this.committedAuditFace();
+                        const headers = await face.listHeaders(enumeration.scopes);
+                        const productIds = headers.filter((h) => h.distilled !== undefined).map((h) => h.id);
+                        const folded = new Set();
+                        if (productIds.length > 0) {
+                            for (const p of await face.getByIds(productIds)) {
+                                for (const row of p.frontmatter.distilled?.inputs ?? [])
+                                    if (mine.has(row.id))
+                                        folded.add(row.id);
+                            }
+                        }
+                        out.foldedCount = folded.size;
+                    }
+                }
+                catch {
+                }
+            }
+        }
+        return out;
+    }
     committedAuditFace() {
         const b = this.backend;
         return b.restrictedAdoptionView?.({ audit: false }) ?? b.retrievalView?.() ?? this.backend;

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

@@ -1,4 +1,4 @@
-export { MemoryEngine, buildMemoryInstruction, truncateIndex, MEMORY_INSTRUCTION_TEMPLATE, MEMORY_RECALL_DISCIPLINE, memoryRecallDisciplineSegment, entryFileHeadCarriesOrigin, MEMORY_PREFERENCE_DISCIPLINE, MEMORY_READONLY_NOTICE, MEMORY_INDEX_MAX_LINES, MEMORY_INDEX_MAX_BYTES, STUB_ARCHIVED_LINE, DEFAULT_MAX_MEMORY_FILES, DEFAULT_HARVEST_DEADLINE_MS, DEFAULT_HARVEST_FILE_BUDGET, MASS_DELETION_FUSE_RATIO, renderAnnouncements, type MemoryEngineOptions, type MemoryInjection, type EntryProvenanceAccount, memoryConsolidationRecommendedNotice, memoryConsolidationCommittedNotice, memoryConsolidationConflictNotice, memoryConsolidationIncompleteNotice, memoryConsolidationRefusedNotice, memoryConsolidationWithheldNotice, MEMORY_CAPTURE_OPTOUT_NOTICE, memoryCaptureOptedOutNotice, memoryCaptureOptOutUnpersistedNotice, type ConsolidationCommitReceipt, type ConsolidationReconcileReport, type ConsolidationResolveReceipt, type ConsolidationPlanSummary, type ConsolidationPlanFoldEvidence, } from "./engine.js";
+export { MemoryEngine, buildMemoryInstruction, truncateIndex, MEMORY_INSTRUCTION_TEMPLATE, MEMORY_RECALL_DISCIPLINE, memoryRecallDisciplineSegment, entryFileHeadCarriesOrigin, MEMORY_PREFERENCE_DISCIPLINE, MEMORY_READONLY_NOTICE, MEMORY_INDEX_MAX_LINES, MEMORY_INDEX_MAX_BYTES, STUB_ARCHIVED_LINE, DEFAULT_MAX_MEMORY_FILES, DEFAULT_HARVEST_DEADLINE_MS, DEFAULT_HARVEST_FILE_BUDGET, MASS_DELETION_FUSE_RATIO, renderAnnouncements, type MemoryEngineOptions, type MemoryInjection, type EntryProvenanceAccount, memoryConsolidationRecommendedNotice, memoryConsolidationCommittedNotice, memoryConsolidationConflictNotice, memoryConsolidationIncompleteNotice, memoryConsolidationRefusedNotice, memoryConsolidationWithheldNotice, MEMORY_CAPTURE_OPTOUT_NOTICE, memoryCaptureOptedOutNotice, memoryCaptureOptOutUnpersistedNotice, type ConsolidationCommitReceipt, type ConsolidationReconcileReport, type ConsolidationResolveReceipt, type ConsolidationPlanSummary, type ConsolidationPlanFoldEvidence, type SessionMemoryStatus, } from "./engine.js";
 export { MEMORY_SEARCH_TOOL_NAME, MEMORY_GET_TOOL_NAME, MEMORY_INDEX_TOOL_NAME, MEMORY_ENGINE_TOOL_NAMES, type MemorySearchDetails, type MemorySearchHit, type CleanMemorySearchHit, type ExposedMemorySearchHit, type MemoryGetDetails, type MemoryIndexDetails, type MemoryIndexRow, type CleanMemoryIndexRow, type ExposedMemoryIndexRow, } from "./tools.js";
 export { MEMORY_EXPOSURE_BANNER, MEMORY_EXPOSURE_HANDLE_TAG, MEMORY_PROVENANCE_RECALL_SENTENCE, MEMORY_PROVENANCE_SEARCH_SENTENCE, memoryExposureIndexRow, parseMemoryExposureIndexRow, } from "./provenance-wording.js";
 export { scanMemoryWrite, scanMemoryFileName, scanRemediation, MEMORY_FILENAME_SEGMENT_RE } from "./scan.js";

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

@@ -407,11 +407,19 @@ export declare function listSessionCaptureOptOut(controlDir: string): Record<str
  * (`controlDir` + `sessionId` coordinates that outlive any live object — see the settlement handle
  * doc in prepare-task.ts), and a live store object cannot ride that lane; its migration needs its
  * own seam design and is registered here rather than half-built.
+ *
+ * DUAL FORM (#511 件2, additive): each leg may answer `T` OR `Promise<T>` — a SQL/remote carrier is
+ * async by nature and could not implement the sync-only trio at all. Every core consumption point
+ * awaits (or `.then`-chains where a sync public seat must stay sync-transparent), so a sync store's
+ * behavior is unchanged and an async store's Promise legs keep the exact same contract per leg:
+ * a rejected `mark` promise is held to the `"unpersisted"` refusal arm, a rejected `read` promise
+ * is the INDETERMINATE fault axis, a rejected `list` promise propagates as the enumeration failure.
+ * The File trio below keeps its synchronous signatures byte-identical.
  */
 export interface SessionCaptureRecordStore {
-    mark(sessionId: string, record: SessionCaptureOptOutRecord): SessionCaptureOptOutMarkOutcome;
-    read(sessionId: string): SessionCaptureOptOutRecord | undefined;
-    list(): Record<string, SessionCaptureOptOutRecord>;
+    mark(sessionId: string, record: SessionCaptureOptOutRecord): SessionCaptureOptOutMarkOutcome | Promise<SessionCaptureOptOutMarkOutcome>;
+    read(sessionId: string): SessionCaptureOptOutRecord | undefined | Promise<SessionCaptureOptOutRecord | undefined>;
+    list(): Record<string, SessionCaptureOptOutRecord> | Promise<Record<string, SessionCaptureOptOutRecord>>;
 }
 /** The core-default {@link SessionCaptureRecordStore}: the file trio over `controlDir` (single-
  *  process / single-host deployments keep today's carrier byte-identical). */

package/dist/core/roles.d.ts

@@ -22,7 +22,12 @@ export declare const CC_MODEL_TIER_ALIASES: Readonly<Record<string, string>>;
  * - an existing catalog key of the same name WINS (deployment SHADOW semantics, mirroring agents):
  *   a deployment that already ships a model literally named "pro" keeps it untouched;
  * - a binding may itself be a catalog name or a Model object (resolved through `resolveModel`);
- *   an unknown binding name throws at construction (config error surfaces at boot, not first use).
+ *   an unknown binding name throws at construction (config error surfaces at boot, not first use);
+ * - `"best"` (dynamic head-of-chain alias, CC `$L` parity) resolves to the FIRST tier in
+ *   {@link DEFAULT_TIER_ORDER} that carries a DIRECT binding — "the strongest model this deployment
+ *   actually bound", not a fixed tier — under the same SHADOW rule (a deployment catalog key named
+ *   `best` wins); with no bound known-order tier (or no tiers at all) the key stays absent and
+ *   `resolveModel("best")` refuses like any unknown ref.
  */
 /** the DISPLAY face of a string model ref: a CC tier ALIAS (haiku/sonnet/…) resolves to its
  *  sema tier name (lite/flash/…) for labels — the alias verbatim reads as a strong claim about a

package/dist/core/roles.js

@@ -3,7 +3,7 @@ export function resolveModel(ref, models) {
     if (typeof ref !== "string") {
         return ref;
     }
-    const m = models?.[ref];
+    const m = models !== undefined && Object.hasOwn(models, ref) ? models[ref] : undefined;
     if (!m) {
         throw new Error(`Unknown model ref "${ref}". Provide it in RunnerDeps.models or pass a Model object.`);
     }
@@ -59,6 +59,15 @@ export function expandTiers(models, tiers) {
         if (m)
             out[alias] = m;
     }
+    if (!out["best"]) {
+        for (const name of DEFAULT_TIER_ORDER) {
+            const m = bound(name);
+            if (m) {
+                out["best"] = m;
+                break;
+            }
+        }
+    }
     return out;
 }
 export function parseModelMention(text, allowedNames) {

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

@@ -174,8 +174,8 @@ export async function prepareMemory(input) {
             };
             const onEngineIncident = (err) => deps.onError?.(err, { phase: "memory", sessionId });
             const adoptionRestricted = input.memoryPersistenceDeclared === false;
-            const armCaptureOptOut = (eng) => {
-                const standingRead = eng.sessionCaptureOptOutOrFault(sessionId);
+            const armCaptureOptOut = async (eng) => {
+                const standingRead = await eng.sessionCaptureOptOutOrFault(sessionId);
                 if (standingRead.fault) {
                     captureIndeterminate = true;
                     deps.onError?.(new Error(`the capture opt-out record store is unreadable at prepare — this session's capture state is indeterminate, and every memory commit boundary (read-side adoption included) suppresses fail-closed until the store answers.`), { phase: "memory", sessionId });
@@ -199,7 +199,7 @@ export async function prepareMemory(input) {
                     let anyFault = standingRead.fault;
                     let found = false;
                     for (const [ancestorId, ancestorDir] of rows) {
-                        const samePlane = eng.sessionCaptureOptOutOrFault(ancestorId);
+                        const samePlane = await eng.sessionCaptureOptOutOrFault(ancestorId);
                         if (samePlane.record !== undefined) {
                             found = true;
                             break;
@@ -208,7 +208,7 @@ export async function prepareMemory(input) {
                             anyFault = true;
                         if (ancestorDir !== undefined && ancestorDir !== eng.controlPlaneDir) {
                             try {
-                                const crossPlane = deps.memoryCaptureRecordStore !== undefined ? deps.memoryCaptureRecordStore({ controlDir: ancestorDir }).read(ancestorId) : readSessionCaptureOptOut(ancestorDir, ancestorId);
+                                const crossPlane = deps.memoryCaptureRecordStore !== undefined ? await deps.memoryCaptureRecordStore({ controlDir: ancestorDir }).read(ancestorId) : readSessionCaptureOptOut(ancestorDir, ancestorId);
                                 if (crossPlane !== undefined) {
                                     found = true;
                                     break;
@@ -230,7 +230,7 @@ export async function prepareMemory(input) {
                 }
                 let forkInherited = false;
                 if (!floored && !captureDeclared && standing === undefined && input.captureForkOrigin !== undefined) {
-                    const src = eng.sessionCaptureOptOutOrFault(input.captureForkOrigin);
+                    const src = await eng.sessionCaptureOptOutOrFault(input.captureForkOrigin);
                     if (src.record !== undefined)
                         forkInherited = true;
                     else if (src.fault && !captureIndeterminate) {
@@ -246,7 +246,7 @@ export async function prepareMemory(input) {
                         throw captureOptOutDeniedError(verdict.detail);
                 }
                 if (standing === undefined) {
-                    const outcome = eng.markSessionCaptureOptOut(sessionId, captureDeclared ? `declared on TaskSpec.memory.capture` : forkInherited ? `inherited capture opt-out from the forked source session` : `inherited capture opt-out floor from the spawning session`);
+                    const outcome = await eng.markSessionCaptureOptOut(sessionId, captureDeclared ? `declared on TaskSpec.memory.capture` : forkInherited ? `inherited capture opt-out from the forked source session` : `inherited capture opt-out floor from the spawning session`);
                     if (outcome === "unpersisted") {
                         deliverEngineNotice(deps.onNotice, memoryCaptureOptOutUnpersistedNotice({ sessionId, ingress: "declaration" }));
                         throw captureOptOutUnpersistedError(sessionId, "declaration");
@@ -287,14 +287,14 @@ export async function prepareMemory(input) {
             let injectFn;
             let harvestBoth;
             let toolPlanes;
-            const admitNothingOptsNow = () => {
+            const admitNothingOptsNow = async () => {
                 if (input.memoryPersistenceDeclared === false) {
                     return { admitNothing: { reason: "harvest admitted nothing: memory persistence is declared unavailable for this session (memoryPersistenceCapable: false)" } };
                 }
                 if (captureLineageIndeterminate) {
                     return { admitNothing: { reason: `harvest admitted nothing: this session's fork-lineage metadata is unreadable — whether it continues an opted-out source cannot be established, so commits are suppressed fail-closed` } };
                 }
-                const own = captureOptedOut ? { record: { at: 0, reason: "in-run state" }, fault: false } : writeEngine.sessionCaptureOptOutOrFault(sessionId);
+                const own = captureOptedOut ? { record: { at: 0, reason: "in-run state" }, fault: false } : await writeEngine.sessionCaptureOptOutOrFault(sessionId);
                 if (own.record !== undefined) {
                     return { admitNothing: { reason: `harvest admitted nothing: this session declared memory capture opt-out (memory.capture: "off")` } };
                 }
@@ -309,11 +309,11 @@ export async function prepareMemory(input) {
                 if (input.captureForkOrigin !== undefined && !ancestors.has(input.captureForkOrigin))
                     ancestors.set(input.captureForkOrigin, undefined);
                 for (const [ancestorId, ancestorDir] of ancestors) {
-                    const samePlane = writeEngine.sessionCaptureOptOutOrFault(ancestorId);
+                    const samePlane = await writeEngine.sessionCaptureOptOutOrFault(ancestorId);
                     let crossPlane;
                     if (ancestorDir !== undefined && ancestorDir !== writeEngine.controlPlaneDir) {
                         try {
-                            crossPlane = deps.memoryCaptureRecordStore !== undefined ? deps.memoryCaptureRecordStore({ controlDir: ancestorDir }).read(ancestorId) : readSessionCaptureOptOut(ancestorDir, ancestorId);
+                            crossPlane = deps.memoryCaptureRecordStore !== undefined ? await deps.memoryCaptureRecordStore({ controlDir: ancestorDir }).read(ancestorId) : readSessionCaptureOptOut(ancestorDir, ancestorId);
                         }
                         catch {
                             return { admitNothing: { reason: `harvest admitted nothing: a spawning session's capture record store is unreadable — the floor state is indeterminate and commits are suppressed fail-closed` } };
@@ -362,7 +362,7 @@ export async function prepareMemory(input) {
                 const personal = createPersonalEngine(personalBackendChosen);
                 const personalEngine = personal.engine;
                 const p = planes;
-                armCaptureOptOut(p.writePlane === "personal" ? personalEngine : projectEngine);
+                await armCaptureOptOut(p.writePlane === "personal" ? personalEngine : projectEngine);
                 const projectHandle = await projectEngine.materialize(p.project, p.writePlane === "project" ? memorySpec.writeScope : null, { adoptionRestricted: adoptionRestricted || captureOptedOut || captureIndeterminate, sessionId });
                 materializedResidue.push(...planeScopes(p.project, p.writePlane === "project" ? memorySpec.writeScope : null));
                 const personalHandle = await personalEngine.materialize(p.personal, p.writePlane === "personal" ? memorySpec.writeScope : null, { adoptionRestricted: adoptionRestricted || captureOptedOut || captureIndeterminate, sessionId });
@@ -393,7 +393,7 @@ export async function prepareMemory(input) {
                 harvestBoth = async () => {
                     const writeFirst = writeIsPersonal ? [personalEngine, personalHandle] : [projectEngine, projectHandle];
                     const readOther = writeIsPersonal ? [projectEngine, projectHandle] : [personalEngine, personalHandle];
-                    const writeReport = await writeFirst[0].harvest(writeFirst[1], { ...pollutedOpts(writeFirst[0]), sessionId, ...admitNothingOptsNow() });
+                    const writeReport = await writeFirst[0].harvest(writeFirst[1], { ...pollutedOpts(writeFirst[0]), sessionId, ...(await admitNothingOptsNow()) });
                     let readReport;
                     let readFailure;
                     try {
@@ -411,14 +411,14 @@ export async function prepareMemory(input) {
             else if (personalOnly) {
                 const personal = createPersonalEngine(choosePersonalBackend());
                 const personalEngine = personal.engine;
-                armCaptureOptOut(personalEngine);
+                await armCaptureOptOut(personalEngine);
                 const handle = await personalEngine.materialize(memorySpec.scopes, memorySpec.writeScope, { adoptionRestricted: adoptionRestricted || captureOptedOut || captureIndeterminate, sessionId });
                 materializedResidue.push(...planeScopes(memorySpec.scopes, memorySpec.writeScope));
                 memoryMarkedEntriesServed = handle.markedEntriesPresent === true;
                 writeEngine = personalEngine;
                 writeHandle = handle;
                 injectFn = () => personalEngine.inject(handle, { writeToolMounted: input.writeToolsMounted, reminderMark: input.reminderMark });
-                harvestBoth = () => personalEngine.harvest(handle, { ...pollutedOpts(personalEngine), sessionId, ...admitNothingOptsNow() });
+                harvestBoth = async () => personalEngine.harvest(handle, { ...pollutedOpts(personalEngine), sessionId, ...(await admitNothingOptsNow()) });
                 toolPlanes = [
                     {
                         backend: retrievalBackend(personal.backend, adoptionRestricted || captureOptedOut || captureIndeterminate || memorySpec.writeScope === null),
@@ -439,14 +439,14 @@ export async function prepareMemory(input) {
                     ...captureStoreOpt(backend, identityKey !== undefined ? deriveProjectControlDir(engineRoot, identityKey) : deriveRepoControlPlaneDir(engineRoot, repoRoot)),
                     ...(input.deps.memoryConsolidation !== undefined ? { consolidation: input.deps.memoryConsolidation } : {}),
                 });
-                armCaptureOptOut(engine);
+                await armCaptureOptOut(engine);
                 const handle = await engine.materialize(memorySpec.scopes, memorySpec.writeScope, { adoptionRestricted: adoptionRestricted || captureOptedOut || captureIndeterminate, sessionId });
                 materializedResidue.push(...planeScopes(memorySpec.scopes, memorySpec.writeScope));
                 memoryMarkedEntriesServed = handle.markedEntriesPresent === true;
                 writeEngine = engine;
                 writeHandle = handle;
                 injectFn = () => engine.inject(handle, { writeToolMounted: input.writeToolsMounted, reminderMark: input.reminderMark });
-                harvestBoth = () => engine.harvest(handle, { ...pollutedOpts(engine), sessionId, ...admitNothingOptsNow() });
+                harvestBoth = async () => engine.harvest(handle, { ...pollutedOpts(engine), sessionId, ...(await admitNothingOptsNow()) });
                 toolPlanes = [
                     {
                         backend: retrievalBackend(backend, adoptionRestricted || captureOptedOut || captureIndeterminate || memorySpec.writeScope === null),
@@ -457,7 +457,7 @@ export async function prepareMemory(input) {
                     },
                 ];
             }
-            memoryWriteGateRef.current = (w) => {
+            memoryWriteGateRef.current = async (w) => {
                 if (readOnlyEngine !== undefined && readOnlyHandle !== undefined) {
                     const ro = readOnlyEngine.gateWrite(readOnlyHandle, w.key, w.content);
                     if (!ro.ok)
@@ -477,7 +477,7 @@ export async function prepareMemory(input) {
                 {
                     const root = writeHandle.writableRoot;
                     if (w.key === root || w.key.startsWith(`${root}${sep}`)) {
-                        const state = captureOptedOut ? { record: { at: 0, reason: "in-run state" }, fault: false } : writeEngine.sessionCaptureOptOutOrFault(sessionId);
+                        const state = captureOptedOut ? { record: { at: 0, reason: "in-run state" }, fault: false } : await writeEngine.sessionCaptureOptOutOrFault(sessionId);
                         if (state.record !== undefined || state.fault) {
                             return {
                                 ok: false,
@@ -555,12 +555,19 @@ export async function prepareMemory(input) {
                 inject: injectFn,
                 harvest: harvestSafe,
                 captureOptOut: {
-                    optedOut: () => captureOptedOut || writeEngine.sessionCaptureOptOutOrFault(sessionId).record !== undefined,
+                    optedOut: () => {
+                        if (captureOptedOut)
+                            return true;
+                        const r = writeEngine.sessionCaptureOptOutOrFault(sessionId);
+                        return r instanceof Promise ? r.then((s) => s.record !== undefined) : r.record !== undefined;
+                    },
                     indeterminate: () => {
                         if (captureOptedOut)
                             return false;
-                        const s = writeEngine.sessionCaptureOptOutOrFault(sessionId);
-                        return s.record === undefined && (captureIndeterminate || s.fault);
+                        const r = writeEngine.sessionCaptureOptOutOrFault(sessionId);
+                        return r instanceof Promise
+                            ? r.then((s) => s.record === undefined && (captureIndeterminate || s.fault))
+                            : r.record === undefined && (captureIndeterminate || r.fault);
                     },
                     flip: async (reason) => {
                         const entitlement = await resolveCaptureEntitlementFresh();
@@ -576,7 +583,7 @@ export async function prepareMemory(input) {
                             throw e;
                         }
                         const trimmed = reason?.trim();
-                        const outcome = writeEngine.markSessionCaptureOptOut(sessionId, trimmed !== undefined && trimmed !== "" ? `host flip verb: ${trimmed.slice(0, 200)}` : "host flip verb");
+                        const outcome = await writeEngine.markSessionCaptureOptOut(sessionId, trimmed !== undefined && trimmed !== "" ? `host flip verb: ${trimmed.slice(0, 200)}` : "host flip verb");
                         if (outcome === "unpersisted") {
                             deliverEngineNotice(deps.onNotice, memoryCaptureOptOutUnpersistedNotice({ sessionId, ingress: "flip-verb" }));
                             throw captureOptOutUnpersistedError(sessionId, "flip-verb");

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

@@ -550,8 +550,9 @@ export interface Prepared {
          * the memory session mounted.
          */
         captureOptOut?: {
-            optedOut: () => boolean;
-            indeterminate: () => boolean;
+            /** Dual form: a sync capture store answers synchronously; a Promise-form store answers a Promise. `await` is correct on either arm. */
+            optedOut: () => boolean | Promise<boolean>;
+            indeterminate: () => boolean | Promise<boolean>;
             flip: (reason?: string) => Promise<{
                 outcome: "created" | "existed";
             }>;

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

@@ -894,6 +894,15 @@ function explicitlyDeferredMemoryTrio(mounted, roster, deferNames) {
 function memoryGroupRetractionSet(builtinDeferPairNames, engineTrioInPlay) {
     return new Set([...builtinDeferPairNames, ...(engineTrioInPlay ? MEMORY_ENGINE_TOOL_NAMES : [])]);
 }
+function assembleParentCaptureState(o, i, ctl, ancestors) {
+    const build = (optedOut, indeterminate) => ({
+        optedOut: optedOut === true,
+        indeterminate: indeterminate === true,
+        ...(ctl !== undefined ? { controlDir: ctl } : {}),
+        ancestors,
+    });
+    return o instanceof Promise || i instanceof Promise ? Promise.all([o, i]).then(([ov, iv]) => build(ov, iv)) : build(o, i);
+}
 async function spliceSessionOverlayRows(overlay, sessionId, persisted, tracer, hostTaskId) {
     if (overlay === undefined)
         return persisted;
@@ -1501,10 +1510,10 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             ...(spec.envFacts !== undefined ? { envFacts: { ...spec.envFacts } } : {}),
             ...(spec.memoryPersistenceCapable !== undefined ? { memoryPersistenceCapable: spec.memoryPersistenceCapable } : {}),
             get memoryCaptureOptedOut() {
-                return memoryEngineSession?.captureOptOut?.optedOut() === true;
+                return memoryEngineSession?.captureOptOut?.optedOut() ?? false;
             },
             get memoryCaptureIndeterminate() {
-                return memoryEngineSession?.captureOptOut?.indeterminate() === true;
+                return memoryEngineSession?.captureOptOut?.indeterminate() ?? false;
             },
             get memoryCaptureControlDir() {
                 return memoryEngineSession?.engine.controlPlaneDir;
@@ -1731,12 +1740,8 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 ...(resolvedInteractionPosture !== undefined ? { parentInteractionPosture: resolvedInteractionPosture } : {}),
                 parentMemoryCaptureState: () => {
                     const ctl = memoryEngineSession?.engine.controlPlaneDir;
-                    return {
-                        optedOut: memoryEngineSession?.captureOptOut?.optedOut() === true,
-                        indeterminate: memoryEngineSession?.captureOptOut?.indeterminate() === true,
-                        ...(ctl !== undefined ? { controlDir: ctl } : {}),
-                        ancestors: [...(internals?.memoryCaptureAncestors ?? []), { sessionId, ...(ctl !== undefined ? { controlDir: ctl } : {}) }],
-                    };
+                    const co = memoryEngineSession?.captureOptOut;
+                    return assembleParentCaptureState(co?.optedOut() ?? false, co?.indeterminate() ?? false, ctl, [...(internals?.memoryCaptureAncestors ?? []), { sessionId, ...(ctl !== undefined ? { controlDir: ctl } : {}) }]);
                 },
                 autoModeReview: () => (autoModeDecider !== undefined ? { decider: autoModeDecider } : undefined),
                 workflowDepth: internals?.workflowDepth,

package/dist/core/runner/runtask.js

@@ -1410,6 +1410,7 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
                 ...(internals?.cycleSeq !== undefined ? { seq: internals.cycleSeq } : {}),
                 ...(internals?.parentTaskId !== undefined ? { parentTaskId: internals.parentTaskId } : {}),
                 ...(subagentName ? { name: subagentName } : {}),
+                model: prepared.model.id,
                 usage: { totalTokens: stats.tokens, toolUses: stats.toolCalls, durationMs: Date.now() - rs.telemetry.taskStart },
                 status: "running",
                 ...ident(),
@@ -4223,6 +4224,7 @@ export class Runner {
                     ...(internals?.cycleSeq !== undefined ? { seq: internals.cycleSeq } : {}),
                     ...(internals?.parentTaskId !== undefined ? { parentTaskId: internals.parentTaskId } : {}),
                     ...(subagentName ? { name: subagentName } : {}),
+                    model: prepared.model.id,
                     usage: { totalTokens: stats.tokens, toolUses: stats.toolCalls, durationMs: Date.now() - rs.telemetry.taskStart },
                     status: result.status === "completed" ? "completed" : "failed",
                     ...ident(),

package/dist/core/task-notification.d.ts

@@ -66,6 +66,19 @@ export interface TaskNotificationPayload {
      *  `TaskResult.errorCode` taxonomy (brain `[code]` prefixes via extractErrorCode, `limit.*`,
      *  `budget.*`, …). Engine-minted, never model text. Absent when the failure carried no code. */
     errorCode?: string;
+    /** Terminal, delegation lanes: the settling run's PROVIDER-BOUNDARY fault assertion, mirrored from
+     *  its `TaskResult.apiFailure`. Its PRESENCE is the claim — "this failure came from the transport or
+     *  the provider, not from this deployment refusing to send, a limit, or unusable model output" — and
+     *  `errorCode` beside it names WHICH terminal; the two answer different questions and neither implies
+     *  the other. Members are whatever the failing attempt stated about itself (`status` when the provider
+     *  answered with one, `requestId` when it named one), so an EMPTY object is meaningful: "provider
+     *  fault, unlabelled", which is not the same statement as absence. Absent on every non-provider
+     *  terminal, on every completed run, and on the non-delegation lanes (bash/monitor), whose failures do
+     *  not pass through a model provider at all. */
+    apiFailure?: {
+        status?: number;
+        requestId?: string;
+    };
     /** Structured exit code of a background command's terminal notification (bash lane): the process
      *  exited on its own with this code. Lets consumers branch on success/failure without parsing the
      *  summary wording. Absent when the process never exited by itself (killed / spawn-failed lanes). */
@@ -77,6 +90,13 @@ export interface TaskNotificationPayload {
      *  every other notification (a completed result is never flagged). */
     partial?: boolean;
     output_file?: string;
+    /** Whatever the settling lane knows about its own spend, JSON-rendered verbatim into one `<usage>`
+     *  tag. Deliberately untyped — the lanes report different quantities and nothing here should force
+     *  one to fabricate a figure it does not have. What IS contracted is the VOCABULARY: a name that two
+     *  lanes both publish must mean the same thing on both. The delegation lanes
+     *  (`background_agent`, its fork/revive cycles) and the workflow lane therefore agree on
+     *  `tokens`/`turns`/`costMicroUsd`/`tool_uses`/`duration_ms`; the workflow lane's fan-out counters
+     *  (`agent_count`, `agents_done`, …) and resume counters have no delegation analog and are its own. */
     usage?: unknown;
     /** CC `<diagnostics>` parity: ENGINE-MINTED teaching text for the "result is empty/unexpected —
      *  now what" moment (per-agent read route / journal coordinate / resume command). Producers must mint it