@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/session/request-session.js

@@ -37,6 +37,7 @@ export async function initializeRequestSession(params) {
             ? { attachments: params.opened.attachments }
             : {}),
     });
+    params.onUserMessagePersisted?.();
     params.events.event("session.messages.updated", {
         sessionId: params.sessionId,
     });

package/dist/src/runtime/session/session-deletion-boundary.d.ts

@@ -3,7 +3,7 @@ import type { SessionStore } from "../ports.js";
 import { type SessionDeletionFinalizer } from "./session-deletion-finalization.js";
 import type { SessionMutationQueue } from "./session-mutation-queue.js";
 /** Shared transaction for managed stores and compatibility deletion adapters. */
-export declare function createSessionDeletionBoundary(base: Pick<SessionStore, "deleteSessionWithStats">, enqueue: SessionMutationQueue, finalize?: SessionDeletionFinalizer): {
+export declare function createSessionDeletionBoundary(base: Pick<SessionStore, "deleteSessionWithStats">, enqueue: SessionMutationQueue, finalize?: SessionDeletionFinalizer, beforeDelete?: (sessionId: string) => Promise<void>): {
     deleteSessionWithStats: (sessionId: string) => Promise<SessionDeleteResult>;
     isDeleted: (sessionId: string) => boolean;
     onDeleted: (listener: import("./session-deletion-cleanup.js").SessionDeletionListener) => () => void;

package/dist/src/runtime/session/session-deletion-boundary.js

@@ -3,7 +3,7 @@ import { createSessionDeletionCleanup } from "./session-deletion-cleanup.js";
 import { createSessionDeletionFinalization, } from "./session-deletion-finalization.js";
 import { createSessionDeletionReceipts } from "./session-deletion-receipts.js";
 /** Shared transaction for managed stores and compatibility deletion adapters. */
-export function createSessionDeletionBoundary(base, enqueue, finalize) {
+export function createSessionDeletionBoundary(base, enqueue, finalize, beforeDelete) {
     const cleanup = createSessionDeletionCleanup();
     const receipts = createSessionDeletionReceipts(base);
     const finalization = finalize
@@ -11,13 +11,17 @@ export function createSessionDeletionBoundary(base, enqueue, finalize) {
         : undefined;
     if (finalization)
         cleanup.onDeleted(finalization.finalizeDeletedSession);
+    async function removePhysicalSession(sessionId) {
+        await beforeDelete?.(sessionId);
+        return receipts.remove(sessionId);
+    }
     async function deleteSessionWithStats(sessionId) {
         assertValidSessionId(sessionId);
         const settlePhysical = finalization?.prepare(sessionId);
         let notification;
         // Reserve before invoking listeners: synchronous reentry must queue behind us.
         const result = enqueue(sessionId, async () => {
-            const [deletion] = await Promise.allSettled([receipts.remove(sessionId)]);
+            const [deletion] = await Promise.allSettled([removePhysicalSession(sessionId)]);
             settlePhysical?.(deletion);
             const [notified] = await notification;
             if (deletion.status === "rejected")

package/dist/src/runtime/session/session-lifecycle-store.d.ts

@@ -1,6 +1,7 @@
 import type { SessionStore } from "../ports.js";
 import type { SessionDeletionListener } from "./session-deletion-cleanup.js";
 import type { SessionDeletionFinalizer } from "./session-deletion-finalization.js";
+import type { SessionClearBoundary } from "./spark-session-clear.js";
 export type { SessionDeletionListener } from "./session-deletion-cleanup.js";
 export declare class SessionDeletedError extends Error {
     readonly sessionId: string;
@@ -18,4 +19,6 @@ export type SessionLifecycleStore = Readonly<{
  * an in-flight write finishes before deletion, while queued and later writes fail.
  * Tombstones last for this application lifetime; deleted IDs cannot be reused.
  */
-export declare function createSessionLifecycleStore(base: SessionStore, finalizeDeletion?: SessionDeletionFinalizer): SessionLifecycleStore;
+export declare function createSessionLifecycleStore(base: SessionStore, finalizeDeletion?: SessionDeletionFinalizer, 
+/** Runs inside the deletion queue after the tombstone, before the transcript is removed. */
+beforeDelete?: (sessionId: string) => Promise<void>, clearBoundary?: SessionClearBoundary): SessionLifecycleStore;

package/dist/src/runtime/session/session-lifecycle-store.js

@@ -17,9 +17,11 @@ export function isSessionDeletedError(error) {
  * an in-flight write finishes before deletion, while queued and later writes fail.
  * Tombstones last for this application lifetime; deleted IDs cannot be reused.
  */
-export function createSessionLifecycleStore(base, finalizeDeletion) {
+export function createSessionLifecycleStore(base, finalizeDeletion, 
+/** Runs inside the deletion queue after the tombstone, before the transcript is removed. */
+beforeDelete, clearBoundary) {
     const enqueueSessionMutation = createSessionMutationQueue();
-    const deletion = createSessionDeletionBoundary(base, enqueueSessionMutation, finalizeDeletion);
+    const deletion = createSessionDeletionBoundary(base, enqueueSessionMutation, finalizeDeletion, beforeDelete);
     function assertSessionNotDeleted(sessionId) {
         if (deletion.isDeleted(sessionId)) {
             throw new SessionDeletedError(sessionId);
@@ -35,6 +37,21 @@ export function createSessionLifecycleStore(base, finalizeDeletion) {
         };
     }
     const store = {
+        ...(base.assertInteractiveSession
+            ? { assertInteractiveSession: base.assertInteractiveSession.bind(base) }
+            : {}),
+        ...(base.createAutomationSession
+            ? {
+                createAutomationSession: wrapSessionMutation(base.createAutomationSession),
+            }
+            : {}),
+        ...(base.runAsAutomationSession
+            ? { runAsAutomationSession: base.runAsAutomationSession.bind(base) }
+            : {}),
+        ...(base.releaseAutomationSession
+            ? { releaseAutomationSession: base.releaseAutomationSession.bind(base) } : {}),
+        ...(base.reconcileAutomationSessions
+            ? { reconcileAutomationSessions: base.reconcileAutomationSessions.bind(base) } : {}),
         ...(base.requestLifecycle
             ? {
                 requestLifecycle: {
@@ -55,6 +72,9 @@ export function createSessionLifecycleStore(base, finalizeDeletion) {
             }
             : {}),
         getAllSessions: base.getAllSessions.bind(base),
+        ...(base.appendAssistantInitiative
+            ? { appendAssistantInitiative: wrapSessionMutation(base.appendAssistantInitiative) }
+            : {}),
         listSessions: base.listSessions.bind(base),
         getSessionById: base.getSessionById.bind(base),
         getSessionSnapshot: base.getSessionSnapshot.bind(base),
@@ -65,8 +85,8 @@ export function createSessionLifecycleStore(base, finalizeDeletion) {
         startRequestStream: wrapSessionMutation(base.startRequestStream),
         appendRequestEvent: wrapSessionMutation(base.appendRequestEvent),
         compareAndSwapSessionMemoryCheckpoint: wrapSessionMutation(base.compareAndSwapSessionMemoryCheckpoint),
-        resetSession: wrapSessionMutation(base.resetSession),
-        clearSessionMessages: wrapSessionMutation(base.clearSessionMessages),
+        resetSession: wrapSessionClear(base.resetSession),
+        clearSessionMessages: wrapSessionClear(base.clearSessionMessages),
         deleteMessage: wrapSessionMutation(base.deleteMessage),
         deleteMessageWithStats: wrapSessionMutation(base.deleteMessageWithStats),
         deleteSession: async (sessionId) => (await deletion.deleteSessionWithStats(sessionId)).deleted,
@@ -88,4 +108,12 @@ export function createSessionLifecycleStore(base, finalizeDeletion) {
         isDeleted: deletion.isDeleted,
         onDeleted: deletion.onDeleted,
     };
+    function wrapSessionClear(operation) {
+        const mutate = wrapSessionMutation(operation);
+        return (sessionId) => {
+            if (!clearBoundary)
+                return mutate(sessionId);
+            return clearBoundary(sessionId, () => mutate(sessionId));
+        };
+    }
 }

package/dist/src/runtime/session/spark-session-attachments.d.ts

@@ -0,0 +1,4 @@
+import type { SessionRecord } from "../../sessions/types.js";
+import type { RuntimeAttachmentStore } from "../attachments/store.js";
+/** Capture only transcript-owned files; a simultaneous new upload is a different reference. */
+export declare function prepareSparkAttachmentCleanup(attachments: RuntimeAttachmentStore | undefined, session: SessionRecord | null, runtimeDirectory?: string): Promise<() => Promise<void>>;

package/dist/src/runtime/session/spark-session-attachments.js

@@ -0,0 +1,28 @@
+import { createSparkCleanupReceipt } from "./spark-session-cleanup-receipt.js";
+/** Capture only transcript-owned files; a simultaneous new upload is a different reference. */
+export async function prepareSparkAttachmentCleanup(attachments, session, runtimeDirectory) {
+    const receipt = runtimeDirectory ? createSparkCleanupReceipt(runtimeDirectory) : undefined;
+    const pending = await receipt?.read() ?? [];
+    const captured = (session?.messages ?? []).flatMap((message) => message.attachments ?? []);
+    const references = [...new Map([...pending, ...captured]
+            .map((attachment) => [attachment.storageRef, attachment])).values()];
+    if (references.length === 0)
+        return async () => { };
+    const deleteAttachment = attachments?.deleteAttachment?.bind(attachments);
+    if (!deleteAttachment)
+        throw new Error("spark_chat_attachment_cleanup_unavailable");
+    if (!receipt)
+        throw new Error("spark_chat_cleanup_receipt_unavailable");
+    // Persist before transcript removal. A failed deletion never loses its retry reference.
+    await receipt.save(references);
+    return async () => {
+        const outcomes = await Promise.allSettled(references.map((reference) => deleteAttachment(reference, { sessionId: session.id })));
+        const failed = outcomes.find(isAttachmentCleanupFailure);
+        if (failed)
+            throw failed.reason;
+        await receipt.complete();
+    };
+}
+function isAttachmentCleanupFailure(outcome) {
+    return outcome.status === "rejected";
+}

package/dist/src/runtime/session/spark-session-cleanup-receipt.d.ts

@@ -0,0 +1,7 @@
+import { type RuntimeAttachmentReference } from "../attachments/store.js";
+/** Exact pending deletions, accessed only while the owner holds SPARK admission. */
+export declare function createSparkCleanupReceipt(runtimeDirectory: string): {
+    read(): Promise<RuntimeAttachmentReference[]>;
+    save(references: RuntimeAttachmentReference[]): Promise<void>;
+    complete(): Promise<void>;
+};

package/dist/src/runtime/session/spark-session-cleanup-receipt.js

@@ -0,0 +1,61 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, open, readFile, rename, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { syncSessionDirectory } from "../../sessions/durable-session-commit.js";
+import { SPARK_SESSION_ID } from "../../sessions/spark-session.js";
+import { parseRuntimeAttachmentReferences } from "../attachments/store.js";
+function isMissingCleanupReceipt(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function parseCleanupReceipt(value) {
+    if (!value || typeof value !== "object")
+        throw new Error("spark_chat_cleanup_receipt_invalid");
+    if (!("schemaVersion" in value) || value.schemaVersion !== 1)
+        throw new Error("spark_chat_cleanup_receipt_invalid");
+    if (!("sessionId" in value) || value.sessionId !== SPARK_SESSION_ID)
+        throw new Error("spark_chat_cleanup_receipt_invalid");
+    if (!("references" in value) || !Array.isArray(value.references))
+        throw new Error("spark_chat_cleanup_receipt_invalid");
+    return parseRuntimeAttachmentReferences(value.references);
+}
+/** Exact pending deletions, accessed only while the owner holds SPARK admission. */
+export function createSparkCleanupReceipt(runtimeDirectory) {
+    const directory = join(runtimeDirectory, "spark-chat");
+    const path = join(directory, "attachment-cleanup.json");
+    return {
+        async read() {
+            try {
+                return parseCleanupReceipt(JSON.parse(await readFile(path, "utf8")));
+            }
+            catch (error) {
+                if (isMissingCleanupReceipt(error))
+                    return [];
+                throw error;
+            }
+        },
+        async save(references) {
+            await mkdir(directory, { recursive: true, mode: 0o700 });
+            await syncSessionDirectory(dirname(directory));
+            const temporary = `${path}.${randomUUID()}.tmp`;
+            try {
+                const handle = await open(temporary, "wx", 0o600);
+                try {
+                    await handle.writeFile(JSON.stringify({ schemaVersion: 1, sessionId: SPARK_SESSION_ID, references }));
+                    await handle.sync();
+                }
+                finally {
+                    await handle.close();
+                }
+                await rename(temporary, path);
+                await syncSessionDirectory(directory);
+            }
+            finally {
+                await rm(temporary, { force: true }).catch(() => undefined);
+            }
+        },
+        async complete() {
+            await rm(path, { force: true });
+            await syncSessionDirectory(directory);
+        },
+    };
+}

package/dist/src/runtime/session/spark-session-clear.d.ts

@@ -0,0 +1,6 @@
+import type { SessionStore } from "../ports.js";
+import type { SessionRequestAdmission } from "../request/session-admission.js";
+import type { RuntimeAttachmentStore } from "../attachments/store.js";
+export type SessionClearBoundary = <T>(sessionId: string, clear: () => Promise<T>) => Promise<T>;
+/** Protect the permanent conversation without changing ordinary session clearing. */
+export declare function createSparkSessionClearBoundary(sessions: Pick<SessionStore, "getSessionById" | "requestLifecycle">, admission: () => SessionRequestAdmission, attachments?: RuntimeAttachmentStore, runtimeDirectory?: string): SessionClearBoundary;

package/dist/src/runtime/session/spark-session-clear.js

@@ -0,0 +1,36 @@
+import { isSparkSession, SPARK_SESSION_ID } from "../../sessions/spark-session.js";
+import { prepareSparkAttachmentCleanup } from "./spark-session-attachments.js";
+/** Protect the permanent conversation without changing ordinary session clearing. */
+export function createSparkSessionClearBoundary(sessions, admission, attachments, runtimeDirectory) {
+    return async (sessionId, clear) => {
+        if (!(await isCompanionClear(sessions, sessionId)))
+            return clear();
+        const release = admission().tryReserve(sessionId);
+        if (!release)
+            throw new Error("spark_chat_busy");
+        try {
+            // Recheck after reservation: a parked request is idle but its saved wait remains active.
+            if (await hasSavedCompanionApproval(sessions, sessionId))
+                throw new Error("spark_chat_busy");
+            const cleanup = await prepareSparkAttachmentCleanup(attachments, await sessions.getSessionById(sessionId), runtimeDirectory);
+            const result = await clear();
+            await cleanup();
+            return result;
+        }
+        finally {
+            release();
+        }
+    };
+}
+async function isCompanionClear(sessions, sessionId) {
+    if (sessionId !== SPARK_SESSION_ID)
+        return false;
+    const session = await sessions.getSessionById(sessionId);
+    if (!session)
+        return false;
+    return isSparkSession(session);
+}
+async function hasSavedCompanionApproval(sessions, sessionId) {
+    const waiting = await sessions.requestLifecycle?.listWaiting(sessionId);
+    return (waiting?.length ?? 0) > 0;
+}

package/dist/src/runtime/session/terminal-response.d.ts

@@ -0,0 +1,21 @@
+import type { SessionTerminalMessage } from "../../sessions/request-lifecycle/contracts.js";
+import type { AgentMode } from "../../shared/types.js";
+import type { RequestSessionStore } from "../request/session-store.js";
+/** One non-durable terminal append. A rejected write has an uncertain outcome. */
+export declare class TerminalResponseAppend {
+    private readonly params;
+    private attempted;
+    private persisted;
+    constructor(params: {
+        store: Pick<RequestSessionStore, "appendMessage">;
+        sessionId: string;
+        requestId: string;
+        agentMode: AgentMode;
+    });
+    snapshot(): Readonly<{
+        attempted: boolean;
+        persisted: boolean;
+    }>;
+    failureOutcome(error: unknown): "persisted" | "session_deleted" | "uncertain";
+    append(message: SessionTerminalMessage): Promise<void>;
+}

package/dist/src/runtime/session/terminal-response.js

@@ -0,0 +1,38 @@
+import { isSessionDeletedError } from "./session-lifecycle-store.js";
+/** One non-durable terminal append. A rejected write has an uncertain outcome. */
+export class TerminalResponseAppend {
+    params;
+    attempted = false;
+    persisted = false;
+    constructor(params) {
+        this.params = params;
+    }
+    snapshot() {
+        return Object.freeze({
+            attempted: this.attempted,
+            persisted: this.persisted,
+        });
+    }
+    failureOutcome(error) {
+        if (!this.attempted)
+            return "uncertain";
+        if (this.persisted)
+            return "persisted";
+        if (isSessionDeletedError(error) &&
+            error.sessionId === this.params.sessionId)
+            return "session_deleted";
+        return "uncertain";
+    }
+    async append(message) {
+        if (this.attempted)
+            throw new Error("terminal_response_append_already_attempted");
+        this.attempted = true;
+        const { content, ...metadata } = message;
+        await this.params.store.appendMessage(this.params.sessionId, "assistant", content, {
+            ...metadata,
+            lastAgentMode: this.params.agentMode,
+            requestId: this.params.requestId,
+        });
+        this.persisted = true;
+    }
+}

package/dist/src/runtime/steps/auditor-decision/advisory-receipt.d.ts

@@ -9,6 +9,7 @@ export type AuditorAdvisoryReceipt = Readonly<{
         kind: typeof EVIDENCE_BINDING_KIND;
         workFingerprint: string;
         selectedEvidenceIds: readonly string[];
+        compactedEvidenceIds?: readonly string[];
         bundleFingerprint: string | null;
     }>;
 }>;

package/dist/src/runtime/steps/auditor-decision/advisory-receipt.js

@@ -66,6 +66,13 @@ export function readAuditorAdvisoryReceipt(summary) {
         return undefined;
     if (!isStringArray(source.selectedEvidenceIds))
         return undefined;
+    if (source.compactedEvidenceIds !== undefined) {
+        if (!isStringArray(source.compactedEvidenceIds))
+            return undefined;
+        const selected = new Set(source.selectedEvidenceIds);
+        if (source.compactedEvidenceIds.some((id) => !selected.has(id)))
+            return undefined;
+    }
     const expectedBundle = source.selectedEvidenceIds.length > 0
         ? fingerprintAuditorBundle(source.workFingerprint, source.selectedEvidenceIds)
         : null;
@@ -74,10 +81,15 @@ export function readAuditorAdvisoryReceipt(summary) {
     return value;
 }
 function binding(assignment) {
+    const compactedIds = new Set(assignment.compactedSourceEvidence?.sources.map((source) => source.executionId));
+    const compactedEvidenceIds = assignment.selectedEvidenceIds.filter((id) => compactedIds.has(id));
     return Object.freeze({
         kind: EVIDENCE_BINDING_KIND,
         workFingerprint: assignment.workFingerprint,
         selectedEvidenceIds: assignment.selectedEvidenceIds,
+        ...(compactedEvidenceIds.length > 0
+            ? { compactedEvidenceIds: Object.freeze(compactedEvidenceIds) }
+            : {}),
         bundleFingerprint: assignment.selectedEvidenceIds.length > 0
             ? fingerprintAuditorBundle(assignment.workFingerprint, assignment.selectedEvidenceIds)
             : null,

package/dist/src/runtime/steps/auditor-decision/contracts.d.ts

@@ -1,3 +1,4 @@
+import type { ExecutionCompactedSources } from "../../context/execution-compacted-evidence.js";
 import type { CapabilityAdapterResult } from "../../orchestration/capability-adapters/index.js";
 export declare const AUDITOR_DECISION_MODEL_STEP: "auditor.decision";
 export declare const EXECUTION_AGENT_ROOT_AUDIT_CRITERION_ID: "request_completion";
@@ -48,6 +49,8 @@ export type AuditorEvidenceInventoryEntry = Readonly<{
     referenceCount: number;
     omittedReferencePreviewCount: number;
     exactEvidenceChars: number;
+    evidencePresentation?: "compacted";
+    projectedEvidenceChars?: number;
     evidenceFingerprint: string;
 }>;
 export type AuditorAssignment = Readonly<{
@@ -64,6 +67,7 @@ export type AuditorAssignment = Readonly<{
     reviewedEvidenceBundles: readonly (readonly string[])[];
     pendingEvidenceIds: readonly string[] | null;
     evidence: readonly AuditorEvidence[];
+    compactedSourceEvidence?: ExecutionCompactedSources;
     availableEvidenceCount: number;
     omittedEvidenceCount: number;
 }>;

package/dist/src/runtime/steps/auditor-decision/evidence-coverage.js

@@ -12,13 +12,13 @@ export function validateAuditorEvidenceCoverage(value, assignment) {
     if (!isEmptyEvidenceRequest(value.requestedEvidenceIds)) {
         return issue("auditor_unexpected_evidence_request", "Only needs_evidence may request another bundle.");
     }
-    if (!requiresCurrentOriginalEvidence(value.verdict))
+    if (!requiresCurrentEvidence(value.verdict))
         return [];
     if (!projectAuditorEvidenceProjectionStatus(assignment).complete) {
-        return issue(`auditor_${value.verdict}_evidence_incomplete`, "Conclusive verdicts require all selected original evidence without omissions.");
+        return issue(`auditor_${value.verdict}_evidence_incomplete`, "Conclusive verdicts require all selected evidence representations to be present.");
     }
     if (!hasCurrentNeededEvidence(needed, assignment, value.verdict)) {
-        return issue(`auditor_${value.verdict}_needed_evidence_missing`, "Every needed evidence ID must be present in the current exact bundle; previews and prior reviews are not proof.");
+        return issue(`auditor_${value.verdict}_needed_evidence_missing`, "Every needed evidence ID must be present in the current admitted bundle; previews and prior reviews are not proof.");
     }
     return [];
 }
@@ -33,7 +33,7 @@ function hasExactInventoryCoverage(needed, notNeeded, assignment) {
     const inventoryIds = new Set(assignment.inventory.map((entry) => entry.executionId));
     return ids.every((id) => typeof id === "string" && inventoryIds.has(id));
 }
-function requiresCurrentOriginalEvidence(verdict) {
+function requiresCurrentEvidence(verdict) {
     if (verdict === "pass")
         return true;
     return verdict === "gaps";
@@ -56,7 +56,7 @@ function validateRequestedBundle(ids, needed, assignment) {
     if (code)
         return issue(code, "Request a complete admissible evidence bundle that has not already been reviewed for this work snapshot.");
     if (!hasRequestedNeededEvidence(needed, ids))
-        return issue("auditor_requested_needed_evidence_missing", "The requested next bundle must include every needed evidence ID, including originals already read in the current bundle.");
+        return issue("auditor_requested_needed_evidence_missing", "The requested next bundle must include every needed evidence ID, including representations already read in the current bundle.");
     return [];
 }
 function hasRequestedNeededEvidence(needed, requested) {

package/dist/src/runtime/steps/auditor-decision/evidence-inventory.d.ts

@@ -1,7 +1,8 @@
+import type { ExecutionCompactedSources } from "../../context/execution-compacted-evidence.js";
 import type { RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
 import type { AuditorCapabilityEvidence, AuditorEvidenceInventoryEntry } from "./contracts.js";
 export declare function projectAuditorWorkEvidence(head: RoleCallLedgerHead, callerCallId: string): readonly AuditorCapabilityEvidence[];
-export declare function projectAuditorEvidenceInventory(head: RoleCallLedgerHead, callerCallId: string, evidence: readonly AuditorCapabilityEvidence[]): readonly AuditorEvidenceInventoryEntry[];
+export declare function projectAuditorEvidenceInventory(head: RoleCallLedgerHead, callerCallId: string, evidence: readonly AuditorCapabilityEvidence[], compactedSourceEvidence?: ExecutionCompactedSources): readonly AuditorEvidenceInventoryEntry[];
 export declare function fingerprintAuditorWork(params: Readonly<{
     requestId: string;
     callerCallId: string;

package/dist/src/runtime/steps/auditor-decision/evidence-inventory.js

@@ -5,11 +5,16 @@ const INVENTORY_TARGET_PREVIEW_LIMIT = 2;
 export function projectAuditorWorkEvidence(head, callerCallId) {
     return Object.freeze(rootSettledExecutions(head, callerCallId).map(projectCapabilityEvidence));
 }
-export function projectAuditorEvidenceInventory(head, callerCallId, evidence) {
+export function projectAuditorEvidenceInventory(head, callerCallId, evidence, compactedSourceEvidence) {
     const executions = rootSettledExecutions(head, callerCallId);
+    const compactedById = new Map(compactedSourceEvidence?.sources.map((source) => [
+        source.executionId,
+        source,
+    ]));
     return Object.freeze(evidence.map((entry, index) => {
         const execution = executions[index];
         const references = entry.references ?? [];
+        const compactedSource = compactedById.get(entry.executionId);
         return Object.freeze({
             executionId: entry.executionId,
             callId: execution.callId,
@@ -25,6 +30,12 @@ export function projectAuditorEvidenceInventory(head, callerCallId, evidence) {
             referenceCount: references.length,
             omittedReferencePreviewCount: Math.max(0, references.length - INVENTORY_TARGET_PREVIEW_LIMIT),
             exactEvidenceChars: JSON.stringify(projectAuditorEvidenceRepresentation(entry)).length,
+            ...(compactedSource
+                ? {
+                    evidencePresentation: "compacted",
+                    projectedEvidenceChars: JSON.stringify(projectAuditorEvidenceRepresentation(entry, compactedSource)).length,
+                }
+                : {}),
             evidenceFingerprint: fingerprintAuditorEvidence(entry),
         });
     }));

package/dist/src/runtime/steps/auditor-decision/evidence-representation.d.ts

@@ -1,10 +1,16 @@
 import type { AuditorCapabilityEvidence } from "./contracts.js";
+import type { ExecutionCompactedSource } from "../../context/execution-compacted-evidence.js";
 type SupplementField = "summary" | "referenceData" | "references";
 type AdapterPath = readonly (string | number)[];
 type RepresentedFields = Partial<Record<SupplementField, AdapterPath>>;
-export type AuditorEvidenceRepresentation = Readonly<Omit<AuditorCapabilityEvidence, SupplementField> & Partial<Pick<AuditorCapabilityEvidence, SupplementField>> & {
+export type AuditorEvidenceRepresentation = Readonly<Omit<AuditorCapabilityEvidence, SupplementField | "adapterResult"> & Partial<Pick<AuditorCapabilityEvidence, SupplementField | "adapterResult">> & {
     representedFields?: Readonly<RepresentedFields>;
+    compactedSourceEvidence?: ExecutionCompactedSource & Readonly<{
+        kind: "runtime_compacted_source_evidence_v1";
+        authority: "passive_reference_only";
+        omissionMeaning: "summarized_detail_not_proven_absent";
+    }>;
 }>;
 /** Canonical records and their exact adapter envelopes are never rewritten. */
-export declare function projectAuditorEvidenceRepresentation(evidence: AuditorCapabilityEvidence): AuditorEvidenceRepresentation;
+export declare function projectAuditorEvidenceRepresentation(evidence: AuditorCapabilityEvidence, compactedSource?: ExecutionCompactedSource): AuditorEvidenceRepresentation;
 export {};

package/dist/src/runtime/steps/auditor-decision/evidence-representation.js

@@ -1,5 +1,18 @@
+import { projectCompactedCapabilityResultReceipt } from "../../context/compacted-capability-result-receipt.js";
 /** Canonical records and their exact adapter envelopes are never rewritten. */
-export function projectAuditorEvidenceRepresentation(evidence) {
+export function projectAuditorEvidenceRepresentation(evidence, compactedSource) {
+    if (compactedSource?.executionId === evidence.executionId) {
+        const receipt = projectCompactedCapabilityResultReceipt(evidence);
+        return Object.freeze({
+            ...receipt,
+            compactedSourceEvidence: Object.freeze({
+                ...compactedSource,
+                kind: "runtime_compacted_source_evidence_v1",
+                authority: "passive_reference_only",
+                omissionMeaning: "summarized_detail_not_proven_absent",
+            }),
+        });
+    }
     const represented = {
         ...evidence,
     };

package/dist/src/runtime/steps/auditor-decision/input.d.ts

@@ -8,4 +8,6 @@ export declare function buildAuditorDecisionInput(request: RequestExecutionSeed,
     modelStep: typeof AUDITOR_DECISION_MODEL_STEP;
     assignment: AuditorAssignment;
     phase: "selection" | "review";
+    selectedEvidenceChars: number;
+    reusedCompactedSourceCount: number;
 }>;

package/dist/src/runtime/steps/auditor-decision/input.js

@@ -8,6 +8,13 @@ import { createAuditorEvidenceSelectionFormat } from "./evidence-selection.js";
 import { buildAuditorDecisionInstructions } from "./prompt.js";
 import { projectAuditorEvidenceRepresentation } from "./evidence-representation.js";
 export function buildAuditorDecisionInput(request, assignment, phase = "review") {
+    const compactedById = new Map(assignment.compactedSourceEvidence?.sources.map((source) => [
+        source.executionId,
+        source,
+    ]));
+    const evidence = phase === "review"
+        ? assignment.evidence.map((entry) => projectAuditorEvidenceRepresentation(entry, compactedById.get(entry.executionId)))
+        : [];
     const format = phase === "selection"
         ? createAuditorEvidenceSelectionFormat(assignment)
         : createAuditorDecisionFormat(assignment);
@@ -58,7 +65,7 @@ export function buildAuditorDecisionInput(request, assignment, phase = "review")
                 authority: "configured_model_context",
                 retention: "exact",
                 contextWindowTokens: budget.contextWindowTokens,
-                evidenceSizeSemantics: "exactEvidenceChars measures the lossless model-visible representation; canonical fingerprints bind the unchanged original records. Runtime admits the complete review message under the configured context policy.",
+                evidenceSizeSemantics: "exactEvidenceChars measures the original representation. For evidencePresentation=compacted, projectedEvidenceChars measures the verified source summary and retained receipt that will be supplied instead. Canonical fingerprints bind the unchanged original records. Runtime admits the complete review message under the configured context policy without further compaction.",
             },
             previewSemantics: "Summary and target previews may be truncated; originalChars, truncated and omittedReferencePreviewCount declare that. Every work execution is indexed. Previews are not original proof.",
         }),
@@ -74,9 +81,9 @@ export function buildAuditorDecisionInput(request, assignment, phase = "review")
                     auditId: assignment.auditId,
                     workFingerprint: assignment.workFingerprint,
                     selectedEvidenceIds: assignment.selectedEvidenceIds,
-                    evidence: assignment.evidence.map(projectAuditorEvidenceRepresentation),
+                    evidence,
                     evidenceProjection: projectAuditorEvidenceProjectionStatus(assignment),
-                    omissionSemantics: "Only whole explicitly selected canonical proof is admitted. adapterResult is unchanged. representedFields maps identical supplementary field values to exact paths under that same entry's adapterResult; all other supplements remain verbatim. No content is truncated or summarized. Pass requires complete inventory coverage and every needed ID in this current bundle. Previews and prior reviews are not proof.",
+                    omissionSemantics: "Each selected entry contains its unchanged adapterResult or a verified existing compactedSourceEvidence summary of that same execution. Summaries may omit detail; omission does not establish absence. evidenceProjection.complete means all selected representations are present, not that summaries retain every original fact. representedFields maps identical supplements to exact paths in that entry's adapterResult; other supplements remain verbatim. Pass requires complete inventory classification and every needed ID in this current bundle with facts sufficient for the criteria. Previews and prior reviews are not proof.",
                 }),
             },
         ]
@@ -108,5 +115,7 @@ export function buildAuditorDecisionInput(request, assignment, phase = "review")
         modelStep: AUDITOR_DECISION_MODEL_STEP,
         assignment,
         phase,
+        selectedEvidenceChars: evidence.reduce((total, entry) => total + JSON.stringify(entry).length, 0),
+        reusedCompactedSourceCount: evidence.filter((entry) => entry.compactedSourceEvidence).length,
     });
 }

package/dist/src/runtime/steps/auditor-decision/projection.js

@@ -1,3 +1,5 @@
+import { projectExecutionCompactionObjective } from "../../context/execution-compaction-objective.js";
+import { resolveExecutionCompactedSources } from "../../context/execution-compacted-evidence.js";
 import { projectRequestSteeringSnapshot } from "../../request/request-steering.js";
 import { traceDebug } from "../../observability/debug-logger.js";
 import { projectAuditorInputState } from "./audit-input-state.js";
@@ -12,8 +14,24 @@ export function projectAuditorAssignment(request, head, call) {
     const objective = parseExecutionAgentAuditObjective(call.objective);
     const steering = projectRequestSteeringSnapshot(request.requestSteering, objective.requestSteeringVersion);
     const evidence = projectAuditorWorkEvidence(head, caller.callId);
+    const compactedSourceEvidence = resolveExecutionCompactedSources({
+        requestId: request.requestId,
+        prompt: request.prompt,
+        objective: projectExecutionCompactionObjective(request.prompt, steering.updates),
+        callId: caller.callId,
+        store: request.contextCompactionStore,
+        results: head.state.capabilityExecutions
+            .filter((execution) => execution.callId === caller.callId && execution.status === "settled")
+            .map((execution) => ({
+            executionId: execution.executionId,
+            callId: execution.callId,
+            invocationAttempt: execution.invocationAttempt,
+            capabilityId: execution.capabilityId,
+            adapterResult: execution.exactResult,
+        })),
+    });
     const state = projectAuditorInputState(head, caller.callId, steering.version, objective.criterionIds, evidence);
-    const inventory = projectAuditorEvidenceInventory(head, caller.callId, evidence);
+    const inventory = projectAuditorEvidenceInventory(head, caller.callId, evidence, compactedSourceEvidence);
     traceDebug("runtime.auditor", "assignment.created", {
         requestId: request.requestId,
         callId: call.callId,
@@ -49,6 +67,7 @@ export function projectAuditorAssignment(request, head, call) {
         reviewedEvidenceBundles: state.reviewedEvidenceBundles,
         selectedEvidenceIds: Object.freeze([]),
         evidence: Object.freeze([]),
+        ...(compactedSourceEvidence ? { compactedSourceEvidence } : {}),
         availableEvidenceCount: inventory.length,
         omittedEvidenceCount: 0,
     });