@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/steps/worker-decision/run.js

@@ -1,8 +1,11 @@
+import { completeWorkerHandoffEvidence } from "./worker-handoff-compaction.js";
+import { workerCompactionIntegrityInput, assertWorkerCheckpointApplicable, readWorkerCompactionCheckpoint, } from "./compaction-integrity.js";
+import { readSuperWorkerCompactionSidecar } from "../../context/super-worker-compaction-sidecar.js";
 import { bindRoleApprovalWait } from "../../orchestration/role-executors/approval-continuation.js";
 import { isWorkerCapabilityApprovalWait } from "../../orchestration/worker-capabilities/approval-contracts.js";
 import { invokeStructuredModelStep, StructuredModelInvalidOutputError, } from "../../model/invoke-structured-step.js";
 import { buildCompactedRequestToolResultsMessage, projectRequestToolResults, } from "../../context/request-tool-results.js";
-import { SEMANTIC_COMPACTION_CONTEXT_LANE, createSemanticCompactionSha256Fingerprint, projectSemanticCompactionDependencyResults, sameSemanticCompactionCheckpointBinding, } from "../../context/semantic-compaction/index.js";
+import { projectSemanticCompactionDependencyResults } from "../../context/semantic-compaction/index.js";
 import { createModelStepCompactionController } from "../../context/model-step-compaction.js";
 import { emitRuntimeStatus } from "../../events/runtime-status.js";
 import { CAPABILITY_CONTROLS_MODEL_STEP, createWorkerCapabilityBinding, isWorkerCapabilityOperationSupervisionLimitError, materializeWorkerCapabilityControlsIfComplete, partitionWorkerCapabilityControlsSchema, workerCapabilityContextCompactionScopeId, WORKER_CAPABILITY_CONTEXT_COMPACTION_ALLOWED_CONSUMERS, WORKER_CAPABILITY_RAW_PAYLOAD_MODEL_STEP, } from "../../orchestration/worker-capabilities/index.js";
@@ -179,8 +182,12 @@ async function runWorkerDecisionPhase(request, options) {
             format: input.format,
             messages: input.context.messages,
             contextCompaction: createModelStepCompactionController(request, {
+                consumer: input.modelStep,
                 call: options.call,
                 sourceRevision: options.requestToolResults.sourceRevision,
+                superWorkerCompaction: readSuperWorkerCompactionSidecar(options.requestToolResults),
+                requireSuperWorkerSources: workerCompactionIntegrityInput(request, options.capabilitySource) !==
+                    undefined,
                 allowedConsumers: WORKER_CAPABILITY_CONTEXT_COMPACTION_ALLOWED_CONSUMERS,
                 scopeId: workerCapabilityContextCompactionScopeId(options.call.callId),
             }),
@@ -234,40 +241,12 @@ async function runWorkerDecisionPhase(request, options) {
         result,
     });
 }
-async function completeWorkerHandoffEvidence(request, options, input) {
-    const store = request.contextCompactionStore;
-    if (!store)
-        return input.resultAuthorSource;
-    const scopeId = workerCapabilityContextCompactionScopeId(options.call.callId);
-    const checkpoint = store.get(scopeId);
-    if (!checkpoint)
-        return input.resultAuthorSource;
-    assertWorkerCheckpointApplicable(request, options.call, checkpoint);
-    const immediatePresentationEvidence = input.resultAuthorSource.operationSupervisionEvidenceContextMessage;
-    const handoffCompactionMessages = immediatePresentationEvidence
-        ? input.context.messages.filter((message) => message !== immediatePresentationEvidence)
-        : input.context.messages;
-    const prepared = await createModelStepCompactionController(request, {
-        call: options.call,
-        sourceRevision: options.requestToolResults.sourceRevision,
-        allowedConsumers: WORKER_CAPABILITY_CONTEXT_COMPACTION_ALLOWED_CONSUMERS,
-        scopeId,
-    }).prepare(handoffCompactionMessages);
-    prepared.commit();
-    const refreshedCheckpoint = store.get(scopeId);
-    if (!refreshedCheckpoint) {
-        throw new Error("context_compaction_handoff_checkpoint_missing");
-    }
-    assertWorkerCheckpointApplicable(request, options.call, refreshedCheckpoint);
-    return buildWorkerDecisionInput(request, {
-        ...options,
-        requestToolResultsContextMessage: buildCompactedRequestToolResultsMessage(options.requestToolResults, refreshedCheckpoint),
-    }).resultAuthorSource;
-}
 async function prepareWorkerDecisionInput(request, options) {
     const store = request.contextCompactionStore;
     const scopeId = workerCapabilityContextCompactionScopeId(options.call.callId);
-    const previous = store?.get(scopeId);
+    const previous = store
+        ? readWorkerCompactionCheckpoint(store, options.requestToolResults, scopeId, WORKER_DECISION_MODEL_STEP)
+        : undefined;
     if (previous) {
         assertWorkerCheckpointApplicable(request, options.call, previous);
     }
@@ -275,27 +254,11 @@ async function prepareWorkerDecisionInput(request, options) {
         ...options,
         ...(previous
             ? {
-                requestToolResultsContextMessage: buildCompactedRequestToolResultsMessage(options.requestToolResults, previous),
+                requestToolResultsContextMessage: buildCompactedRequestToolResultsMessage(options.requestToolResults, previous, workerCompactionIntegrityInput(request, options.capabilitySource)),
             }
             : {}),
     });
 }
