@sema-agent/core 7.0.1 → 7.0.2

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 7.0.2 — 2026-08-30
+
+### Added
+- **`MemoryEngine.sessionMemoryStatus(sessionId)`** (#511①, design/383 §S-7 — the signed-design read face missed at build): `{captureOptedOut?, committedCount?, foldedCount?, optOutSource?, lastCaptureAt?}`. Every key optional — absence means that fact's source was unreadable, never a coined false/0 stand-in; a store fault answers `optOutSource:"fault"` with `captureOptedOut` ABSENT (the indeterminate axis projected); `foldedCount` counts evidence-only input rows over the full product blocks; the face never throws. New exported type `SessionMemoryStatus` (export surface 1841→1842). Server projects the wire endpoint as a pure derivation ([5786]).
+- **`SessionCaptureRecordStore` dual form** (#511②): the three legs widen to `T | Promise<T>` — a SQL/async backend plugs in with Promise signatures while every existing sync implementation compiles untouched (the additive mechanical proof). The dual form propagates: sync deployments stay sync-transparent end to end; the sync-facing public seats (`MemoryEngineSession.captureOptOut.*`, `ToolExecuteContext.memoryCaptureOptedOut/…Indeterminate`, `parentMemoryCaptureState`) go dual with the await law documented — per-leg failure mapping preserved (mark rejection ⇒ unpersisted, read rejection ⇒ the indeterminate fault axis).
+- **`best` model alias** (#511③, CC 250 $L parity): with `RunnerDeps.tiers` configured, `"best"` resolves to the first DIRECTLY bound tier walking `ultra→max→pro→flash→lite` from the head ("best available", deliberately not a fixed alias-table row). Explicit spellings win over the dynamic walk: a deployment catalog key named `best`, or an explicit `tiers.best` binding. No tiers ⇒ the word stays an unknown ref (refused, never coined).
+
+### Changed — narrowing (named)
+- **Agent tool `model` argument: non-string values on the schema-外 direct-call lane refuse typed** (#511④, test [5781] codex observation): a number/array/boolean/garbage-object now refuses `model.invalid` (closed-set ADDITION beside `model.empty`/`model.unknown` — downstream pinning the details.error set gains a row) instead of crashing or silently no-oping; a legal Model-shape object (string id+api) passes through as the per-call model; strings keep every existing arm byte-identical.
+- **`modelNote` fork-ignored and roster-less arms defuse the model-authored word** (#511⑤, census P2): both arms now run the same `inlineUntrusted` fold (newline fold + fence/envelope-tag neutralization + 80 cap) the family's other three arms already ran — a hostile `model` word can no longer carry raw newlines or fence sentinels into a top-level report line. Clean short words render byte-identical.
+
 ## 7.0.1 — 2026-08-30
 
 ### Added

package/dist/agents/subagent.js

@@ -1590,6 +1590,19 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                     };
                 }
             }
+            const modelObjectForm = typeof a.model === "object" &&
+                a.model !== null &&
+                !Array.isArray(a.model) &&
+                typeof a.model.id === "string" &&
+                typeof a.model.api === "string";
+            if (a.model !== undefined && typeof a.model !== "string" && !modelObjectForm) {
+                const typeDesc = Array.isArray(a.model) ? "an array" : a.model === null ? "null" : typeof a.model === "object" ? "an object" : `a ${typeof a.model}`;
+                return {
+                    isError: true,
+                    content: `Sub-agent not started: \`model\` must be a model name (string) from this deployment's catalog — got ${typeDesc}. Omit the parameter to run the agent type's own model.`,
+                    details: { error: "model.invalid" },
+                };
+            }
             if (typeof a.model === "string" && a.model.trim() === "" && !wantsFork && reviveClaim === undefined) {
                 return {
                     isError: true,
@@ -1602,6 +1615,14 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
             let modelNote;
             const judgedModels = activeModels();
             const rosterKeys = judgedModels !== undefined ? Object.keys(judgedModels) : [];
+            if (modelObjectForm) {
+                if (wantsFork) {
+                    modelNote = `note: model "${inlineUntrusted(a.model.id, 80)}" was ignored — a fork always runs on the caller's model.`;
+                }
+                else {
+                    perCallModel = a.model;
+                }
+            }
             if (typeof a.model === "string" && requestedModel === undefined) {
                 modelNote = wantsFork
                     ? `note: model "" was ignored — a fork always runs on the caller's model.`
@@ -1609,10 +1630,10 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
             }
             else if (requestedModel !== undefined) {
                 if (wantsFork) {
-                    modelNote = `note: model "${requestedModel}" was ignored — a fork always runs on the caller's model.`;
+                    modelNote = `note: model "${inlineUntrusted(requestedModel, 80)}" was ignored — a fork always runs on the caller's model.`;
                 }
                 else if (rosterKeys.length === 0) {
-                    modelNote = `note: model "${requestedModel}" was NOT applied — this delegation tool has no model roster configured; the sub-agent ran on its default (inherited) model.`;
+                    modelNote = `note: model "${inlineUntrusted(requestedModel, 80)}" was NOT applied — this delegation tool has no model roster configured; the sub-agent ran on its default (inherited) model.`;
                 }
                 else {
                     try {
@@ -1783,7 +1804,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                     }
                 })()
                 : childModel?.id;
-            const rowModelKey = perCallModel !== undefined ? requestedModel : typeof childModel === "string" ? childModel : childModel?.id;
+            const rowModelKey = perCallModel !== undefined ? requestedModel ?? perCallModel.id : typeof childModel === "string" ? childModel : childModel?.id;
             const childSystemPrompt = def?.systemPrompt ?? opts.systemPrompt;
             const childDefaultPersona = childSystemPrompt === undefined && !wantsFork ? SUBAGENT_PROMPT : undefined;
             const defMaxTurns = typeof def?.maxTurns === "number" && Number.isFinite(def.maxTurns) && def.maxTurns > 0 ? def.maxTurns : undefined;
@@ -2027,6 +2048,9 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
             const provenanceRequest = ctx.delegationProvenanceForChildren?.();
             const childProvenanceRef = provenanceRequest !== undefined ? { current: newDelegationProvenanceAggregate() } : undefined;
             const childAttestation = (status) => childProvenanceRef !== undefined ? reduceDelegationAttestation(childProvenanceRef.current, { completed: status === "completed" }) : undefined;
+            const liveCaptureFloor = reviveClaim === undefined
+                ? { optedOut: (await ctx.memoryCaptureOptedOut) === true, indeterminate: (await ctx.memoryCaptureIndeterminate) === true }
+                : undefined;
             const childInternals = {
                 ...(inheritedManifestScope ? { inheritedManifestScope } : {}),
                 ...(childProvenanceRef !== undefined && provenanceRequest !== undefined ? { delegationProvenance: { ref: childProvenanceRef, contentSafety: provenanceRequest } } : {}),
@@ -2045,8 +2069,8 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                 ...(ctx.interactionPosture !== undefined ? { parentInteractionPosture: ctx.interactionPosture } : {}),
                 ...(reviveClaim === undefined
                     ? {
-                        ...(ctx.memoryCaptureOptedOut === true ? { memoryCaptureFloor: true } : {}),
-                        ...(ctx.memoryCaptureOptedOut !== true && ctx.memoryCaptureIndeterminate === true ? { memoryCaptureFloorIndeterminate: true } : {}),
+                        ...(liveCaptureFloor?.optedOut === true ? { memoryCaptureFloor: true } : {}),
+                        ...(liveCaptureFloor?.optedOut !== true && liveCaptureFloor?.indeterminate === true ? { memoryCaptureFloorIndeterminate: true } : {}),
                         ...(ctx.memoryCaptureControlDir !== undefined ? { memoryCaptureQueryDir: ctx.memoryCaptureControlDir } : {}),
                         ...(ctx.memoryCaptureAncestors !== undefined ? { memoryCaptureAncestors: ctx.memoryCaptureAncestors } : {}),
                     }

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

@@ -796,6 +796,27 @@ export declare function memoryConsolidationRefusedNotice(input: {
     reason?: string;
     occurrenceId?: string;
 }): EngineNotice;
+/**
+ * design/383 §S-7 (#511 件1) — {@link MemoryEngine.sessionMemoryStatus}'s answer. Every key is
+ * optional; ABSENCE means the fact's source could not be read (a fault never coins a `false`/`0`
+ * stand-in) — see the method doc for each key's exact absence law.
+ */
+export interface SessionMemoryStatus {
+    /** TRUE = a standing capture opt-out record; FALSE = store readable, no record (capture on).
+     *  ABSENT = the record store faulted — indeterminate (`optOutSource: "fault"` accompanies). */
+    captureOptedOut?: boolean;
+    /** Committed entries carrying this session's lineage contribution. Absent = ledger unreadable. */
+    committedCount?: number;
+    /** Of those, entries already folded into consolidation products (lineage × `distilled.inputs`).
+     *  Absent = ledger / scope enumeration / product read unreadable. */
+    foldedCount?: number;
+    /** WHY `captureOptedOut` reads as it does: `"record"` = a standing one-way record;
+     *  `"fault"` = the store faulted and the capture state is INDETERMINATE (no boolean is coined). */
+    optOutSource?: "record" | "fault";
+    /** Newest lineage `lastAt` for this session (ms epoch) — rides the same single ledger read as
+     *  `committedCount`. Absent = ledger unreadable, or no committed contribution exists at all. */
+    lastCaptureAt?: number;
+}
 export declare class MemoryEngine {
     private readonly backend;
     private readonly memoryDir;
@@ -910,13 +931,17 @@ export declare class MemoryEngine {
      * first cross-process resume, and "私密 only until the next resume" is a promise this engine
      * refuses to imply — the deliberate divergence from the pollution marker's best-effort arm.
      */
-    markSessionCaptureOptOut(sessionId: string, reason: string): SessionCaptureOptOutMarkOutcome;
+    markSessionCaptureOptOut(sessionId: string, reason: string): SessionCaptureOptOutMarkOutcome | Promise<SessionCaptureOptOutMarkOutcome>;
     /** The session's capture opt-out record (in-process first, then the durable store) — undefined =
      *  capture is on. Side-effect-free OBSERVER face; a THROWING store read degrades to the
      *  in-process answer here. Every consumer whose answer decides whether bytes COMMIT must use
      *  {@link sessionCaptureOptOutOrFault} instead — this face cannot distinguish "no record" from
-     *  "store outage", and on that distinction the fail direction flips. */
-    sessionCaptureOptOut(sessionId: string): SessionCaptureOptOutRecord | undefined;
+     *  "store outage", and on that distinction the fail direction flips.
+     *  DUAL FORM (#511 件2, the whole capture-face family — this one, `sessionCaptureOptOutOrFault`,
+     *  `markSessionCaptureOptOut`, `listCaptureOptOutSessions`): over a sync store the answer is the
+     *  same synchronous value as always; over a Promise-form {@link SessionCaptureRecordStore} the
+     *  face answers a Promise of the identical shape. `await` is always correct on either arm. */
+    sessionCaptureOptOut(sessionId: string): SessionCaptureOptOutRecord | undefined | Promise<SessionCaptureOptOutRecord | undefined>;
     /** {@link sessionCaptureOptOut} with the FAULT axis preserved (codex review, 亲核 adopted):
      *  `fault: true` ⇔ the durable store THREW — the record state is INDETERMINATE, which the
      *  commit-deciding consumers (harvest opening read, pre-commit re-read, the runner's read
@@ -926,11 +951,14 @@ export declare class MemoryEngine {
     sessionCaptureOptOutOrFault(sessionId: string): {
         record?: SessionCaptureOptOutRecord;
         fault: boolean;
-    };
+    } | Promise<{
+        record?: SessionCaptureOptOutRecord;
+        fault: boolean;
+    }>;
     /** Every capture-opted-out session id (durable roster ∪ in-process marks). THROWS on an
      *  enumeration failure — the one consumer (the consolidation eligibility arm, §2.4) is
      *  fail-closed by design: "roster unknown" must refuse the run, never read as "no one opted out". */
-    listCaptureOptOutSessions(): Set<string>;
+    listCaptureOptOutSessions(): Set<string> | Promise<Set<string>>;
     /**
      * design/383 §2.3 — the mid-session flip's BOUNDARY-ISOLATION SWEEP over the write plane: files
      * under the writable root that this session window added or changed (vs the materialize baseline)
@@ -1445,6 +1473,35 @@ export declare class MemoryEngine {
      * registry THROWS fail-closed — the same reason an unsupported one never reads as empty.
      */
     listMemoryScopes(): Promise<MemoryScopeEnumeration>;
+    /**
+     * design/383 §S-7 (#511 件1) — the HOST's per-session memory-status read face: the data supply
+     * for the "memory capture is off / N committed, M folded" disclosure family and the
+     * resume-visibility answer (state face, not event face — notice dedup semantics are untouched).
+     * A server projects it onto a wire endpoint as a PURE derivation of these keys.
+     *
+     * EVERY key is optional and its ABSENCE means "that fact's source could not be read" — a fault
+     * never coins a `false`/`0` stand-in (the §3.1 fault-transit law):
+     *  - `captureOptedOut` — the capture opt-out state. Present `true` (a standing record — with
+     *    `optOutSource: "record"`) or present `false` (the store answered and no one-way record
+     *    exists — genuine "capture on"). ABSENT ⇔ the record store faulted: the capture state is
+     *    INDETERMINATE and `optOutSource: "fault"` says so (the 383 片2/3 `captureIndeterminate`
+     *    axis, projected — never a boolean).
+     *  - `committedCount` — how many committed entries carry this session's lineage contribution
+     *    (the lineage ledger's committed set). Absent ⇔ the ledger is unreadable.
+     *  - `foldedCount` — of those, how many appear among the `distilled.inputs` of committed
+     *    consolidation products (the lineage × distilled.inputs intersection — "already folded into
+     *    long-term memory"). Absent ⇔ the ledger, the scope enumeration (a backend without
+     *    `listScopes` cannot name the header universe), or the product read is unreadable.
+     *  - `lastCaptureAt` — the newest `lastAt` over this session's lineage contributions (ms epoch).
+     *    CHEAP by construction — it rides the SAME single ledger read as `committedCount`, so it is
+     *    carried rather than dropped; absent ⇔ the ledger is unreadable OR the session has no
+     *    committed contribution at all (there is no such moment to name — the one key whose absence
+     *    also covers "no fact exists", stated here so consumers need not guess).
+     *
+     * Side-effect-free committed reads throughout (capture face + lineage sidecar + audit-face
+     * headers/getByIds); never throws — an unreadable source is an absent key, which IS the answer.
+     */
+    sessionMemoryStatus(sessionId: string): Promise<SessionMemoryStatus>;
     /** The committed, side-effect-free audit read: the adoption-restricted committed view when the
      *  backend offers one (zero-copy File — ledger+shadow, no disk adoption), else the non-adopting
      *  retrieval view (copy-out File), else the backend itself (Pg/TiDB shapes — naturally committed

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

@@ -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/types.d.ts

@@ -934,8 +934,14 @@ export interface ToolExecuteContext {
      * opted-out session captures nothing, whatever its chosen AgentDefinition says — the opt-out is
      * a floor no selection loosens (the `memoryPersistenceCapable:false` floor's exact law, on the
      * privacy axis). Trusted Runner-filled seat, never a model/tool argument.
+     *
+     * DUAL FORM (#511 件2): on a deployment whose capture record store is synchronous (the default
+     * file trio) this is a plain boolean, byte-identical to before; a Promise-form
+     * {@link RunnerDeps.memoryCaptureRecordStore} makes the live read answer a `Promise<boolean>`.
+     * Consumers must `await` (identity on the boolean arm) — a bare `=== true` on the Promise arm
+     * would coin `false`, the exact un-floored escape this seat closes.
      */
-    memoryCaptureOptedOut?: boolean;
+    memoryCaptureOptedOut?: boolean | Promise<boolean>;
     /**
      * design/383 §2.5 (rescan post-6.0.0-RC) — the floor seat's THIRD state: TRUE ⇔ the spawning
      * session's capture opt-out state is INDETERMINATE at the moment a delegation tool reads this
@@ -947,8 +953,10 @@ export interface ToolExecuteContext {
      * irreversible record is ever minted off an unreadable state); a readable-and-clean answer
      * proceeds clean. Never TRUE beside {@link memoryCaptureOptedOut} — a known opt-out is
      * determinate. Trusted Runner-filled seat, never a model/tool argument.
+     * Dual form like its twin (#511 件2): `boolean` over a sync store, `Promise<boolean>` over a
+     * Promise-form store — consumers `await`.
      */
-    memoryCaptureIndeterminate?: boolean;
+    memoryCaptureIndeterminate?: boolean | Promise<boolean>;
     /** design/383 §2.5 — the spawning session's write-plane control dir (the coordinate its capture
      *  record is keyed under), forwarded beside the floor bit so a cross-plane child's record-query
      *  leg reads the PARENT's carrier, not its own plane's. Trusted Runner-filled seat. */

package/dist/index.d.ts

@@ -179,7 +179,7 @@ export { AdoptionError, assertAdoptionBootGate, readRootAdoptionFile, writeRootA
 export { adoptLocalDataRoot, ackAdoptionConfig, witnessAdoptionConfig, listAdoptionQuarantine, readAdoptionStatus, type AdoptionStatus, type AdoptLocalDataRootOptions, type AdoptLocalDataRootResult, type AdoptionCarriageLeg, type AdoptionCarriageLegContext, type AdoptionConfigWitnessReceipt, } from "./stores/file/adoption/adopt.js";
 export { formatHookFeedback, runToolGate, createHookEnvCapabilities, createPreToolUseConstraintPolicy, type PersistedRuleHit, type PersistedRuleHitRule, type PersistedRuleUnreadable, type PersistedRuleCoverage, type PersistedRuleAnswer, normalizePersistedRuleHit, type Hooks, type HookToolContext, type HookInvocationIdentity, type UserPromptSubmitContext, type PostToolBatchContext, type HookEnvCapabilities, type HookToolOutput, type PreToolUseResult, type PostToolUseResult, type UserPromptSubmitResult, type HookToolFailure, type PostToolUseFailureResult, type PostToolBatchCall, type PostToolBatchResult, type PreCompactContext, type PreCompactResult, type PostCompactContext, type StopFailureContext, type PermissionDeniedPayload, type PermissionDeniedSource, } from "./core/hooks.js";
 export { InMemoryMemoryStore, composeMemoryBlock, composeLayeredMemoryBlock, normalizeMemorySpec, type NormalizedMemorySpec, type MemorySpecInput, supportsConsolidation, supportsPeriodicConsolidation, firstSentence, expandLexicalTerms, lexicalSearchMatch, type Embedder, classifyPromotable, enforcePromotableWriteGate, guardedMemoryStore, MemoryGateError, detectSecret, enforceSecretWriteGate, enforceStructuredNoteSecretGate, type UtilityGate, type MemoryStore, type MemoryVectorMode, type ScoredMemory, type MemoryNoteHeader, type MemoryNoteRecord, type MemoryNoteType, type StructuredNoteInput, } from "./core/memory.js";
-export { MemoryEngine, FileMemoryEngineBackend, memoryBackendContract, assertMemoryBackendSearchEquivalence, type MemoryBackendContractHooks, buildMemoryInstruction, truncateIndex, scanEntryFiles, deriveRepoKey, deriveRepoMemoryDir, deriveControlPlaneDir, deriveRepoControlPlaneDir, resolveMemoryEngineRoot, scopeDirName, ControlPlaneCorruptError, parseEntryFile, serializeEntryFile, computeEntryRev, entryFromFile, MEMORY_ORIGIN_CAUSES, committedOriginOf, originEquals, consolidationExposedFrontmatter, ambiguousOriginRepresentation, type OriginClearanceRow, type OriginClearanceEvent, type OriginClearanceShadow, committedDistilledOf, distilledEquals, type MemoryEntryDistilled, type MemoryEntryDistilledInput, CONSOLIDATION_DEFAULTS, ConsolidationRefusedError, MEMORY_SEARCH_SUPERSEDED_TAG, consolidationTypeEligible, deriveSupersededSet, memorySupersededNote, readIntentCredentials, supersessionFuseCeiling, memoryConsolidationRecommendedNotice, memoryConsolidationCommittedNotice, memoryConsolidationConflictNotice, memoryConsolidationIncompleteNotice, memoryConsolidationRefusedNotice, memoryConsolidationWithheldNotice, type ConsolidationGateRead, type ConsolidationGateRow, type ConsolidationIntent, type ConsolidationIntentCredentialRow, type ConsolidationLeaseSeat, type ConsolidationProductProposal, type ConsolidationProposal, type MemoryConsolidationOptions, type ConsolidationCommitReceipt, type ConsolidationReconcileReport, type ConsolidationResolveReceipt, type ConsolidationPlanSummary, type ConsolidationPlanFoldEvidence, 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, MEMORY_DISTILLER_PURITY_CONTRACT_V1, detectCleanArmVerbatimLeak, type CleanArmLeakFinding, type CleanArmLeakVerdict, type MemoryDistillerPurityContract, 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, CONSOLIDATION_DRIVER_PLANS_DIR, CONSOLIDATION_DRIVER_RUNS_FILE, CONSOLIDATION_RUN_STOP_REASONS, archiveDistillerPlan, readConsolidationDriverRun, runMemoryConsolidationDriver, type ConsolidationDriverEngine, type ConsolidationDriverRunRow, type ConsolidationRunReceipt, type ConsolidationRunStopReason, type RunMemoryConsolidationOptions, isInstructionEntry, type MemoryEntryOrigin, type MemoryOriginCause, MEMORY_INSTRUCTION_TEMPLATE, MEMORY_RECALL_DISCIPLINE, MEMORY_PREFERENCE_DISCIPLINE, MEMORY_READONLY_NOTICE, MEMORY_CAPTURE_OPTOUT_NOTICE, memoryCaptureOptedOutNotice, memoryCaptureOptOutUnpersistedNotice, SESSION_CAPTURE_OPTOUT_DIR, markSessionCaptureOptOut, readSessionCaptureOptOut, listSessionCaptureOptOut, fileSessionCaptureRecordStore, type SessionCaptureOptOutRecord, type SessionCaptureOptOutMarkOutcome, type SessionCaptureRecordStore, readV2HeaderHints, type V2HeaderHints, LINEAGE_FILE, CHALLENGES_FILE, CHALLENGED_HISTORY_FILE, CHALLENGE_LEDGER_MAX_EVENTS, rebuildStrictControlPlaneLedger, type ControlPlaneRebuildReceipt, type StrictControlPlaneLedger, type ChallengeAssignment, type ChallengeEvent, type ChallengedHistoryRow, type LineagePendingTxn, type LineagePromotion, MEMORY_INDEX_FILENAME, MEMORY_INDEX_MAX_LINES, MEMORY_INDEX_MAX_BYTES, MEMORY_SEARCH_TOOL_NAME, MEMORY_GET_TOOL_NAME, MEMORY_INDEX_TOOL_NAME, MEMORY_ENGINE_TOOL_NAMES, type MemorySearchDetails, type MemorySearchHit, type CleanMemorySearchHit, type ExposedMemorySearchHit, MEMORY_EXPOSURE_BANNER, MEMORY_EXPOSURE_HANDLE_TAG, memoryExposureIndexRow, type MemoryGetDetails, type MemoryIndexDetails, type MemoryIndexRow, type CleanMemoryIndexRow, type ExposedMemoryIndexRow, STUB_ARCHIVED_LINE, DEFAULT_MAX_MEMORY_FILES, DEFAULT_MAX_ENTRY_DEPTH, DEFAULT_HARVEST_DEADLINE_MS, DEFAULT_HARVEST_FILE_BUDGET, MASS_DELETION_FUSE_RATIO, scanMemoryWrite, scanMemoryFileName, scanRemediation, MEMORY_FILENAME_SEGMENT_RE, renderAnnouncements, enqueueMemoryAnnouncement, drainMemoryAnnouncements, peekMemoryAnnouncements, bumpScanFuse, scanFuseCount, clearScanFuse, ANNOUNCEMENTS_FILE, MEMORY_ANNOUNCEMENTS_MAX, SCAN_FUSE_FILE, SCAN_FUSE_THRESHOLD, type MemoryAnnouncement, type ScanFinding, type MemoryEngineOptions, type MemoryInjection, type EntryProvenanceAccount, type TransferEvidence, type CommittedBinding, type CommittedEntrySnapshot, type CommittedScopeSnapshots, type EntryCustodyReport, erasureSelectHash, type EraseMemoryEntriesInput, type ErasureSelect, type ErasedBinding, type MemoryErasureAttestation, computeMemoryBundleHash, type MemoryExportBundle, type MemoryImportReport, type MemoryExportSnapshot, type MemoryBundleImportPlan, type BundleChallengeRow, type BundleLineageRow, type BundlePollutedSession, type MemoryBackend, type MemoryEntry, type MemoryEntryFrontmatter, type MemoryEntryHeader, type MemoryScopeEnumeration, type ScoredMemoryEntry, type NotePatch, type PatchReport, type MaterializedFile, type MemorySessionHandle, type HarvestReport, type HarvestRejection, type HarvestRejectionCode, type ParsedEntryFile, type ScannedEntryFile, SCOPE_SEGMENT_MAX_ENCODED, PROJECT_MARKER_PATH, encodeScopeSegment, decodeScopeSegment, parseScopeKey, formatUserScope, formatOrgScope, formatProjScope, formatUserProjScope, isPersonalScope, assertScopeContractPlacement, formatProjectMarker, parseProjectMarker, resolveProjectId, PROJECT_ID_REGEX, type ParsedScopeKey, migrateScope, type MigrateScopeReport, materializeEntriesToFiles, harvestFilesToPatches, projectionsToWriteBack, screenInboundEntries, REMOTE_HARVEST_PER_FILE_BYTES, REMOTE_MASS_DELETION_FUSE_RATIO, type RemoteMemoryFile, type RemoteMemoryBaseline, type RemoteMaterialization, type RemoteHarvestResult, type InboundEntryFinding, deriveProjectMemoryDir, deriveProjectControlDir, recordProjectIdHint, lookupProjectIdHint, PROJECT_ID_HINTS_FILE, reconcileMemoryEntries, nextSyncBaseline, mergeRecallHits, type MemorySyncCursor, type MemorySyncConflict, type MemorySyncPlan, type RecallSource, syncMemoryScope, type MemorySyncTransport, type MemorySyncRequestBody, type MemorySyncResponseBody, type MemorySyncClientConflict, type SyncMemoryScopeOptions, type MemorySyncClientResult, } from "./core/memory-engine/index.js";
+export { MemoryEngine, FileMemoryEngineBackend, memoryBackendContract, assertMemoryBackendSearchEquivalence, type MemoryBackendContractHooks, buildMemoryInstruction, truncateIndex, scanEntryFiles, deriveRepoKey, deriveRepoMemoryDir, deriveControlPlaneDir, deriveRepoControlPlaneDir, resolveMemoryEngineRoot, scopeDirName, ControlPlaneCorruptError, parseEntryFile, serializeEntryFile, computeEntryRev, entryFromFile, MEMORY_ORIGIN_CAUSES, committedOriginOf, originEquals, consolidationExposedFrontmatter, ambiguousOriginRepresentation, type OriginClearanceRow, type OriginClearanceEvent, type OriginClearanceShadow, committedDistilledOf, distilledEquals, type MemoryEntryDistilled, type MemoryEntryDistilledInput, CONSOLIDATION_DEFAULTS, ConsolidationRefusedError, MEMORY_SEARCH_SUPERSEDED_TAG, consolidationTypeEligible, deriveSupersededSet, memorySupersededNote, readIntentCredentials, supersessionFuseCeiling, memoryConsolidationRecommendedNotice, memoryConsolidationCommittedNotice, memoryConsolidationConflictNotice, memoryConsolidationIncompleteNotice, memoryConsolidationRefusedNotice, memoryConsolidationWithheldNotice, type ConsolidationGateRead, type ConsolidationGateRow, type ConsolidationIntent, type ConsolidationIntentCredentialRow, type ConsolidationLeaseSeat, type ConsolidationProductProposal, type ConsolidationProposal, type MemoryConsolidationOptions, type ConsolidationCommitReceipt, type ConsolidationReconcileReport, type ConsolidationResolveReceipt, type ConsolidationPlanSummary, type ConsolidationPlanFoldEvidence, type SessionMemoryStatus, 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, MEMORY_DISTILLER_PURITY_CONTRACT_V1, detectCleanArmVerbatimLeak, type CleanArmLeakFinding, type CleanArmLeakVerdict, type MemoryDistillerPurityContract, 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, CONSOLIDATION_DRIVER_PLANS_DIR, CONSOLIDATION_DRIVER_RUNS_FILE, CONSOLIDATION_RUN_STOP_REASONS, archiveDistillerPlan, readConsolidationDriverRun, runMemoryConsolidationDriver, type ConsolidationDriverEngine, type ConsolidationDriverRunRow, type ConsolidationRunReceipt, type ConsolidationRunStopReason, type RunMemoryConsolidationOptions, isInstructionEntry, type MemoryEntryOrigin, type MemoryOriginCause, MEMORY_INSTRUCTION_TEMPLATE, MEMORY_RECALL_DISCIPLINE, MEMORY_PREFERENCE_DISCIPLINE, MEMORY_READONLY_NOTICE, MEMORY_CAPTURE_OPTOUT_NOTICE, memoryCaptureOptedOutNotice, memoryCaptureOptOutUnpersistedNotice, SESSION_CAPTURE_OPTOUT_DIR, markSessionCaptureOptOut, readSessionCaptureOptOut, listSessionCaptureOptOut, fileSessionCaptureRecordStore, type SessionCaptureOptOutRecord, type SessionCaptureOptOutMarkOutcome, type SessionCaptureRecordStore, readV2HeaderHints, type V2HeaderHints, LINEAGE_FILE, CHALLENGES_FILE, CHALLENGED_HISTORY_FILE, CHALLENGE_LEDGER_MAX_EVENTS, rebuildStrictControlPlaneLedger, type ControlPlaneRebuildReceipt, type StrictControlPlaneLedger, type ChallengeAssignment, type ChallengeEvent, type ChallengedHistoryRow, type LineagePendingTxn, type LineagePromotion, MEMORY_INDEX_FILENAME, MEMORY_INDEX_MAX_LINES, MEMORY_INDEX_MAX_BYTES, MEMORY_SEARCH_TOOL_NAME, MEMORY_GET_TOOL_NAME, MEMORY_INDEX_TOOL_NAME, MEMORY_ENGINE_TOOL_NAMES, type MemorySearchDetails, type MemorySearchHit, type CleanMemorySearchHit, type ExposedMemorySearchHit, MEMORY_EXPOSURE_BANNER, MEMORY_EXPOSURE_HANDLE_TAG, memoryExposureIndexRow, type MemoryGetDetails, type MemoryIndexDetails, type MemoryIndexRow, type CleanMemoryIndexRow, type ExposedMemoryIndexRow, STUB_ARCHIVED_LINE, DEFAULT_MAX_MEMORY_FILES, DEFAULT_MAX_ENTRY_DEPTH, DEFAULT_HARVEST_DEADLINE_MS, DEFAULT_HARVEST_FILE_BUDGET, MASS_DELETION_FUSE_RATIO, scanMemoryWrite, scanMemoryFileName, scanRemediation, MEMORY_FILENAME_SEGMENT_RE, renderAnnouncements, enqueueMemoryAnnouncement, drainMemoryAnnouncements, peekMemoryAnnouncements, bumpScanFuse, scanFuseCount, clearScanFuse, ANNOUNCEMENTS_FILE, MEMORY_ANNOUNCEMENTS_MAX, SCAN_FUSE_FILE, SCAN_FUSE_THRESHOLD, type MemoryAnnouncement, type ScanFinding, type MemoryEngineOptions, type MemoryInjection, type EntryProvenanceAccount, type TransferEvidence, type CommittedBinding, type CommittedEntrySnapshot, type CommittedScopeSnapshots, type EntryCustodyReport, erasureSelectHash, type EraseMemoryEntriesInput, type ErasureSelect, type ErasedBinding, type MemoryErasureAttestation, computeMemoryBundleHash, type MemoryExportBundle, type MemoryImportReport, type MemoryExportSnapshot, type MemoryBundleImportPlan, type BundleChallengeRow, type BundleLineageRow, type BundlePollutedSession, type MemoryBackend, type MemoryEntry, type MemoryEntryFrontmatter, type MemoryEntryHeader, type MemoryScopeEnumeration, type ScoredMemoryEntry, type NotePatch, type PatchReport, type MaterializedFile, type MemorySessionHandle, type HarvestReport, type HarvestRejection, type HarvestRejectionCode, type ParsedEntryFile, type ScannedEntryFile, SCOPE_SEGMENT_MAX_ENCODED, PROJECT_MARKER_PATH, encodeScopeSegment, decodeScopeSegment, parseScopeKey, formatUserScope, formatOrgScope, formatProjScope, formatUserProjScope, isPersonalScope, assertScopeContractPlacement, formatProjectMarker, parseProjectMarker, resolveProjectId, PROJECT_ID_REGEX, type ParsedScopeKey, migrateScope, type MigrateScopeReport, materializeEntriesToFiles, harvestFilesToPatches, projectionsToWriteBack, screenInboundEntries, REMOTE_HARVEST_PER_FILE_BYTES, REMOTE_MASS_DELETION_FUSE_RATIO, type RemoteMemoryFile, type RemoteMemoryBaseline, type RemoteMaterialization, type RemoteHarvestResult, type InboundEntryFinding, deriveProjectMemoryDir, deriveProjectControlDir, recordProjectIdHint, lookupProjectIdHint, PROJECT_ID_HINTS_FILE, reconcileMemoryEntries, nextSyncBaseline, mergeRecallHits, type MemorySyncCursor, type MemorySyncConflict, type MemorySyncPlan, type RecallSource, syncMemoryScope, type MemorySyncTransport, type MemorySyncRequestBody, type MemorySyncResponseBody, type MemorySyncClientConflict, type SyncMemoryScopeOptions, type MemorySyncClientResult, } from "./core/memory-engine/index.js";
 export { SHARED_MEMORY_READ_CAP_BYTES, SHARED_MEMORY_LIST_PAGE_SIZE, SharedMemoryStoreError, type SharedMemoryStoreProvider, type SharedMemoryStoreReader, type SharedMemoryPagedList, type SharedMemoryStoreInfo, type SharedMemoryDocumentEntry, type SharedMemorySnapshot, type SharedMemoryRequestContext, type MemoryListDetails, type MemoryReadDetails, } from "./core/shared-memory/types.js";
 export { sharedMemoryStoreContract, type SharedMemoryFixture, type SharedMemoryStoreContractHooks, } from "./core/shared-memory/contract.js";
 export { termSet, jaccardDistance, cosineDistance } from "./core/memory-vector.js";

package/dist/orchestration/run-workflow-tool.d.ts

@@ -245,7 +245,15 @@ export interface RunWorkflowToolDeps {
             sessionId: string;
             controlDir?: string;
         }>;
-    };
+    } | Promise<{
+        optedOut: boolean;
+        indeterminate: boolean;
+        controlDir?: string;
+        ancestors?: ReadonlyArray<{
+            sessionId: string;
+            controlDir?: string;
+        }>;
+    }>;
     /** TRUSTED nesting depth from the run's internals (NOT a tool param) — passed to `startWorkflow` so a
      *  cross-process child workflow is rejected by the one-level guard. */
     workflowDepth?: number;

package/dist/orchestration/run-workflow-tool.js

@@ -515,12 +515,17 @@ export async function createRunWorkflowTool(d) {
                     ...(() => {
                         if ("memoryCaptureOptedOut" in ctx) {
                             return {
-                                parentMemoryCaptureState: () => ({
-                                    optedOut: ctx.memoryCaptureOptedOut === true,
-                                    indeterminate: ctx.memoryCaptureIndeterminate === true,
-                                    ...(ctx.memoryCaptureControlDir !== undefined ? { controlDir: ctx.memoryCaptureControlDir } : {}),
-                                    ...(ctx.memoryCaptureAncestors !== undefined ? { ancestors: ctx.memoryCaptureAncestors } : {}),
-                                }),
+                                parentMemoryCaptureState: () => {
+                                    const o = ctx.memoryCaptureOptedOut ?? false;
+                                    const i = ctx.memoryCaptureIndeterminate ?? false;
+                                    const build = (optedOut, indeterminate) => ({
+                                        optedOut: optedOut === true,
+                                        indeterminate: indeterminate === true,
+                                        ...(ctx.memoryCaptureControlDir !== undefined ? { controlDir: ctx.memoryCaptureControlDir } : {}),
+                                        ...(ctx.memoryCaptureAncestors !== undefined ? { ancestors: ctx.memoryCaptureAncestors } : {}),
+                                    });
+                                    return o instanceof Promise || i instanceof Promise ? Promise.all([o, i]).then(([ov, iv]) => build(ov, iv)) : build(o, i);
+                                },
                             };
                         }
                         return d.parentMemoryCaptureState !== undefined ? { parentMemoryCaptureState: d.parentMemoryCaptureState } : {};

package/dist/orchestration/workflow.d.ts

@@ -405,7 +405,15 @@ export interface RunWorkflowOptions {
             sessionId: string;
             controlDir?: string;
         }>;
-    };
+    } | Promise<{
+        optedOut: boolean;
+        indeterminate: boolean;
+        controlDir?: string;
+        ancestors?: ReadonlyArray<{
+            sessionId: string;
+            controlDir?: string;
+        }>;
+    }>;
     /** Call-time getter for the HOST run's RESOLVED Model object. A spawned agent whose
      *  fold chain (script spec → agentType → governance baseline) produced NO model inherits the
      *  parent's full object — baseUrl/key routing included — instead of falling to a string/role

package/dist/orchestration/workflow.js

@@ -619,8 +619,8 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
         ...(opts.placementRoot !== undefined ? { placementRoot: opts.placementRoot } : {}),
         ...(opts.originatingSessionId !== undefined ? { parentSessionId: opts.originatingSessionId } : {}),
     };
-    const captureFloorSeatsNow = () => {
-        const s = opts.parentMemoryCaptureState?.();
+    const captureFloorSeatsNow = async () => {
+        const s = await opts.parentMemoryCaptureState?.();
         if (s === undefined)
             return {};
         return {
@@ -1255,7 +1255,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                         opts.onForwardEvent(e.type === "task_progress" ? { ...e, workflowRunId: runId, workflowAgentLabel: label } : e);
                     }
                     : undefined;
-                const baseInternals = { ...(agentOpts.isolation ? { isolation: agentOpts.isolation } : {}), ...(opts.parentCwd !== undefined ? { parentCwd: opts.parentCwd } : {}), ...spawnAttribution, ...captureFloorSeatsNow(), ...(enrichedForward !== undefined ? { onForwardEvent: enrichedForward } : {}), delegationTaskType: "workflow", agentName: label, onWorkspaceResolved: createWorkspaceObserver(rec) };
+                const baseInternals = { ...(agentOpts.isolation ? { isolation: agentOpts.isolation } : {}), ...(opts.parentCwd !== undefined ? { parentCwd: opts.parentCwd } : {}), ...spawnAttribution, ...(await captureFloorSeatsNow()), ...(enrichedForward !== undefined ? { onForwardEvent: enrichedForward } : {}), delegationTaskType: "workflow", agentName: label, onWorkspaceResolved: createWorkspaceObserver(rec) };
                 let attempts = 0;
                 let throttleRetried = false;
                 let lastAttemptReason;
@@ -1574,7 +1574,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                     ...(agentOpts.isolation ? { isolation: agentOpts.isolation } : {}),
                     ...(opts.parentCwd !== undefined ? { parentCwd: opts.parentCwd } : {}),
                     ...spawnAttribution,
-                    ...captureFloorSeatsNow(),
+                    ...(await captureFloorSeatsNow()),
                     ...(enrichedForwardS !== undefined ? { onForwardEvent: enrichedForwardS } : {}),
                     delegationTaskType: "workflow",
                     agentName: label,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "7.0.1",
+  "version": "7.0.2",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",

package/test/export-surface.snapshot.json

@@ -1,7 +1,7 @@
 {
   "_comment": "design/87 L3 — frozen public export surface of src/index.ts (name -> kind). DO NOT edit by hand to silence a red test. A removed/changed entry = a SemVer-BREAKING change; bump MAJOR and update this fixture in the SAME commit (design/87 §4.2 / §5.2). Regenerate via REGEN in test/export-surface.test.ts.",
   "_tierComment": "#435 v1 — machine-readable layering of the public surface: stable = demonstrated by README.md / src/examples; internal = an `Internal`-marked name or a runner/engine deep-subtree declaration (the model seam src/engine/llm is excluded — it is the BYOM contract, not an engine internal); advanced = a supported export the front door does not walk you through. THIS IS AN INITIAL HEURISTIC, derived mechanically and expected to be refined ticket by ticket: no human reviewed these 1700+ entries one by one, and nothing here claims otherwise. Known bias: a short or English-word export name (ok, err, Result, Usage) can match ordinary prose in README.md and land `stable` on a coincidence. Every export MUST carry a tier — a new export with no row fails the gate in export-surface.test.ts.",
-  "count": 1841,
+  "count": 1842,
   "exports": {
     "A2ATaskState": "type",
     "A2ATaskStateReversal": "type",
@@ -996,6 +996,7 @@
     "SessionCaptureOptOutRecord": "interface",
     "SessionCaptureRecordStore": "interface",
     "SessionError": "class",
+    "SessionMemoryStatus": "interface",
     "SessionMetadata": "interface",
     "SessionPermissionRules": "interface",
     "SessionPlacement": "interface",
@@ -2839,6 +2840,7 @@
     "SessionCaptureOptOutRecord": "advanced",
     "SessionCaptureRecordStore": "advanced",
     "SessionError": "stable",
+    "SessionMemoryStatus": "advanced",
     "SessionMetadata": "stable",
     "SessionPermissionRules": "advanced",
     "SessionPlacement": "advanced",