@sema-agent/core 7.20.1 → 7.21.1

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

@@ -75,6 +75,10 @@ export declare const LLM_DISTILLER_CONTRACTS: Record<string, LlmDistillerContrac
  * left hanging. The exposure-partitioned topology itself deliberately did NOT bump this version
  * (the candidate-set composition is topology, not wording; the wording axis stays single-variable
  * for exactly this A/B).
+ *
+ * WHERE THAT OBLIGATION NOW LIVES IN CODE: the root-elimination arm is the writing-channel option pair on
+ * {@link mintLlmConsolidationPlan} (`writingIntent: "none-stated"` + `productKeyFallback: false`, recorded as
+ * `minting.writingChannel`); the A/B readings, verdict and ruling are tracked in `docs/memory-distillation-ga.json`.
  */
 export declare const MEMORY_DISTILLER_CONTRACT_V1: LlmDistillerContract;
 /**
@@ -314,6 +318,12 @@ export interface LlmConsolidationPlan {
          *  single-call-chain plans, INCLUDING the zero-marked degenerate of the partitioned mint
          *  (whose bytes must stay identical to the plain mint's, modulo the attestation echo). */
         arms?: LlmConsolidationPlanArm[];
+        /** pd-2 root-elimination A/B — the WRITING CHANNEL this plan was minted under, PRESENT ONLY when non-default,
+         *  so a default plan's bytes are unchanged and a reading can attribute its arm from the archive alone. */
+        writingChannel?: {
+            intent: "grouping" | "none-stated";
+            keyFallback: boolean;
+        };
     };
 }
 export type MintLlmConsolidationPlanResult = {
@@ -330,7 +340,7 @@ export type MintLlmConsolidationPlanResult = {
  * it answered is returned inside the plan so the run can be re-read, re-scored and disputed from
  * the archive alone.
  */
-export declare function mintLlmConsolidationPlan({ candidates, chat, model, baseUrl, maxInputsPerProduct, contract, onProgress, armLabel, }: {
+export declare function mintLlmConsolidationPlan({ candidates, chat, model, baseUrl, maxInputsPerProduct, contract, onProgress, armLabel, writingIntent, productKeyFallback, }: {
     candidates: readonly DistillerCandidate[];
     chat: DistillerChatFn;
     /** The requested model id, recorded into the plan (audit anchor). Alias spellings refuse. */
@@ -353,6 +363,21 @@ export declare function mintLlmConsolidationPlan({ candidates, chat, model, base
      *  archive only, and stays compatible with `planParseRepairs`' `startsWith("grouping")` phase
      *  split and its `#N` retry grammar. Absent ⇒ the historical label forms, byte-identical. */
     armLabel?: "clean" | "marked";
+    /**
+     * pd-2 root-elimination A/B (the standing obligation on {@link MEMORY_DISTILLER_CONTRACT_V1}) — the WRITING
+     * CHANNEL: which grouping-authored bytes reach the writing pass. `"grouping"` (absent ≡ this, the shipped form)
+     * fills `{{INTENT}}` with the grouping pass's own `intent`; `"none-stated"` fills it with `(none stated)` for
+     * EVERY group, so the clean arm's authoring prompt carries no grouping-authored intent bytes. Mint TOPOLOGY, not
+     * wording: the contract's frozen text is untouched and no version moves. Recorded on the plan
+     * (`minting.writingChannel`) whenever non-default.
+     */
+    writingIntent?: "grouping" | "none-stated";
+    /**
+     * The channel's second byte path: `true` (absent ≡ this) names a product after the grouping-authored `key` when
+     * the writing answer carries no `name`; `false` treats a missing or empty `name` as a FORMAT failure (retried,
+     * then a counted write failure — R3), so nothing grouping-authored ever becomes a product's name on this arm.
+     */
+    productKeyFallback?: boolean;
 }): Promise<MintLlmConsolidationPlanResult>;
 /** ONE rev sentinel for every face that RECORDS or RE-CHECKS a candidate's rev (the mint roster
  *  below, the driver's cross-cycle roster re-check, the replay's offered map). The snapshot

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

@@ -259,8 +259,9 @@ function assertMintConfig(chat, model) {
         throw distillerConfigRefusal(`mintLlmConsolidationPlan needs an EXPLICIT model id, got ${JSON.stringify(model)} — an alias can be re-pointed upstream and would move the run with no trace in the plan.`);
     }
 }
-export async function mintLlmConsolidationPlan({ candidates, chat, model, baseUrl, maxInputsPerProduct = DISTILLER_DEFAULT_MAX_INPUTS_PER_PRODUCT, contract = MEMORY_DISTILLER_CONTRACT_V1, onProgress = null, armLabel, }) {
+export async function mintLlmConsolidationPlan({ candidates, chat, model, baseUrl, maxInputsPerProduct = DISTILLER_DEFAULT_MAX_INPUTS_PER_PRODUCT, contract = MEMORY_DISTILLER_CONTRACT_V1, onProgress = null, armLabel, writingIntent, productKeyFallback, }) {
     assertMintConfig(chat, model);
+    const writingChannel = writingIntent === "none-stated" || productKeyFallback === false ? { intent: writingIntent ?? "grouping", keyFallback: productKeyFallback !== false } : undefined;
     const rows = candidates.map((c, i) => ({ n: i + 1, id: c?.entry?.id, rev: c?.entry?.rev, text: renderCandidate(i + 1, c) }));
     const missingId = rows.filter((r) => typeof r.id !== "string");
     if (missingId.length > 0)
@@ -310,7 +311,7 @@ export async function mintLlmConsolidationPlan({ candidates, chat, model, baseUr
     const writeFailures = [];
     for (const [i, g] of sanitized.groups.entries()) {
         const memberText = g.members.map((m) => byId.get(m.id)?.text ?? "").join("\n\n");
-        const user = fill(contract.writing.instructions, { INTENT: g.intent || "(none stated)", MEMBERS: memberText });
+        const user = fill(contract.writing.instructions, { INTENT: writingIntent === "none-stated" ? "(none stated)" : g.intent || "(none stated)", MEMBERS: memberText });
         let written = null;
         let err = null;
         for (let attempt = 0; attempt <= contract.retries && written === null; attempt++) {
@@ -330,6 +331,10 @@ export async function mintLlmConsolidationPlan({ candidates, chat, model, baseUr
                 err = "the object carries no non-empty `body`";
                 continue;
             }
+            if (productKeyFallback === false && (typeof value.name !== "string" || value.name.trim() === "")) {
+                err = "the object carries no non-empty `name` (no grouping-key fallback on this arm)";
+                continue;
+            }
             written = parsed.value;
         }
         if (written === null) {
@@ -371,6 +376,7 @@ export async function mintLlmConsolidationPlan({ candidates, chat, model, baseUr
                 usage,
                 prompts: { grouping: groupingUser, writingTemplate: contract.writing.instructions, systems: { grouping: contract.grouping.system, writing: contract.writing.system } },
                 transcript: calls,
+                ...(writingChannel !== undefined ? { writingChannel } : {}),
             },
         },
     };
@@ -455,6 +461,7 @@ export async function mintExposurePartitionedPlan(args) {
                 },
                 transcript,
                 ...(arms.length > 0 ? { arms: arms.map((a) => armUsageOf(a.tag, a.res, a.count)) } : {}),
+                ...(anchor?.minting.writingChannel !== undefined ? { writingChannel: anchor.minting.writingChannel } : {}),
             },
         },
     };

package/dist/core/path-identity.d.ts

@@ -0,0 +1,13 @@
+import type { ExecutionEnv } from "../internal/harness-types.js";
+import { type PathFamily } from "../tools/fs/safety.js";
+/**
+ * Every spelling the leaf symlink chain of `path` passes through, or `[]`.
+ *
+ * `[]` has ONE reading — nothing to judge beyond the spelling and the terminal — reached three ways that are
+ * deliberately the same word: no `canonicalChain` declared, `ok: false`, or an empty chain. An unanswerable
+ * chain is never a refusal: the terminal's own canonicalization already refuses what it cannot resolve, and a
+ * second refusal law over one target would be a second rule. The spelling is anchored as the canonicalizer
+ * anchors it (`baseCwd`). A refused namespace spelling and a win-form UNC spelling are not walked (the reference
+ * CLI's variant set stops at a network spelling); the share is recognized by the throat's own `isUncSpelling`.
+ */
+export declare function symlinkChainHops(env: ExecutionEnv, path: string, signal: AbortSignal | undefined, family: PathFamily, baseCwd?: string): Promise<readonly string[]>;

package/dist/core/path-identity.js

@@ -0,0 +1,14 @@
+import { isAbsoluteForFamily, isUncSpelling, joinForFamily, win32NamespaceScreen } from "../tools/fs/safety.js";
+export async function symlinkChainHops(env, path, signal, family, baseCwd) {
+    if (typeof env.canonicalChain !== "function")
+        return [];
+    const screened = win32NamespaceScreen(path, family);
+    if (!screened.ok)
+        return [];
+    const spelled = screened.spelled;
+    if (family === "win" && isUncSpelling(spelled))
+        return [];
+    const target = baseCwd !== undefined && baseCwd.length > 0 && !isAbsoluteForFamily(family, spelled) ? joinForFamily(family, baseCwd, spelled) : spelled;
+    const chain = await env.canonicalChain(target, signal);
+    return chain.ok ? chain.value.hops : [];
+}

package/dist/core/runner/env-capability-census.d.ts

@@ -1,9 +1,11 @@
 import type { ExecutionEnv } from "../../internal/harness.js";
 import type { EngineNotice } from "../engine-notice.js";
-/** One capability key whose declared value is not a boolean, with the type it actually carries. */
+/** One declaration whose value is not the shape its seat takes, with the type it actually carries. */
 export interface MalformedCapabilityDeclaration {
     readonly key: string;
     readonly valueType: string;
+    /** The shape the seat takes: a `capabilities.*` boolean, or an optional seam method. */
+    readonly expected: "boolean" | "function";
 }
 /**
  * Every boolean capability this env DECLARES with a value that is not a boolean.

package/dist/core/runner/env-capability-census.js

@@ -1,37 +1,54 @@
 import { isRemoteExecutionEnv } from "../remote-env.js";
 import { deliverEngineNotice } from "../engine-notice.js";
 const BOOLEAN_CAPABILITY_KEYS = ["isolation", "suspendable", "canonicalPathAuthoritative"];
+const OPTIONAL_METHOD_KEYS = ["writeFileExclusive", "writeFileGuarded", "setFileMode", "readLink", "canonicalChain"];
 export function malformedCapabilityDeclarations(env) {
+    const out = [];
+    for (const key of OPTIONAL_METHOD_KEYS) {
+        let value;
+        try {
+            value = Reflect.get(env, key);
+        }
+        catch {
+            out.push({ key, valueType: "unreadable", expected: "function" });
+            continue;
+        }
+        if (value === undefined || typeof value === "function")
+            continue;
+        out.push({ key, valueType: value === null ? "null" : typeof value, expected: "function" });
+    }
     let caps;
     try {
         if (!isRemoteExecutionEnv(env))
-            return [];
+            return out;
         caps = env.capabilities;
     }
     catch {
-        return [{ key: "capabilities", valueType: "unreadable" }];
+        out.push({ key: "capabilities", valueType: "unreadable", expected: "boolean" });
+        return out;
     }
-    const out = [];
     for (const key of BOOLEAN_CAPABILITY_KEYS) {
         let value;
         try {
             value = caps[key];
         }
         catch {
-            out.push({ key, valueType: "unreadable" });
+            out.push({ key, valueType: "unreadable", expected: "boolean" });
             continue;
         }
         if (value === undefined || typeof value === "boolean")
             continue;
-        out.push({ key, valueType: value === null ? "null" : typeof value });
+        out.push({ key, valueType: value === null ? "null" : typeof value, expected: "boolean" });
     }
     return out;
 }
 export function announceMalformedCapabilities(env, onNotice) {
-    for (const { key, valueType } of malformedCapabilityDeclarations(env)) {
+    for (const { key, valueType, expected } of malformedCapabilityDeclarations(env)) {
         deliverEngineNotice(onNotice, {
             code: "config.execution_env_capability_invalid",
-            message: `The execution environment declares capabilities.${key} as a ${valueType}, not a boolean. What a reader makes of that is the reader's own business and differs between them — the containment readers take only the boolean, so this reads as undeclared, while the suspend reader takes any truthy value, so a non-empty string reads as TRUE. That is why a declaration of the wrong shape cannot pass quietly: the engine may act on something other than what the adapter meant. Fix the adapter — this is a wiring fault, not a supported way to leave the capability unset.`,
+            message: expected === "function"
+                ? `The execution environment declares ${key} as a ${valueType}, not a function. This seat is declared by being present as a callable method and undeclared by being absent, so every reader takes the absent reading — the reach the adapter meant to declare is silently the old one. Fix the adapter — this is a wiring fault, not a supported way to leave the seat unset.`
+                : `The execution environment declares capabilities.${key} as a ${valueType}, not a boolean. What a reader makes of that is the reader's own business and differs between them — the containment readers take only the boolean, so this reads as undeclared, while the suspend reader takes any truthy value, so a non-empty string reads as TRUE. That is why a declaration of the wrong shape cannot pass quietly: the engine may act on something other than what the adapter meant. Fix the adapter — this is a wiring fault, not a supported way to leave the capability unset.`,
             detail: { key, valueType },
         });
     }

package/dist/core/runner/gate-exit.d.ts

@@ -251,6 +251,13 @@ export interface GatePass {
      *  leaves the call's boundary UNKNOWN: the allow layer (a stored allow rule, the read-only reader) must
      *  not clear the surviving ask — a person confirms it. Writer: the fold. Reader: the lanes' mandate. */
     probeUnanswered?: true;
+    /** borrowed-mutable — the write-protection judge covered this call and its table MATCHED: the allow
+     *  layer must not clear the surviving ask, a live decider still may. Writer: the fold's fourth tighten,
+     *  on BOTH its arms. Reader: the lanes' mandate. */
+    writeProtected?: true;
+    /** borrowed-mutable — the same judge could NOT RESOLVE the target: no automatic lane may answer the
+     *  ask. Writer and reader as above; the pair is mutually exclusive (one verdict per judgment). */
+    writeProtectionUnresolved?: true;
     /** borrowed-mutable — the rewrite remembered BEFORE a hook-ask promotion / tighten, re-applied on the
      *  approved path (a redaction is not cancelled because a person confirmed). Writer: the fold. Readers: the
      *  fold's probe and write-protection judges, the lanes, the allow exit. */

package/dist/core/runner/inherited-ask-grants.d.ts

@@ -33,6 +33,7 @@ export declare function consumeInheritedAskGrant(grants: Map<string, {
     argsJson: string;
     presented: unknown;
     waitMs: number;
+    settled?: object;
 }>, onAsk: OnAsk | undefined, humanReviewRef: {
     count: number;
     totalWaitMs: number;

package/dist/core/runner/inherited-ask-grants.js

@@ -1,5 +1,5 @@
 import { primaryActivityArg } from "../arg-summary.js";
-import { askApproverIdentity } from "../tool-policy.js";
+import { askApproverIdentity, carryEngineAttestations } from "../tool-policy.js";
 export function askGrantShapeOf(args) {
     try {
         return JSON.stringify(args ?? null);
@@ -25,5 +25,8 @@ export function consumeInheritedAskGrant(grants, onAsk, humanReviewRef, decision
         toolName: req.toolName,
         ...(toolArg !== undefined ? { toolArg } : {}),
     });
-    return { action: "allow", presentedInput: grant.presented };
+    const reused = { action: "allow", presentedInput: grant.presented };
+    if (grant.settled !== undefined)
+        carryEngineAttestations(grant.settled, reused);
+    return reused;
 }

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

@@ -15,9 +15,10 @@
 import type { Model } from "../../internal/llm.js";
 import type { Brain, ModelRoles, ModelRef, TaskSpec } from "../types.js";
 import { type DistillerChatFn } from "../memory-engine/distiller.js";
-import type { RunMemoryConsolidationOptions } from "../memory-engine/consolidation-driver.js";
-import type { MemoryConsolidationOptions } from "../memory-engine/consolidation.js";
+import { type RunMemoryConsolidationOptions, type ConsolidationDriverEngine } from "../memory-engine/consolidation-driver.js";
+import { type MemoryConsolidationOptions } from "../memory-engine/consolidation.js";
 import type { LlmDistillerContract } from "../memory-engine/distiller.js";
+import type { EngineNotice } from "../engine-notice.js";
 /** The slice of `RunnerDeps` this resolver reads (pass the deps object itself). */
 export interface MemoryConsolidationDriverDeps {
     brain: Brain;
@@ -47,3 +48,73 @@ export interface MemoryConsolidationDriverDeps {
  * coded here or in the verb's own screen, never folds to a default.
  */
 export declare function resolveMemoryConsolidationDriver(deps: MemoryConsolidationDriverDeps): RunMemoryConsolidationOptions;
+/**
+ * "Is there ANY model seat to resolve a consolidation run from?" (the question the
+ * `autoRunOnRecommendation` construction door asks). It mirrors {@link resolveMemoryConsolidationDriver}'s
+ * seat BRANCH — an explicit chat seat (function or endpoint triple) OR a resolvable
+ * `consolidate`/`summarize` role — WITHOUT the value validation (a present-but-alias model id is a
+ * DIFFERENT bad value, caught loudly by the driver's own screen when it runs). False ⇔ the resolve
+ * verb would throw its "no model seat" refusal. Pinned against that resolve for drift.
+ */
+export declare function consolidationSeatResolvable(deps: MemoryConsolidationDriverDeps): boolean;
+/**
+ * The advisory-to-execution bridge: fire ONE host consolidation run for the
+ * recommended `scope`, fire-and-forget. Called from the post-task settle tail (NOT the harvest tail)
+ * exactly once, only when {@link RunnerDeps.autoRunOnRecommendation} is armed AND the terminal
+ * harvest recommended consolidation. It NEVER throws and NEVER rejects: the driver's own R1–R7
+ * failure table settles the run (zero-write on mint failure, `_incomplete` on non-convergence), this
+ * bridge only relays the run's advisory notices to `onNotice` and routes a seat/engine fault to
+ * `onError(phase:"memory")`. Adds no failure semantics of its own — the trigger is the only new thing.
+ */
+export declare function autoRunConsolidationFromRecommendation(args: {
+    deps: MemoryConsolidationDriverDeps;
+    engine: ConsolidationDriverEngine;
+    scope: string;
+    sessionId: string;
+    onNotice?: (notice: EngineNotice) => void;
+    onError?: (err: unknown, ctx: {
+        phase: "memory";
+        sessionId: string;
+    }) => void;
+}): Promise<void>;
+/**
+ * THE shipped default for `RunnerDeps.autoRunOnRecommendation` when the seat is
+ * ABSENT: ON — the reference CLI's auto-dream form (auto-execute under the same 24h ∧ 5-session
+ * threshold gate the recommendation edge already uses; an explicit `false` is the deployment's off
+ * switch). One named value so the polarity is this one line; every sentence about the default names
+ * this constant rather than spelling a polarity. Read ONLY through {@link autoRunOnRecommendationEffective}.
+ */
+export declare const AUTO_RUN_ON_RECOMMENDATION_DEFAULT = true;
+/**
+ * The ONE resolver of "is auto-consolidation armed on this deployment", read by the
+ * prepare door's manifest fact and by the settle-tail trigger (never re-derived at a call site):
+ *  - explicit `true`  ⇒ armed (the door has already refused it unless it can run);
+ *  - explicit `false` ⇒ off — the deployment's own off switch, and it beats the default;
+ *  - ABSENT ⇒ {@link AUTO_RUN_ON_RECOMMENDATION_DEFAULT}, and ONLY where it can run (the protocol
+ *    switch wired AND a model seat resolvable) — the reference CLI's "auto-dream: off while
+ *    auto-memory is off": a default-on world must not arm a deployment that wired no consolidation;
+ *  - any other value ⇒ off (never arm on garbage; the door refuses it at prepare anyway).
+ */
+export declare function autoRunOnRecommendationEffective(deps: MemoryConsolidationDriverDeps & {
+    autoRunOnRecommendation?: unknown;
+}): boolean;
+/**
+ * The settle tail's ONE question: does this scope's gate row hold a recommendation
+ * that no completed run has consumed? Asked of the GATE ROW through the same predicate the
+ * recommendation edge is the negation of ({@link recommendationUnconsumed}) — never of a single
+ * harvest's report: a crossing recorded by an earlier checkpoint harvest of the same run, or by a
+ * session whose settle never fired, is still owed a run here. (The report-based reading stranded such
+ * a scope forever: the edge sat disarmed, nothing advanced `lastRunAt`.) A gate the engine cannot read
+ * answers `false` — the verbs would refuse loudly on it anyway.
+ */
+export declare function scopeHasUnconsumedRecommendation(engine: Pick<ConsolidationDriverEngine, "readConsolidationGate">, scope: string): boolean;
+/**
+ * The auto-consolidation ARMING door (bad-value loudness, three states), called from
+ * the prepare config doors at construction on every leg. A garbage value refuses; a CONTRADICTION
+ * (`true` with nothing to run) refuses — never folded to off, so an armed-but-unrunnable trigger (the
+ * invisible-failure family) cannot ship: a deployment learns at boot, not one silently dropped
+ * recommendation later. Lives beside {@link consolidationSeatResolvable}, the one question it asks.
+ */
+export declare function assertAutoConsolidationWirable(deps: MemoryConsolidationDriverDeps & {
+    autoRunOnRecommendation?: unknown;
+}): void;

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

@@ -1,6 +1,8 @@
 import { brainToRuntime } from "../runtime.js";
 import { expandTiers, roleModelIfSet } from "../roles.js";
 import { isAliasModelId, openAiCompatChatSeat } from "../memory-engine/distiller.js";
+import { runMemoryConsolidationDriver } from "../memory-engine/consolidation-driver.js";
+import { recommendationUnconsumed } from "../memory-engine/consolidation.js";
 function seatRefusal(message) {
     const e = new Error(message);
     e.code = "config.memory_consolidation_driver";
@@ -58,3 +60,58 @@ export function resolveMemoryConsolidationDriver(deps) {
         ...(deps.memoryConsolidation !== undefined ? { consolidation: deps.memoryConsolidation } : {}),
     };
 }
+export function consolidationSeatResolvable(deps) {
+    if (deps.memoryConsolidationDriver?.chat !== undefined)
+        return true;
+    const models = expandTiers(deps.models, deps.tiers);
+    return (roleModelIfSet("consolidate", {}, { models, roles: deps.roles }) ?? roleModelIfSet("summarize", {}, { models, roles: deps.roles })) !== undefined;
+}
+export function autoRunConsolidationFromRecommendation(args) {
+    const { deps, engine, scope, sessionId, onNotice, onError } = args;
+    return (async () => {
+        try {
+            await runMemoryConsolidationDriver(engine, scope, { ...resolveMemoryConsolidationDriver(deps), onNotice });
+        }
+        catch (err) {
+            try {
+                onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "memory", sessionId });
+            }
+            catch {
+            }
+        }
+    })();
+}
+export const AUTO_RUN_ON_RECOMMENDATION_DEFAULT = true;
+export function autoRunOnRecommendationEffective(deps) {
+    const raw = deps.autoRunOnRecommendation;
+    if (raw === true)
+        return true;
+    if (raw !== undefined)
+        return false;
+    return AUTO_RUN_ON_RECOMMENDATION_DEFAULT && deps.memoryConsolidation !== undefined && consolidationSeatResolvable(deps);
+}
+export function scopeHasUnconsumedRecommendation(engine, scope) {
+    const row = engine.readConsolidationGate(scope);
+    return row !== undefined && recommendationUnconsumed(row);
+}
+function autoRunRefusal(message) {
+    const e = new Error(message);
+    e.code = "config.auto_consolidation";
+    return e;
+}
+export function assertAutoConsolidationWirable(deps) {
+    const raw = deps.autoRunOnRecommendation;
+    if (raw === undefined)
+        return;
+    if (typeof raw !== "boolean") {
+        throw autoRunRefusal(`RunnerDeps.autoRunOnRecommendation must be a boolean when present (got ${JSON.stringify(raw)}) — a non-boolean would silently read as off, arming or disarming whole-library egress by accident.`);
+    }
+    if (raw !== true)
+        return;
+    if (deps.memoryConsolidation === undefined) {
+        throw autoRunRefusal("RunnerDeps.autoRunOnRecommendation is true but RunnerDeps.memoryConsolidation is absent — the recommendation that would trigger a run is never minted (consolidation is OFF) and the engine's verbs refuse coded, so the trigger can never fire. An armed-but-unrunnable trigger is refused, never folded to off: wire memoryConsolidation, or leave autoRunOnRecommendation unset.");
+    }
+    if (!consolidationSeatResolvable(deps)) {
+        throw autoRunRefusal("RunnerDeps.autoRunOnRecommendation is true but no consolidation model seat resolves — configure RunnerDeps.memoryConsolidationDriver.chat (an endpoint triple or a chat function), or declare roles.consolidate / roles.summarize. Arming auto-run with no model to run it is refused, never folded to off (a whole-library distillation must not silently ride the default main model).");
+    }
+}

package/dist/core/runner/prepare-config-doors.js

@@ -3,6 +3,7 @@ import { assertContainmentFaceValue } from "../../tools/fs/index.js";
 import { MICRO_COMPACT_MACHINES } from "../context-edit.js";
 import { assertNoRetiredRunnerDeps } from "./retired-runner-deps.js";
 import { resolveCheckpointStore } from "../checkpoint-store.js";
+import { assertAutoConsolidationWirable } from "./memory-consolidation-driver.js";
 import { isModelPriced, malformedPricingField, modelCostToPricing } from "../pricing.js";
 import { preflightLockedConfig } from "../locked-config.js";
 import { assertRetentionCapability } from "../retention.js";
@@ -237,6 +238,7 @@ export function prepareConfigDoors(input) {
         throw e;
     }
     const memoryCapturePolicy = memoryCapturePolicyRaw === "governed" ? "governed" : memoryCapturePolicyRaw === "capture-required" ? "capture-required" : "open";
+    assertAutoConsolidationWirable(deps);
     if (spec.resumeAtMode !== undefined) {
         if (spec.resumeAt === undefined) {
             const e = new Error(`resumeAtMode "${spec.resumeAtMode}" requires resumeAt (there is no branch target to position against)`);

package/dist/core/runner/prepare-policy-chain.d.ts

@@ -155,6 +155,7 @@ export interface PreparePolicyChainResult {
         argsJson: string;
         presented: unknown;
         waitMs: number;
+        settled?: object;
     }>;
     /** owned — the SINGLE AskRequest source-identity factory every resolveAsk construction site spreads. */
     askSourceIdentity: () => {

package/dist/core/runner/prepare-policy-chain.js

@@ -152,7 +152,7 @@ export async function preparePolicyChain(input) {
     }, "mandate_unreconstructible", creq);
     const markerChannelFullDeny = (creq) => attestAskUnresolvableCause({ action: "deny", message: `no approver is reachable for the inherited approval of "${creq.toolName}" and the marker channel is at capacity — denied fail-closed` }, "approver_unavailable", creq);
     const inheritedAskGrants = new Map();
-    const recordInheritedAskGrant = (toolCallId, approver, presented, waitMs) => {
+    const recordInheritedAskGrant = (toolCallId, approver, presented, waitMs, settled) => {
         if (typeof approver !== "function")
             return;
         if (presented === undefined)
@@ -162,7 +162,7 @@ export async function preparePolicyChain(input) {
         const argsJson = askGrantShapeOf(presented);
         if (argsJson === undefined)
             return;
-        inheritedAskGrants.set(toolCallId, { approver, argsJson, presented, waitMs });
+        inheritedAskGrants.set(toolCallId, { approver, argsJson, presented, waitMs, settled });
     };
     const sandboxDeclared = isIsolated(executionEnv);
     const sandboxAdmissionArmed = (() => {
@@ -277,37 +277,51 @@ export async function preparePolicyChain(input) {
         cwdRef: handsCwdRef,
         deniesDirectoryRead: readDenyMatcher !== undefined ? (d) => readDenyMatcher.matchPath(d) !== null : undefined,
     });
-    const recheckApprovedEdit = async (pol, onAskOf, creq, edit, csignal, ancestorDecider, ancestorTracker) => {
+    const recheckApprovedEdit = async (pol, onAskOf, creq, edit, approved, csignal, ancestorDecider, ancestorTracker) => {
         let editArgs = edit;
+        let settledBy = approved;
+        const vetoed = (d) => {
+            const out = { ...d };
+            carryEngineAttestations(d, out);
+            carryPrecedingSettlement(settledBy, out);
+            return out;
+        };
         for (let round = 0;; round++) {
             if (round >= 3) {
-                return {
+                return vetoed({
                     action: "deny",
                     message: `the approval-edit chain for "${creq.toolName}" exceeded the re-approval cap (inherited parent policy) — denied fail-closed; re-submit the edited action directly`,
-                };
+                });
             }
             let re;
             try {
                 re = await pol.check({ ...creq, args: editArgs }, csignal ?? abortController.signal);
             }
             catch (err) {
-                return {
+                return vetoed({
                     action: "deny",
                     message: `inherited parent policy re-check of the approved edit errored for "${creq.toolName}": ${err instanceof Error ? err.message : String(err)}`,
-                };
+                });
             }
             if (re.action === "deny")
-                return re;
+                return vetoed(re);
             if (re.action === "allow") {
-                return { action: "allow", updatedInput: re.updatedInput !== undefined ? re.updatedInput : editArgs };
+                const out = { action: "allow", updatedInput: re.updatedInput !== undefined ? re.updatedInput : editArgs };
+                carryEngineAttestations(re, out);
+                carryPrecedingSettlement(settledBy, out);
+                return out;
             }
             if (re.updatedInput !== undefined)
                 editArgs = re.updatedInput;
             const judged = await judgeInheritedClassifier({ autoMode: ancestorDecider !== undefined ? { decider: ancestorDecider, denialTracking: ancestorTracker } : undefined, ask: re, req: { ...creq, args: editArgs }, signal: csignal ?? abortController.signal, subject: "the approved edit", allowRewrite: editArgs });
-            if (judged.kind === "allow")
-                return judged.result;
+            if (judged.kind === "allow") {
+                const cleared = { ...judged.result };
+                carryEngineAttestations(judged.result, cleared);
+                carryPrecedingSettlement(settledBy, cleared);
+                return cleared;
+            }
             if (judged.kind === "deny")
-                return judged.result;
+                return vetoed(judged.result);
             const { ask: editAsk, fallback: editFallback, mintedHere: editMintedHere } = judged;
             re = editAsk;
             const rr = await resolveAsk({
@@ -326,8 +340,12 @@ export async function preparePolicyChain(input) {
             settleDenialLimitFallback({ fallback: editFallback, mintedHere: editMintedHere, tracker: ancestorTracker, resolved: rr, headless: headlessDenyAtRecheck, stop: stopForDenialLimit, toolName: creq.toolName, toolCallId: creq.toolCallId });
             if (rr.action !== "allow")
                 return rr;
-            if (rr.updatedInput === undefined)
-                return { action: "allow", updatedInput: editArgs };
+            settledBy = rr;
+            if (rr.updatedInput === undefined) {
+                const out = { action: "allow", updatedInput: editArgs };
+                carryPrecedingSettlement(rr, out);
+                return out;
+            }
             editArgs = rr.updatedInput;
         }
     };
@@ -404,9 +422,9 @@ export async function preparePolicyChain(input) {
                     if (resolved.action !== "allow")
                         return resolved;
                     if (resolved.updatedInput !== undefined) {
-                        return recheckApprovedEdit(pc.policy, pc.onAsk, creq, resolved.updatedInput, csignal, pc.autoMode?.decider, pc.autoMode?.denialTracking);
+                        return recheckApprovedEdit(pc.policy, pc.onAsk, creq, resolved.updatedInput, resolved, csignal, pc.autoMode?.decider, pc.autoMode?.denialTracking);
                     }
-                    recordInheritedAskGrant(creq.toolCallId, pc.onAsk, resolved.presentedInput, askWaitMs);
+                    recordInheritedAskGrant(creq.toolCallId, pc.onAsk, resolved.presentedInput, askWaitMs, resolved);
                     return { action: "allow" };
                 },
             }
@@ -473,12 +491,16 @@ export async function preparePolicyChain(input) {
                     if (resolved.action !== "allow")
                         return resolved;
                     if (resolved.updatedInput !== undefined) {
-                        return recheckApprovedEdit(pc.policy, pc.onAsk, creq, resolved.updatedInput, csignal, pc.autoMode?.decider, pc.autoMode?.denialTracking);
+                        return recheckApprovedEdit(pc.policy, pc.onAsk, creq, resolved.updatedInput, resolved, csignal, pc.autoMode?.decider, pc.autoMode?.denialTracking);
                     }
                     if (pc.preToolUse === undefined) {
-                        recordInheritedAskGrant(creq.toolCallId, pc.onAsk, resolved.presentedInput, askWaitMs);
+                        recordInheritedAskGrant(creq.toolCallId, pc.onAsk, resolved.presentedInput, askWaitMs, resolved);
                     }
-                    return decision.updatedInput !== undefined ? { ...resolved, updatedInput: decision.updatedInput } : resolved;
+                    if (decision.updatedInput === undefined)
+                        return resolved;
+                    const approvedWithRewrite = { ...resolved, updatedInput: decision.updatedInput };
+                    carryEngineAttestations(resolved, approvedWithRewrite);
+                    return approvedWithRewrite;
                 },
             });
     const rewriteCapableLayers = policy !== undefined || parentConstraintWrappers.length > 0;
@@ -540,6 +562,7 @@ export async function preparePolicyChain(input) {
                 const recheckLayers = [...recheckPrefix, ...postEmitterSameInstanceAdapters];
                 const finalReq = { ...req, args: decision.updatedInput };
                 let asked;
+                const revalidated = {};
                 try {
                     for (const layer of recheckLayers) {
                         const d = await layer.check(finalReq, signal);
@@ -558,13 +581,22 @@ export async function preparePolicyChain(input) {
                         }
                         if (d.action === "ask" && asked === undefined)
                             asked = d;
+                        carryEngineAttestations(d, revalidated);
                     }
                 }
                 finally {
                     rewriteEmitterIndex.delete(req.toolCallId);
                 }
                 if (asked !== undefined && decision.action === "allow") {
-                    return { ...asked, updatedInput: decision.updatedInput };
+                    const surfaced = { ...asked, updatedInput: decision.updatedInput };
+                    carryEngineAttestations(asked, surfaced);
+                    return surfaced;
+                }
+                if (decision.action === "allow") {
+                    const owned = { ...decision };
+                    carryEngineAttestations(decision, owned);
+                    carryEngineAttestations(revalidated, owned);
+                    return owned;
                 }
                 return decision;
             },

package/dist/core/runner/prepare-wiring-manifest.js

@@ -8,6 +8,7 @@ import { durableMandateSourceOf, isLiveApproverSeat } from "../tool-policy.js";
 import { deliverEngineNotice } from "../types.js";
 import { inlineUntrusted } from "../untrusted-text.js";
 import { mountWriteProtection } from "./write-protection-station.js";
+import { autoRunOnRecommendationEffective } from "./memory-consolidation-driver.js";
 import { GLOBAL_USAGE_KEY, usageRetryAfterMs, windowsGovernCost } from "../usage-window-store.js";
 import { LSP_CONTRACT_ID, countElicitOptIns, deriveLspSeam, deriveWiringManifest, resolveAskSeamForm, resolveDeclaredDurability, resolveElicitSeam, resolveQuestionSeam, resolveSubagentTranscriptTier } from "../wiring-manifest.js";
 import { DEFAULT_IRREVERSIBLE_SCOPE } from "./checkpoint-scope.js";
@@ -207,6 +208,7 @@ export function prepareWiringManifest(input) {
         autoMode: { ...autoModeArmReason },
         mcp: mcpManifestEntries(lockedPreflight.mcp, mcp.statuses),
         ...(writeProtection !== undefined ? { writeProtectionTargetView: writeProtection.targetView } : {}),
+        autoConsolidationOnRecommendation: autoRunOnRecommendationEffective(deps),
         tools: toolRoster,
         hooks: wiredHookEntries(hooks, spec.hooks !== undefined ? "spec" : "deps", preToolUseObservational),
         ...(lspManagerWired ? { lsp: deriveLspSeam(toolRoster.entries.some((e) => e.contract.contractId === LSP_CONTRACT_ID), lspDiagnosticsLive) } : {}),

package/dist/core/runner/run-settle-and-teardown.js

@@ -18,6 +18,7 @@ import { resumeDecisionWasNegative } from "./decide-continuation.js";
 import { drainForwardedFramesBeforeDone, forwardsSubagentEvents } from "./prepare-run-refs.js";
 import { generatePromptSuggestions } from "./prompt-suggestions.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
+import { autoRunConsolidationFromRecommendation, autoRunOnRecommendationEffective, scopeHasUnconsumedRecommendation } from "./memory-consolidation-driver.js";
 import { amendTerminal, terminalProjection } from "./terminal-projection.js";
 export async function runSettleAndTeardown(input) {
     const { spec, queue, prepared, resume, internals, rs, stats, ident, parentToolCallId, subagentName, loopLatch, timeout, ownCommittedTailRef, emitDelegationLifecycle, taskIdRef, manualCompactRef, drainManualCompact, final, threw, abortedLive, userInterruptedLive, answerSettled, strandedHumanAnswers, reasoningResolution, comp, setResult, onSuggestions, onSuspend, runner, sessions } = input;
@@ -240,6 +241,10 @@ export async function runSettleAndTeardown(input) {
         if (prepared.memoryEngineSession) {
             const mes = prepared.memoryEngineSession;
             await settleTeardownLeg(() => mes.harvest(), "memoryEngineSession.harvest (settle leg)", (e) => runner.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
+            const scope = mes.handle.writeScope;
+            if (scope !== null && autoRunOnRecommendationEffective(runner.deps) && scopeHasUnconsumedRecommendation(mes.engine, scope)) {
+                void autoRunConsolidationFromRecommendation({ deps: runner.deps, engine: mes.engine, scope, sessionId: prepared.sessionId, onNotice: runner.deps.onNotice, onError: runner.deps.onError });
+            }
         }
         emitTrace(rs.telemetry.tracer, () => ({
             kind: "task.end",