-function createWorkerCompactionBinding(request, call) {
-    return Object.freeze({
-        requestId: request.requestId,
-        currentRequestFingerprint: createSemanticCompactionSha256Fingerprint(request.prompt),
-        roleId: "worker",
-        callId: call.callId,
-        objectiveFingerprint: createSemanticCompactionSha256Fingerprint(call.objective),
-        contextLane: SEMANTIC_COMPACTION_CONTEXT_LANE,
-        allowedConsumers: WORKER_CAPABILITY_CONTEXT_COMPACTION_ALLOWED_CONSUMERS,
-    });
-}
-function assertWorkerCheckpointApplicable(request, call, checkpoint) {
-    if (!sameSemanticCompactionCheckpointBinding(checkpoint, createWorkerCompactionBinding(request, call))) {
-        throw new Error("context_compaction_checkpoint_not_applicable");
-    }
-}
 export const GENERIC_WORKER_EXECUTOR = Object.freeze({
     roleId: "worker",
     async execute({ context, call, ledger, continuation }) {

package/dist/src/runtime/steps/worker-decision/worker-handoff-compaction.d.ts

@@ -0,0 +1,4 @@
+import type { RequestExecutionScope } from "../../request/execution-scope.js";
+import { type WorkerResultAuthorSource } from "./contracts.js";
+import { buildWorkerDecisionInput } from "./input.js";
+export declare function completeWorkerHandoffEvidence(request: RequestExecutionScope, options: Parameters<typeof buildWorkerDecisionInput>[1], input: ReturnType<typeof buildWorkerDecisionInput>): Promise<WorkerResultAuthorSource>;

package/dist/src/runtime/steps/worker-decision/worker-handoff-compaction.js

@@ -0,0 +1,69 @@
+import { createModelStepCompactionController } from "../../context/model-step-compaction.js";
+import { buildCompactedRequestToolResultsMessage } from "../../context/request-tool-results.js";
+import { readSuperWorkerCompactionSidecar } from "../../context/super-worker-compaction-sidecar.js";
+import { workerCapabilityContextCompactionScopeId, WORKER_CAPABILITY_CONTEXT_COMPACTION_ALLOWED_CONSUMERS, } from "../../orchestration/worker-capabilities/index.js";
+import { assertWorkerCheckpointApplicable, readWorkerCompactionCheckpoint, workerCompactionIntegrityInput, } from "./compaction-integrity.js";
+import { WORKER_DECISION_MODEL_STEP, } from "./contracts.js";
+import { buildWorkerDecisionInput } from "./input.js";
+export async function completeWorkerHandoffEvidence(request, options, input) {
+    const store = request.contextCompactionStore;
+    if (!store)
+        return input.resultAuthorSource;
+    const scopeId = workerCapabilityContextCompactionScopeId(options.call.callId);
+    const checkpoint = readWorkerCompactionCheckpoint(store, options.requestToolResults, scopeId, WORKER_DECISION_MODEL_STEP);
+    if (!checkpoint)
+        return input.resultAuthorSource;
+    assertWorkerCheckpointApplicable(request, options.call, checkpoint);
+    const immediatePresentationEvidence = input.resultAuthorSource.operationSupervisionEvidenceContextMessage;
+    const handoffCompactionMessages = immediatePresentationEvidence
+        ? input.context.messages.filter((message) => message !== immediatePresentationEvidence)
+        : input.context.messages;
+    const controller = createModelStepCompactionController(request, {
+        call: options.call,
+        sourceRevision: options.requestToolResults.sourceRevision,
+        superWorkerCompaction: readSuperWorkerCompactionSidecar(options.requestToolResults),
+        requireSuperWorkerSources: workerCompactionIntegrityInput(request, options.capabilitySource) !==
+            undefined,
+        allowedConsumers: WORKER_CAPABILITY_CONTEXT_COMPACTION_ALLOWED_CONSUMERS,
+        scopeId,
+        consumer: WORKER_DECISION_MODEL_STEP,
+    });
+    const stage = requireWorkerHandoffCompactionStage(controller.getStages(), scopeId);
+    request.abortSignal.throwIfAborted();
+    const outcome = await stage.prepare(handoffCompactionMessages);
+    request.abortSignal.throwIfAborted();
+    workerCompactionIntegrityInput(request, options.capabilitySource);
+    assertWorkerHandoffSourcesRemainAvailable(outcome);
+    const hasPreparedHandoffCheckpoint = outcome.kind === "prepared";
+    if (hasPreparedHandoffCheckpoint) {
+        await outcome.preparation.commit();
+        request.abortSignal.throwIfAborted();
+        workerCompactionIntegrityInput(request, options.capabilitySource);
+    }
+    const refreshedCheckpoint = readWorkerCompactionCheckpoint(store, options.requestToolResults, scopeId, WORKER_DECISION_MODEL_STEP);
+    if (!refreshedCheckpoint) {
+        throw new Error("context_compaction_handoff_checkpoint_missing");
+    }
+    assertWorkerCheckpointApplicable(request, options.call, refreshedCheckpoint);
+    return buildWorkerDecisionInput(request, {
+        ...options,
+        requestToolResultsContextMessage: buildCompactedRequestToolResultsMessage(options.requestToolResults, refreshedCheckpoint, workerCompactionIntegrityInput(request, options.capabilitySource)),
+    }).resultAuthorSource;
+}
+function requireWorkerHandoffCompactionStage(stages, scopeId) {
+    if (stages.length !== 1)
+        throw new Error("context_compaction_handoff_stage_invalid");
+    const stage = stages[0];
+    if (stage.compactionScope !== "active_request")
+        throw new Error("context_compaction_handoff_stage_invalid");
+    if (stage.scopeId !== scopeId)
+        throw new Error("context_compaction_handoff_stage_invalid");
+    return stage;
+}
+function assertWorkerHandoffSourcesRemainAvailable(outcome) {
+    if (outcome.kind === "prepared")
+        return;
+    if (outcome.reason === "no_new_sources")
+        return;
+    throw new Error("context_compaction_handoff_checkpoint_missing");
+}

package/dist/src/sessions/assistant-initiative-append.d.ts

@@ -0,0 +1,14 @@
+import { type CreateAssistantConversationInput } from "./assistant-initiative.js";
+import type { SessionRecord } from "./types.js";
+/** Covers the proactive owner's complete retained receipt window. Never model context. */
+export declare const MAX_ASSISTANT_INITIATIVE_RECEIPTS = 100;
+/** Pure append shared by storage adapters; proposal identity is the replay key. */
+export declare function appendSparkInitiativeRecord(existing: SessionRecord | null, sessionId: string, input: CreateAssistantConversationInput, now: Date): SessionRecord;
+export declare function hasVisibleAssistantInitiative(session: SessionRecord, proposalId: string): boolean;
+/** Caller holds the canonical session mutation queue across commit and rollback. */
+export declare function appendAssistantInitiativeRecord(options: {
+    directory: string;
+    sessionId: string;
+    input: CreateAssistantConversationInput;
+    now: Date;
+}): Promise<SessionRecord>;

package/dist/src/sessions/assistant-initiative-append.js

@@ -0,0 +1,64 @@
+import { assertAssistantInitiative } from "./assistant-initiative.js";
+import { saveDurableSessionFile } from "./durable-session-commit.js";
+import { deleteSessionFile, ensureSessionsDir, loadSessionFile } from "./session-store.js";
+import { assertValidSessionId } from "./record/rules.js";
+import { assertSessionKindUnchanged, sessionKindCreationFields } from "./spark-session.js";
+/** Covers the proactive owner's complete retained receipt window. Never model context. */
+export const MAX_ASSISTANT_INITIATIVE_RECEIPTS = 100;
+/** Pure append shared by storage adapters; proposal identity is the replay key. */
+export function appendSparkInitiativeRecord(existing, sessionId, input, now) {
+    input.assertCurrent?.();
+    assertValidSessionId(sessionId);
+    assertAssistantInitiative(input);
+    const identity = sessionKindCreationFields(sessionId, { kind: "spark" });
+    if (existing)
+        assertSessionKindUnchanged(existing, "spark");
+    if (hasSavedInitiative(existing, input.initiative.proposalId))
+        return existing;
+    const timestamp = now.toISOString();
+    const session = existing ?? {
+        id: sessionId, ...identity, createdAt: timestamp, updatedAt: timestamp,
+        lastAgentMode: "reasoning", messageCount: 0, messages: [],
+    };
+    const messages = [...session.messages, {
+            id: `initiative:${input.initiative.proposalId}`, role: "assistant", content: input.content,
+            source: "co_worker", grounding: "conversation", createdAt: timestamp, initiative: input.initiative,
+        }];
+    const assistantInitiativeReceipts = [...(session.assistantInitiativeReceipts ?? []), input.initiative.proposalId]
+        .slice(-MAX_ASSISTANT_INITIATIVE_RECEIPTS);
+    return { ...session, messages, messageCount: messages.length, updatedAt: timestamp, assistantInitiativeReceipts };
+}
+function hasSavedInitiative(session, proposalId) {
+    if (!session)
+        return false;
+    if (session.assistantInitiativeReceipts?.includes(proposalId))
+        return true;
+    return hasVisibleAssistantInitiative(session, proposalId);
+}
+export function hasVisibleAssistantInitiative(session, proposalId) {
+    return session.messages.some((message) => message.initiative?.proposalId === proposalId);
+}
+/** Caller holds the canonical session mutation queue across commit and rollback. */
+export async function appendAssistantInitiativeRecord(options) {
+    options.input.assertCurrent?.();
+    assertValidSessionId(options.sessionId);
+    await ensureSessionsDir(options.directory);
+    const existing = await loadSessionFile(options.directory, options.sessionId);
+    const record = appendSparkInitiativeRecord(existing, options.sessionId, options.input, options.now);
+    if (record === existing)
+        return record;
+    await saveDurableSessionFile(options.directory, record, options.input.assertCurrent);
+    try {
+        options.input.assertCurrent?.();
+    }
+    catch (error) {
+        await restorePreInitiativeRecord(options.directory, options.sessionId, existing);
+        throw error;
+    }
+    return record;
+}
+async function restorePreInitiativeRecord(directory, sessionId, existing) {
+    if (existing)
+        return saveDurableSessionFile(directory, existing);
+    await deleteSessionFile(directory, sessionId);
+}

package/dist/src/sessions/assistant-initiative.d.ts

@@ -8,6 +8,9 @@ export type AssistantInitiative = Readonly<{
         id: string;
         version: string;
     }>[];
+    /** Optional only for legacy initiatives authored before context handoffs. */
+    handoffBrief?: string;
+    handoffTitle?: string;
 }>;
 export type CreateAssistantConversationInput = Readonly<{
     title: string;
@@ -24,3 +27,4 @@ export declare function createAssistantConversationRecord(options: {
     now: Date;
 }): Promise<SessionRecord>;
 export declare function isAssistantInitiativeMessage(message: SessionMessage): boolean;
+export declare function assertAssistantInitiative(input: CreateAssistantConversationInput): void;

package/dist/src/sessions/assistant-initiative.js

@@ -1,5 +1,6 @@
 import { assertValidSessionId } from "./record/rules.js";
 import { deleteSessionFile, ensureSessionsDir, loadSessionFile, saveSessionFile } from "./session-store.js";
+import { isSparkHandoffBrief } from "./spark-handoff-brief.js";
 /** Called under the same per-session mutation queue as edits and deletion. */
 export async function createAssistantConversationRecord(options) {
     const { sessionId, input } = options;
@@ -40,7 +41,7 @@ export function isAssistantInitiativeMessage(message) {
         return false;
     return typeof message.initiative.proposalId === "string" && message.initiative.proposalId.length > 0;
 }
-function assertAssistantInitiative(input) {
+export function assertAssistantInitiative(input) {
     if (!input.title.trim() || input.title.length > 160)
         throw new Error("assistant_initiative_title_invalid");
     if (!input.content.trim() || input.content.length > 4000)
@@ -49,6 +50,11 @@ function assertAssistantInitiative(input) {
         throw new Error("assistant_initiative_binding_invalid");
     if (!input.initiative.reason.trim() || input.initiative.reason.length > 1000)
         throw new Error("assistant_initiative_reason_invalid");
+    if (input.initiative.handoffBrief !== undefined && !isSparkHandoffBrief(input.initiative.handoffBrief))
+        throw new Error("assistant_initiative_handoff_brief_invalid");
+    if (input.initiative.handoffTitle !== undefined &&
+        (typeof input.initiative.handoffTitle !== "string" || !input.initiative.handoffTitle.trim() || input.initiative.handoffTitle.length > 160))
+        throw new Error("assistant_initiative_handoff_title_invalid");
     if (!input.initiative.sources.length || input.initiative.sources.length > 12)
         throw new Error("assistant_initiative_sources_invalid");
     for (const source of input.initiative.sources) {

package/dist/src/sessions/automation-session-origin.d.ts

@@ -0,0 +1,34 @@
+export type AutomationSessionOrigin = Readonly<{
+    kind: "automation_node_v1";
+    automationId: string;
+    runId: string;
+    nodeId: string;
+    attemptId: string;
+}>;
+/** Runtime-only authority. A matching JSON object cannot recreate this handle. */
+export type AutomationSessionHandle = Readonly<{
+    kind: "automation_session_handle";
+}>;
+export declare class AutomationSessionLockedError extends Error {
+    readonly code = "automation_session_locked";
+    constructor();
+}
+export declare function isAutomationSessionLockedError(error: unknown): boolean;
+export declare function isAutomationSessionOrigin(value: unknown): value is AutomationSessionOrigin;
+export declare function hasAutomationSessionOrigin(value: {
+    automationOrigin?: unknown;
+}): boolean;
+/** One SessionService instance owns its handles and async execution scope. */
+export declare function createAutomationSessionAccess(): Readonly<{
+    canAccess: (sessionId: string, record: {
+        automationOrigin?: unknown;
+    }) => boolean;
+    assertAccess(sessionId: string, record: {
+        automationOrigin?: unknown;
+    }): void;
+    issue(sessionId: string, origin: AutomationSessionOrigin): Readonly<{
+        kind: "automation_session_handle";
+    }>;
+    revoke(handle: AutomationSessionHandle): void;
+    run<T>(handle: AutomationSessionHandle, task: () => Promise<T>): Promise<T>;
+}>;

package/dist/src/sessions/automation-session-origin.js

@@ -0,0 +1,78 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+export class AutomationSessionLockedError extends Error {
+    code = "automation_session_locked";
+    constructor() {
+        super("automation_session_locked");
+        this.name = "AutomationSessionLockedError";
+    }
+}
+export function isAutomationSessionLockedError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const value = error;
+    return (value.code === "automation_session_locked" ||
+        value.message === "automation_session_locked");
+}
+export function isAutomationSessionOrigin(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const origin = value;
+    return (origin.kind === "automation_node_v1" &&
+        hasIdentity(origin.automationId) &&
+        hasIdentity(origin.runId) &&
+        hasIdentity(origin.nodeId) &&
+        hasIdentity(origin.attemptId));
+}
+export function hasAutomationSessionOrigin(value) {
+    const origin = value.automationOrigin;
+    return (!!origin &&
+        typeof origin === "object" &&
+        origin.kind === "automation_node_v1");
+}
+function hasIdentity(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function matchesOrigin(expected, actual) {
+    return (expected.automationId === actual.automationId &&
+        expected.runId === actual.runId &&
+        expected.nodeId === actual.nodeId &&
+        expected.attemptId === actual.attemptId);
+}
+/** One SessionService instance owns its handles and async execution scope. */
+export function createAutomationSessionAccess() {
+    const scope = new AsyncLocalStorage();
+    const handles = new WeakMap();
+    function canAccess(sessionId, record) {
+        if (!hasAutomationSessionOrigin(record))
+            return true;
+        const current = scope.getStore();
+        return (current?.sessionId === sessionId &&
+            isAutomationSessionOrigin(record.automationOrigin) &&
+            matchesOrigin(current.origin, record.automationOrigin));
+    }
+    return Object.freeze({
+        canAccess,
+        assertAccess(sessionId, record) {
+            if (!canAccess(sessionId, record))
+                throw new AutomationSessionLockedError();
+        },
+        issue(sessionId, origin) {
+            if (!isAutomationSessionOrigin(origin))
+                throw new Error("automation_session_origin_invalid");
+            const handle = Object.freeze({
+                kind: "automation_session_handle",
+            });
+            handles.set(handle, Object.freeze({ sessionId, origin }));
+            return handle;
+        },
+        revoke(handle) {
+            handles.delete(handle);
+        },
+        async run(handle, task) {
+            const accepted = handles.get(handle);
+            if (!accepted)
+                throw new AutomationSessionLockedError();
+            return await scope.run(accepted, task);
+        },
+    });
+}

package/dist/src/sessions/automation-session-store.d.ts

@@ -0,0 +1,12 @@
+import { type AutomationSessionHandle, type AutomationSessionOrigin, type createAutomationSessionAccess } from "./automation-session-origin.js";
+/** Adapter-owned lifetime and recovery for hidden attempt transcripts only. */
+export declare function createAutomationSessionStore(input: {
+    sessionsDir: string;
+    now(): Date;
+    access: ReturnType<typeof createAutomationSessionAccess>;
+    enqueue<T>(sessionId: string, mutation: () => Promise<T>): Promise<T>;
+}): {
+    create: (sessionId: string, origin: AutomationSessionOrigin) => Promise<AutomationSessionHandle>;
+    release: (handle: AutomationSessionHandle) => void;
+    reconcile: (cleanupAttachments: (id: string) => Promise<void>, onError: (sessionId: string, error: unknown) => void) => Promise<void>;
+};

package/dist/src/sessions/automation-session-store.js

@@ -0,0 +1,129 @@
+import { readdir } from "node:fs/promises";
+import { AutomationSessionLockedError, hasAutomationSessionOrigin, isAutomationSessionOrigin } from "./automation-session-origin.js";
+import { assertValidSessionId } from "./record/rules.js";
+import { saveDurableSessionFile } from "./durable-session-commit.js";
+import { deleteSessionFile, ensureSessionsDir, loadSessionFile } from "./session-store.js";
+const MAX_SESSION_RETIREMENTS = 64;
+const MAX_SESSION_SCANS = 256;
+/** Adapter-owned lifetime and recovery for hidden attempt transcripts only. */
+export function createAutomationSessionStore(input) {
+    const handles = new WeakMap();
+    const owners = new Map();
+    const retiring = new Set();
+    let cursor = "";
+    let reconciliation;
+    function releaseOwner(sessionId) {
+        const remaining = (owners.get(sessionId) ?? 1) - 1;
+        if (remaining > 0) {
+            owners.set(sessionId, remaining);
+            return;
+        }
+        owners.delete(sessionId);
+    }
+    async function create(sessionId, origin) {
+        assertValidSessionId(sessionId);
+        if (!isAutomationSessionOrigin(origin))
+            throw new Error("automation_session_origin_invalid");
+        if (retiring.has(sessionId))
+            throw new AutomationSessionLockedError();
+        const handle = input.access.issue(sessionId, origin);
+        owners.set(sessionId, (owners.get(sessionId) ?? 0) + 1);
+        try {
+            await input.access.run(handle, () => input.enqueue(sessionId, async () => {
+                await ensureSessionsDir(input.sessionsDir);
+                const existing = await loadSessionFile(input.sessionsDir, sessionId);
+                if (existing && !hasAutomationSessionOrigin(existing))
+                    throw new Error("automation_session_origin_conflict");
+                if (existing)
+                    return;
+                const timestamp = input.now().toISOString();
+                await saveDurableSessionFile(input.sessionsDir, {
+                    id: sessionId, automationOrigin: Object.freeze({ ...origin }), title: sessionId,
+                    createdAt: timestamp, updatedAt: timestamp, lastAgentMode: "reasoning",
+                    messageCount: 0, messages: [],
+                });
+            }));
+            handles.set(handle, sessionId);
+            return handle;
+        }
+        catch (error) {
+            input.access.revoke(handle);
+            releaseOwner(sessionId);
+            throw error;
+        }
+    }
+    function release(handle) {
+        const sessionId = handles.get(handle);
+        if (!sessionId)
+            return;
+        handles.delete(handle);
+        input.access.revoke(handle);
+        releaseOwner(sessionId);
+    }
+    async function retire(sessionId, origin, cleanupAttachments) {
+        // Claim synchronously before issuing recovery authority or awaiting storage.
+        if (owners.has(sessionId))
+            return;
+        retiring.add(sessionId);
+        const handle = input.access.issue(sessionId, origin);
+        try {
+            await input.access.run(handle, () => input.enqueue(sessionId, async () => {
+                const current = await loadSessionFile(input.sessionsDir, sessionId);
+                if (!current || current.id !== sessionId)
+                    return;
+                if (!isAutomationSessionOrigin(current.automationOrigin))
+                    return;
+                input.access.assertAccess(sessionId, current);
+                // Keep the durable origin until its dependent cleanup succeeds.
+                await cleanupAttachments(sessionId);
+                await deleteSessionFile(input.sessionsDir, sessionId);
+            }));
+        }
+        finally {
+            input.access.revoke(handle);
+            retiring.delete(sessionId);
+        }
+    }
+    async function reconcileFiles(cleanupAttachments, onError) {
+        await ensureSessionsDir(input.sessionsDir);
+        const entries = await readdir(input.sessionsDir, { withFileTypes: true });
+        const names = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map((entry) => entry.name).sort();
+        const ordered = [...names.filter((name) => name > cursor), ...names.filter((name) => name <= cursor)];
+        let attempted = 0;
+        let scanned = 0;
+        for (const name of ordered) {
+            if (attempted === MAX_SESSION_RETIREMENTS)
+                break;
+            if (scanned === MAX_SESSION_SCANS)
+                break;
+            scanned += 1;
+            cursor = name;
+            const sessionId = name.slice(0, -5);
+            if (owners.has(sessionId))
+                continue;
+            try {
+                assertValidSessionId(sessionId);
+                const session = await loadSessionFile(input.sessionsDir, sessionId);
+                if (!session || session.id !== sessionId)
+                    continue;
+                if (!isAutomationSessionOrigin(session.automationOrigin))
+                    continue;
+                attempted += 1;
+                await retire(sessionId, session.automationOrigin, cleanupAttachments);
+            }
+            catch (error) {
+                // Advancing the cursor also for failures keeps later bounded batches fair.
+                onError(sessionId, error);
+            }
+        }
+    }
+    function reconcile(cleanupAttachments, onError) {
+        if (reconciliation)
+            return reconciliation;
+        reconciliation = reconcileFiles(cleanupAttachments, onError)
+            .finally(() => { reconciliation = undefined; });
+        return reconciliation;
+    }
+    return { create, release, reconcile };
+}

package/dist/src/sessions/index.d.ts

@@ -5,6 +5,7 @@ import type { SessionArtifactPathInput, SessionContextEntryKind, SessionMessageG
 export type { SessionArtifactPath, SessionArtifactPathInput } from "./types.js";
 export { buildContextBuckets, buildContextWindow };
 export declare function getOrCreateSession(sessionId: string): Promise<import("./types.js").SessionRecord>;
+export declare function assertInteractiveSession(sessionId: string): Promise<void>;
 export declare function getAllSessions(): Promise<import("./types.js").SessionRecord[]>;
 export declare function listSessions(params?: {
     limit?: number;

package/dist/src/sessions/index.js

@@ -5,6 +5,9 @@ export { buildContextBuckets, buildContextWindow };
 export function getOrCreateSession(sessionId) {
     return sessionService.getOrCreateSession(sessionId);
 }
+export function assertInteractiveSession(sessionId) {
+    return sessionService.assertInteractiveSession(sessionId);
+}
 export function getAllSessions() {
     return sessionService.getAllSessions();
 }

package/dist/src/sessions/memory/source.d.ts

@@ -6,7 +6,7 @@ export type SessionMemorySettledTurn = Readonly<{
 }>;
 export type SessionMemorySourceSnapshot = Readonly<{
     sourceRevision: string;
-    /** Settled history, including assistant initiatives that must never be summarized. */
+    /** Settled history, including standalone assistant conversation units. */
     historyMessages: readonly SessionMessage[];
     turns: readonly SessionMemorySettledTurn[];
     messageReferences: readonly SessionMemoryMessageReference[];

package/dist/src/sessions/memory/source.js

@@ -1,23 +1,16 @@
 import { createHash } from "node:crypto";
 import { isAssistantInitiativeMessage } from "../assistant-initiative.js";
 export function snapshotSessionMemorySource(session) {
-    const settledTurns = collectSettledConversationTurns(session.messages);
-    const historyMessages = Object.freeze(settledTurns.flatMap(turnMessages));
-    const turns = Object.freeze(settledTurns.filter(isCompactableConversationTurn));
-    const historyReferences = historyMessages.map(createMessageReference);
-    const messageReferences = Object.freeze(historyReferences.filter(function isCompactableMessageReference(_reference, index) {
-        return !isAssistantInitiativeMessage(historyMessages[index]);
-    }));
+    const turns = collectSettledConversationTurns(session.messages);
+    const historyMessages = Object.freeze(turns.flatMap(turnMessages));
+    const messageReferences = Object.freeze(historyMessages.map(createMessageReference));
     return Object.freeze({
-        sourceRevision: fingerprint(historyReferences.map(({ fingerprint: value }) => value).join("\n")),
+        sourceRevision: fingerprint(messageReferences.map(({ fingerprint: value }) => value).join("\n")),
         historyMessages,
         turns,
         messageReferences,
     });
 }
-function isCompactableConversationTurn(turn) {
-    return !isAssistantInitiativeMessage(turn.assistant);
-}
 export function resolveCoveredTurnCount(snapshot, checkpoint) {
     if (!checkpoint) {
         return 0;

package/dist/src/sessions/project-binding.d.ts

@@ -7,6 +7,7 @@ export type SessionProject = Readonly<{
 }>;
 export type SessionCreationOptions = Readonly<{
     project?: SessionProject;
+    kind?: import("./spark-session.js").SessionKind;
 }>;
 export declare function copySessionProject(project: SessionProject): SessionProject;
 export declare function assertSessionProjectUnchanged(session: SessionRecord, requested?: SessionProject): void;

package/dist/src/sessions/record/projection.d.ts

@@ -26,5 +26,6 @@ export declare function toSessionListItem(session: SessionRecord): {
         name: string;
         directory: string;
     }> | undefined;
+    kind?: "spark" | undefined;
     id: string;
 };

package/dist/src/sessions/record/projection.js

@@ -1,3 +1,4 @@
+import { isAssistantInitiativeMessage } from "../assistant-initiative.js";
 import { projectSessionRequestLifecycle } from "../request-lifecycle/projection.js";
 function getRequestEventCompactionKey(payload) {
     const type = typeof payload.type === "string" ? payload.type : "";
@@ -166,6 +167,8 @@ export function toSnapshotMessage(sessionId, message, requests) {
     };
 }
 function inferMessageRequestId(message, requests) {
+    if (isAssistantInitiativeMessage(message))
+        return null;
     if (message.role !== "assistant") {
         return null;
     }
@@ -209,6 +212,7 @@ export function toSessionListItem(session) {
         .find((message) => message.role === "assistant");
     return {
         id: session.id,
+        ...(session.kind ? { kind: session.kind } : {}),
         ...(session.project ? { project: session.project } : {}),
         title: session.title,
         createdAt: toEpochMs(session.createdAt),