@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/context/semantic-compaction/super-operation-source.d.ts

@@ -0,0 +1,8 @@
+import type { RoleCallFrame, RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
+import { type SemanticCompactionSource } from "./contracts.js";
+/** Historical notices bind to immutable executions, never today's transient warning state. */
+export declare function assertHistoricalOperationSource(params: {
+    source: SemanticCompactionSource;
+    head: RoleCallLedgerHead;
+    call: RoleCallFrame;
+}): void;

package/dist/src/runtime/context/semantic-compaction/super-operation-source.js

@@ -0,0 +1,99 @@
+import { OPERATION_SUPERVISION_EVIDENCE_MESSAGE_KIND, projectOperationSupervisionLinkedEvidence, } from "../operation-supervision-evidence.js";
+import { createSemanticCompactionSha256Fingerprint as hash, } from "./contracts.js";
+import { readStoredSourceMessage } from "./super-source-message.js";
+/** Historical notices bind to immutable executions, never today's transient warning state. */
+export function assertHistoricalOperationSource(params) {
+    const { source, head, call } = params;
+    const message = readStoredSourceMessage(source);
+    const record = JSON.parse(message.content);
+    if (call.roleId !== "worker")
+        throw new Error("context_compaction_source_family_not_owned");
+    if (record.kind !== OPERATION_SUPERVISION_EVIDENCE_MESSAGE_KIND)
+        throw new Error("context_compaction_supervision_source_invalid");
+    if (source.sourceRef !==
+        `operation-supervision-evidence:${hash(message.content).slice(7)}`)
+        throw new Error("context_compaction_supervision_source_invalid");
+    const invocation = record.binding?.invocationAttempt;
+    if (record.binding?.callId !== call.callId)
+        throw new Error("context_compaction_supervision_call_invalid");
+    if (!Number.isSafeInteger(invocation) ||
+        invocation < 2 ||
+        invocation > call.activationCount)
+        throw new Error("context_compaction_supervision_invocation_invalid");
+    if (!Number.isSafeInteger(record.sourceRevision) ||
+        record.sourceRevision > head.revision ||
+        record.sourceRevision < 1)
+        throw new Error("context_compaction_supervision_revision_invalid");
+    if (!Array.isArray(record.entries) || record.entries.length === 0)
+        throw new Error("context_compaction_supervision_source_invalid");
+    const entries = record.entries.map((entry) => {
+        const notice = requireHistoricalNotice(entry.notice);
+        if (entry.originExecutionId !== notice.originExecutionId)
+            throw new Error("context_compaction_supervision_origin_invalid");
+        const execution = head.state.capabilityExecutions.find((candidate) => candidate.executionId === notice.originExecutionId);
+        if (!execution)
+            throw new Error("context_compaction_supervision_origin_invalid");
+        if (!isHistoricalNoticeInvocationBound(notice, execution, call, invocation))
+            throw new Error("context_compaction_supervision_invocation_invalid");
+        return projectOperationSupervisionLinkedEvidence(head, call, notice);
+    });
+    const expected = {
+        kind: OPERATION_SUPERVISION_EVIDENCE_MESSAGE_KIND,
+        authority: "canonical_role_call_ledger",
+        purpose: "supply_exact_immediate_operation_supervision_evidence",
+        applicability: "bound_activation_decision_or_its_immediate_presentation_handoff",
+        presenceEffect: "passive_evidence_not_user_intent_action_authority_or_new_execution",
+        sourceRevision: record.sourceRevision,
+        binding: {
+            callId: call.callId,
+            invocationAttempt: invocation,
+            consumers: ["activation_decision", "immediate_presentation_handoff"],
+        },
+        coverage: "complete_for_immediate_operation_supervision_notices",
+        entries,
+    };
+    if (JSON.stringify(record) !== JSON.stringify(expected))
+        throw new Error("context_compaction_supervision_evidence_changed");
+}
+function requireHistoricalNotice(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("context_compaction_supervision_notice_invalid");
+    const keys = Object.keys(value);
+    const permittedKeys = [
+        "kind",
+        "authority",
+        "presenceEffect",
+        "stage",
+        "actionFingerprint",
+        "priorOutcome",
+        "outcomeFingerprint",
+        "originExecutionId",
+        "matchingOutcomeCount",
+        "interventionCount",
+    ];
+    if (keys.length !== permittedKeys.length ||
+        keys.some((key) => !permittedKeys.includes(key)))
+        throw new Error("context_compaction_supervision_notice_invalid");
+    const notice = value;
+    if (notice.kind !== "runtime_operation_supervision_v1")
+        throw new Error("context_compaction_supervision_notice_invalid");
+    if (notice.authority !== "runtime_state")
+        throw new Error("context_compaction_supervision_notice_invalid");
+    if (notice.presenceEffect !== "passive_mechanical_intervention_not_user_intent")
+        throw new Error("context_compaction_supervision_notice_invalid");
+    if (notice.stage !== "warning" && notice.stage !== "intervention")
+        throw new Error("context_compaction_supervision_notice_invalid");
+    if (notice.matchingOutcomeCount !== 2)
+        throw new Error("context_compaction_supervision_notice_invalid");
+    if (notice.interventionCount !== (notice.stage === "warning" ? 0 : 1))
+        throw new Error("context_compaction_supervision_notice_invalid");
+    return notice;
+}
+function isHistoricalNoticeInvocationBound(notice, execution, call, invocation) {
+    if (notice.stage === "warning")
+        return (execution.callId === call.callId &&
+            execution.invocationAttempt + 1 === invocation);
+    if (execution.callId !== call.callId)
+        return true;
+    return execution.invocationAttempt < invocation;
+}

package/dist/src/runtime/context/semantic-compaction/super-reviewer-source.d.ts

@@ -0,0 +1,16 @@
+import type { RoleCallFrame, RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
+import { type SemanticCompactionSource } from "./contracts.js";
+import type { RequestContextCompactionStore } from "./store.js";
+/**
+ * Retains historical Reviewer evidence under its existing guarantees.
+ * Old bounded appendices do not encode their producing call/projection revision;
+ * do not invent that provenance by reconstructing today's Reviewer snapshot.
+ * Checkpoint applicability, allowed consumers and result lineage are validated
+ * by the checkpoint/dependency owners before this stored message is exposed.
+ */
+export declare function assertHistoricalReviewerSource(params: {
+    source: SemanticCompactionSource;
+    head: RoleCallLedgerHead;
+    call: RoleCallFrame;
+    store: RequestContextCompactionStore;
+}): void;

package/dist/src/runtime/context/semantic-compaction/super-reviewer-source.js

@@ -0,0 +1,37 @@
+import { createSemanticCompactionSha256Fingerprint as hash, } from "./contracts.js";
+import { readStoredSourceMessage } from "./super-source-message.js";
+/**
+ * Retains historical Reviewer evidence under its existing guarantees.
+ * Old bounded appendices do not encode their producing call/projection revision;
+ * do not invent that provenance by reconstructing today's Reviewer snapshot.
+ * Checkpoint applicability, allowed consumers and result lineage are validated
+ * by the checkpoint/dependency owners before this stored message is exposed.
+ */
+export function assertHistoricalReviewerSource(params) {
+    const { source, call } = params;
+    if (call.roleId !== "reviewer")
+        throw new Error("context_compaction_source_family_not_owned");
+    const message = readStoredSourceMessage(source);
+    const boundary = message.content.indexOf("\nBEGIN BOUNDED EVIDENCE CONTENT\n");
+    if (boundary < 0 ||
+        !message.content.endsWith("\nEND BOUNDED EVIDENCE CONTENT"))
+        throw new Error("context_compaction_reviewer_source_invalid");
+    let header;
+    try {
+        header = JSON.parse(message.content.slice(0, boundary));
+    }
+    catch {
+        throw new Error("context_compaction_reviewer_source_invalid");
+    }
+    if (header.kind !== "runtime_reviewer_evidence_v1" ||
+        header.authority !== "reference_data")
+        throw new Error("context_compaction_reviewer_source_invalid");
+    const evidenceRef = typeof header.evidenceRef === "string"
+        ? header.evidenceRef.trim()
+        : undefined;
+    const expectedRef = evidenceRef
+        ? `reviewer-evidence:${evidenceRef}`
+        : `reviewer-evidence:${hash(message.content).slice(7)}`;
+    if (source.sourceRef !== expectedRef)
+        throw new Error("context_compaction_reviewer_source_invalid");
+}

package/dist/src/runtime/context/semantic-compaction/super-source-integrity.d.ts

@@ -0,0 +1,21 @@
+import type { RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
+import { type SemanticCompactionCheckpoint, type SemanticCompactionCheckpointBinding } from "./contracts.js";
+import type { RequestContextCompactionStore } from "./store.js";
+export type SuperCompactionIntegrityInput = Readonly<{
+    requestId: string;
+    prompt: string;
+    head: RoleCallLedgerHead;
+    store: RequestContextCompactionStore;
+}>;
+/** Independently checks stored canonical bytes even when no checkpoint was committed. */
+export declare function assertSuperCompactionSourceIntegrity(params: SuperCompactionIntegrityInput): void;
+/** Derived checkpoint validation is separate so a candidate failure cannot taint healthy sources. */
+export declare function assertSuperCompactionCheckpointIntegrity(params: SuperCompactionIntegrityInput & {
+    checkpoint: SemanticCompactionCheckpoint;
+}): void;
+/** Exact owned binding, independent of derived continuation content/revision health. */
+export declare function assertSuperCompactionCheckpointBinding(params: Omit<SuperCompactionIntegrityInput, "store"> & {
+    checkpoint: SemanticCompactionCheckpointBinding & {
+        scopeId: string;
+    };
+}): void;

package/dist/src/runtime/context/semantic-compaction/super-source-integrity.js

@@ -0,0 +1,169 @@
+import { CompactionSourceInvariantError } from "../compaction-source-invariant.js";
+import { WORKER_CAPABILITY_CONTEXT_COMPACTION_ALLOWED_CONSUMERS } from "../../orchestration/worker-capabilities/payload-contracts.js";
+import { projectCanonicalCapabilityResultCompactionSources } from "../capability-result-compaction-source.js";
+import { hasSuperContextContract } from "../super-context-policy.js";
+import { assertValidSemanticCompactionCheckpoint, createSemanticCompactionSha256Fingerprint as hash, SEMANTIC_COMPACTION_CONTEXT_LANE, } from "./contracts.js";
+import { assertHistoricalOperationSource } from "./super-operation-source.js";
+import { assertHistoricalChildResultSource } from "./super-child-result-source.js";
+import { assertHistoricalReviewerSource } from "./super-reviewer-source.js";
+import { readStoredSourceMessage } from "./super-source-message.js";
+/** Independently checks stored canonical bytes even when no checkpoint was committed. */
+export function assertSuperCompactionSourceIntegrity(params) {
+    assertSuperIntegrityRequest(params);
+    const snapshot = params.store.snapshot?.();
+    if (!snapshot)
+        throw new Error("context_compaction_snapshot_unavailable");
+    const canonicalSources = new Map();
+    for (const source of snapshot.sources)
+        assertOwnedSource(params, source, canonicalSources);
+}
+/** Derived checkpoint validation is separate so a candidate failure cannot taint healthy sources. */
+export function assertSuperCompactionCheckpointIntegrity(params) {
+    assertSuperIntegrityRequest(params);
+    const { checkpoint, head } = params;
+    assertValidSemanticCompactionCheckpoint(checkpoint);
+    assertSuperCompactionCheckpointBinding(params);
+    const call = head.state.calls.find((candidate) => candidate.callId === checkpoint.callId);
+    if (checkpoint.sourceRevision > head.revision)
+        throw new Error("context_compaction_checkpoint_revision_invalid");
+    const canonicalSources = new Map();
+    for (const digest of checkpoint.sourceDigests) {
+        const source = params.store.materializeSource(digest.sourceRef, digest.sourceFingerprint);
+        if (source === undefined)
+            throw new CompactionSourceInvariantError("context_compaction_source_materialization_missing", digest.sourceRef);
+        assertOwnedSource(params, source, canonicalSources, call);
+    }
+}
+/** Exact owned binding, independent of derived continuation content/revision health. */
+export function assertSuperCompactionCheckpointBinding(params) {
+    const { checkpoint, head, requestId, prompt } = params;
+    if (!hasSuperContextContract(head.policy.authority, "supervisor"))
+        throw new Error("context_compaction_source_policy_invalid");
+    const call = head.state.calls.find((candidate) => candidate.callId === checkpoint.callId);
+    if (!call)
+        throw new Error("context_compaction_checkpoint_call_invalid");
+    if (head.state.requestId !== requestId || checkpoint.requestId !== requestId)
+        throw new Error("context_compaction_checkpoint_request_invalid");
+    if (checkpoint.currentRequestFingerprint !== hash(prompt))
+        throw new Error("context_compaction_checkpoint_request_invalid");
+    if (checkpoint.roleId !== call.roleId)
+        throw new Error("context_compaction_checkpoint_role_invalid");
+    const objective = call.roleId === "supervisor" ? prompt : call.objective;
+    if (!objective || checkpoint.objectiveFingerprint !== hash(objective))
+        throw new Error("context_compaction_checkpoint_objective_invalid");
+    if (checkpoint.contextLane !== SEMANTIC_COMPACTION_CONTEXT_LANE)
+        throw new Error("context_compaction_checkpoint_lane_invalid");
+    assertOwnedScopeBinding(checkpoint, call);
+}
+function assertSuperIntegrityRequest(params) {
+    if (params.head.state.requestId !== params.requestId)
+        throw new Error("context_compaction_source_request_invalid");
+    if (!hasSuperContextContract(params.head.policy.authority, "supervisor"))
+        throw new Error("context_compaction_source_policy_invalid");
+}
+function assertOwnedScopeBinding(checkpoint, call) {
+    const expectedScope = call.roleId === "worker"
+        ? `worker:${call.callId}:request-tool-results`
+        : `role:${call.roleId}:${call.callId}:continuation`;
+    if (checkpoint.scopeId !== expectedScope)
+        throw new Error("context_compaction_checkpoint_scope_invalid");
+    const consumers = resolveOwnedConsumers(call);
+    if (JSON.stringify(checkpoint.allowedConsumers) !== JSON.stringify(consumers))
+        throw new Error("context_compaction_checkpoint_consumers_invalid");
+}
+function resolveOwnedConsumers(call) {
+    if (call.roleId === "worker")
+        return WORKER_CAPABILITY_CONTEXT_COMPACTION_ALLOWED_CONSUMERS;
+    if (call.roleId === "supervisor")
+        return ["supervisor.decision", "supervisor.response"];
+    if (call.roleId === "planner")
+        return ["planner.decision", "planner.graph"];
+    if (call.roleId === "reviewer")
+        return ["reviewer.decision"];
+    throw new Error("context_compaction_checkpoint_role_invalid");
+}
+function assertOwnedSource(params, source, canonicalSources, scopeCall) {
+    if (hash(source.content) !== source.sourceFingerprint)
+        throw new CompactionSourceInvariantError("context_compaction_source_content_mismatch", source.sourceRef);
+    if (params.store.materializeSource(source.sourceRef, source.sourceFingerprint)
+        ?.content !== source.content)
+        throw new CompactionSourceInvariantError("context_compaction_source_materialization_missing", source.sourceRef);
+    const execution = params.head.state.capabilityExecutions.find((candidate) => candidate.executionId === source.sourceRef);
+    if (execution) {
+        if (scopeCall && scopeCall.callId !== execution.callId)
+            throw new CompactionSourceInvariantError("context_compaction_execution_owner_invalid", source.sourceRef);
+        let ownedSources = canonicalSources.get(execution.callId);
+        if (!ownedSources) {
+            ownedSources = new Map(projectCanonicalCapabilityResultCompactionSources({
+                head: params.head,
+                callId: execution.callId,
+            }).map((candidate) => [candidate.sourceRef, candidate]));
+            canonicalSources.set(execution.callId, ownedSources);
+        }
+        const canonical = ownedSources.get(source.sourceRef);
+        if (!canonical ||
+            canonical.sourceFingerprint !== source.sourceFingerprint ||
+            canonical.content !== source.content)
+            throw new CompactionSourceInvariantError("context_compaction_execution_source_changed", source.sourceRef);
+        return;
+    }
+    const message = readStoredSourceMessage(source);
+    const record = readSourceCapsuleHeader(message.content);
+    if (record.kind === "runtime_operation_supervision_evidence_v1") {
+        const call = requireSourceOwner(params.head, readSourceBindingCallId(record.binding), scopeCall);
+        assertHistoricalOperationSource({ source, head: params.head, call });
+        return;
+    }
+    if (record.kind === "runtime_child_result") {
+        const call = requireSourceOwner(params.head, record.callerCallId, scopeCall);
+        assertHistoricalChildResultSource({ source, head: params.head, call });
+        return;
+    }
+    if (record.kind === "runtime_reviewer_evidence_v1") {
+        assertOwnedReviewerSource(params, source, scopeCall);
+        return;
+    }
+    throw new CompactionSourceInvariantError("context_compaction_source_family_invalid", source.sourceRef);
+}
+function requireSourceOwner(head, callId, scopeCall) {
+    const call = head.state.calls.find((candidate) => candidate.callId === callId);
+    if (!call)
+        throw new Error("context_compaction_source_call_invalid");
+    if (scopeCall && scopeCall.callId !== call.callId)
+        throw new Error("context_compaction_source_call_invalid");
+    return call;
+}
+function assertOwnedReviewerSource(params, source, scopeCall) {
+    if (scopeCall) {
+        assertHistoricalReviewerSource({ ...params, source, call: scopeCall });
+        return;
+    }
+    const candidates = params.head.state.calls.filter((call) => call.roleId === "reviewer");
+    for (const call of candidates) {
+        try {
+            assertHistoricalReviewerSource({ ...params, source, call });
+            return;
+        }
+        catch {
+            /* Another historical reviewer may own this inventory source. */
+        }
+    }
+    throw new Error("context_compaction_reviewer_source_unowned");
+}
+function readSourceCapsuleHeader(content) {
+    let value;
+    try {
+        value = JSON.parse(content.split("\n", 1)[0]);
+    }
+    catch {
+        throw new Error("context_compaction_source_family_invalid");
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("context_compaction_source_family_invalid");
+    return value;
+}
+function readSourceBindingCallId(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return value.callId;
+}

package/dist/src/runtime/context/semantic-compaction/super-source-message.d.ts

@@ -0,0 +1,4 @@
+import type { ChatMessage } from "../../../model-gateway/types.js";
+import { type SemanticCompactionSource } from "./contracts.js";
+/** A registered digest alone does not authorize a model-visible source message. */
+export declare function readStoredSourceMessage(source: SemanticCompactionSource): ChatMessage;

package/dist/src/runtime/context/semantic-compaction/super-source-message.js

@@ -0,0 +1,23 @@
+import { createSemanticCompactionSha256Fingerprint as hash, } from "./contracts.js";
+/** A registered digest alone does not authorize a model-visible source message. */
+export function readStoredSourceMessage(source) {
+    if (hash(source.content) !== source.sourceFingerprint)
+        throw new Error("context_compaction_source_content_mismatch");
+    let message;
+    try {
+        message = JSON.parse(source.content);
+    }
+    catch {
+        throw new Error("context_compaction_source_message_invalid");
+    }
+    if (!message || typeof message !== "object" || Array.isArray(message))
+        throw new Error("context_compaction_source_message_invalid");
+    const record = message;
+    if (record.role !== "user")
+        throw new Error("context_compaction_source_message_invalid");
+    if (typeof record.content !== "string" || record.content.length === 0)
+        throw new Error("context_compaction_source_message_invalid");
+    if (Object.keys(record).some((key) => key !== "role" && key !== "content"))
+        throw new Error("context_compaction_source_message_invalid");
+    return record;
+}

package/dist/src/runtime/context/session-memory/model-step-controller.js

@@ -6,11 +6,6 @@ export function createSessionMemoryAwareCompactionController(request, activeRequ
     }
     const inputProjection = sessionMemory.project();
     return Object.freeze({
-        get compactionScope() {
-            return sessionMemory.project().compactableTurnCount > 0
-                ? "session_history"
-                : activeRequestController.compactionScope;
-        },
         project(messages) {
             const currentProjection = sessionMemory.project();
             const projected = replaceSessionMemoryProjection({
@@ -20,23 +15,42 @@ export function createSessionMemoryAwareCompactionController(request, activeRequ
             });
             return activeRequestController.project(projected);
         },
-        async prepare(messages) {
+        getStages() {
+            const activeStages = activeRequestController.getStages();
             const currentProjection = sessionMemory.project();
-            if (currentProjection.compactableTurnCount === 0) {
-                return activeRequestController.prepare(messages);
-            }
-            const prepared = await sessionMemory.prepare(request);
-            return Object.freeze({
-                messages: replaceSessionMemoryProjection({
-                    messages,
-                    current: currentProjection,
-                    next: prepared.projection,
+            const hasCompactableSessionHistory = currentProjection.compactableTurnCount > 0;
+            if (!hasCompactableSessionHistory)
+                return activeStages;
+            const scopeId = `session:${request.sessionId}:history`;
+            return Object.freeze([
+                Object.freeze({
+                    compactionScope: "session_history",
+                    scopeId,
+                    async prepare(messages) {
+                        const prepared = await sessionMemory.prepare(request);
+                        return Object.freeze({
+                            kind: "prepared",
+                            preparation: Object.freeze({
+                                messages: replaceSessionMemoryProjection({
+                                    messages,
+                                    current: currentProjection,
+                                    next: prepared.projection,
+                                }),
+                                commit: prepared.commit,
+                                scopeId,
+                                sourceRevision: prepared.checkpoint.sourceRevision,
+                                coveredSourceCount: prepared.coveredTurnCount,
+                                hasExhaustedCompactionSources: prepared.projection.compactableTurnCount === 0,
+                            }),
+                        });
+                    },
                 }),
-                commit: prepared.commit,
-                scopeId: `session:${request.sessionId}:history`,
-                sourceRevision: prepared.checkpoint.sourceRevision,
-                coveredSourceCount: prepared.coveredTurnCount,
-            });
+                ...activeStages,
+            ]);
+        },
+        hasExhaustedVerifiedCompactionSources(messages) {
+            return (sessionMemory.project().compactableTurnCount === 0 &&
+                activeRequestController.hasExhaustedVerifiedCompactionSources?.(messages) === true);
         },
     });
 }

package/dist/src/runtime/context/session-memory/selection.js

@@ -10,8 +10,6 @@ export function selectSessionMemoryProjection(params) {
     const uncoveredTurns = params.source.turns.slice(coveredTurnCount);
     const uncoveredMessageIds = new Set(uncoveredTurns.flatMap(({ userMessages, assistant }) => [...userMessages, assistant].map(({ id }) => id)));
     const historyMessages = params.source.historyMessages.filter(function retainsOriginalHistoryMessage(message) {
-        if (isAssistantInitiativeMessage(message))
-            return true;
         return uncoveredMessageIds.has(message.id);
     });
     const compactableTurnCount = Math.max(0, uncoveredTurns.length - SESSION_MEMORY_PROTECTED_TURN_COUNT);

package/dist/src/runtime/context/spark-conversation-policy.d.ts

@@ -0,0 +1,4 @@
+/** Identity and voice only; each consumer retains its own assignment and authority. */
+export declare const SPARK_COMPANION_VOICE_INSTRUCTIONS: readonly ["You are SPARK (ABot SPARK), the user's ongoing AI companion. Your purpose is to be someone the user can talk with, think aloud with and turn to for help, from everyday conversation to finding information, creating things and getting things done.", "Speak like a warm, thoughtful friend who helps: natural, informal, curious and lightly playful when it fits. Follow the user's mood and level of detail. Ordinary conversation can simply be conversation; do not force it into a task, intake interview or technical work report. Use technical detail or structured reports when they help with what the user actually wants. Avoid forced familiarity, constant cheerleading or excessive emojis.", "Write the entire user-facing reply in the language of the latest user-authored message, unless the user explicitly requests another language. Earlier suggestions or conversation, quoted material, sources and tool output do not select the reply language. Keep technical names and code in their original form when needed. Use the chosen language naturally without announcing, explaining or apologizing for a language change."];
+/** Static presentation policy bound to the canonical session, never client input. */
+export declare function buildSparkConversationInstructions(sessionKind: "spark" | undefined): readonly string[];

package/dist/src/runtime/context/spark-conversation-policy.js

@@ -0,0 +1,16 @@
+/** Identity and voice only; each consumer retains its own assignment and authority. */
+export const SPARK_COMPANION_VOICE_INSTRUCTIONS = [
+    "You are SPARK (ABot SPARK), the user's ongoing AI companion. Your purpose is to be someone the user can talk with, think aloud with and turn to for help, from everyday conversation to finding information, creating things and getting things done.",
+    "Speak like a warm, thoughtful friend who helps: natural, informal, curious and lightly playful when it fits. Follow the user's mood and level of detail. Ordinary conversation can simply be conversation; do not force it into a task, intake interview or technical work report. Use technical detail or structured reports when they help with what the user actually wants. Avoid forced familiarity, constant cheerleading or excessive emojis.",
+    "Write the entire user-facing reply in the language of the latest user-authored message, unless the user explicitly requests another language. Earlier suggestions or conversation, quoted material, sources and tool output do not select the reply language. Keep technical names and code in their original form when needed. Use the chosen language naturally without announcing, explaining or apologizing for a language change.",
+];
+/** Static presentation policy bound to the canonical session, never client input. */
+export function buildSparkConversationInstructions(sessionKind) {
+    if (sessionKind !== "spark")
+        return [];
+    return [
+        ...SPARK_COMPANION_VOICE_INSTRUCTIONS,
+        "This policy governs user-facing wording only, including acknowledgements and answers. It does not add a task, select a capability, grant permission or establish a result. Follow the current user's request and the normal execution and approval rules.",
+        "Earlier assistant turns, including suggestions you initiated, are your own prior messages in this conversation. Use the supplied conversation chronology to resolve what the user refers to and answer questions about what you said. An empty long-term-memory recall does not mean the supplied conversation is missing; do not claim you cannot remember or access a message that is present in that history. Previous suggestions are assistant history, not pending assignments or permission to act. Ground familiarity in available conversation and permitted memory; do not invent memories, observations, screen access or completed work.",
+    ];
+}

package/dist/src/runtime/context/super-compaction-failure-owner.d.ts

@@ -0,0 +1,10 @@
+import type { ExecutionPolicyAuthoritySnapshot, RoleCallLedgerHead } from "../orchestration/role-calls/contracts.js";
+import { type SuperContextFailureBinding } from "./super-context-failure.js";
+export type SuperCompactionFailureOwner = Readonly<{
+    binding: SuperContextFailureBinding;
+    head?: RoleCallLedgerHead;
+}>;
+/** Only canonical SUPER invocation boundaries may opt into owned failures. */
+export declare function superCompactionFailureOwner(authority: ExecutionPolicyAuthoritySnapshot, binding: SuperContextFailureBinding): SuperCompactionFailureOwner | undefined;
+/** Provider awaits stay outside this synchronous context-owned boundary. */
+export declare function withSuperCompactionFailure<T>(owner: SuperCompactionFailureOwner | undefined, operation: () => T): T;

package/dist/src/runtime/context/super-compaction-failure-owner.js

@@ -0,0 +1,64 @@
+import { hasSuperContextContract } from "./super-context-policy.js";
+import { createOwnedSuperContextFailure, SuperContextFailure, } from "./super-context-failure.js";
+import { InvalidatedCompactionScopeError } from "./semantic-compaction/scope-quarantine.js";
+import { CompactionSourceInvariantError } from "./compaction-source-invariant.js";
+/** Only canonical SUPER invocation boundaries may opt into owned failures. */
+export function superCompactionFailureOwner(authority, binding) {
+    if (!hasSuperContextContract(authority, binding.contractId))
+        return undefined;
+    return Object.freeze({ binding: Object.freeze({ ...binding }) });
+}
+/** Provider awaits stay outside this synchronous context-owned boundary. */
+export function withSuperCompactionFailure(owner, operation) {
+    try {
+        return operation();
+    }
+    catch (cause) {
+        if (!owner || cause instanceof SuperContextFailure)
+            throw cause;
+        const code = ownedSourceInvariantCode(cause);
+        if (!code)
+            throw cause;
+        const binding = cause instanceof CompactionSourceInvariantError && cause.sourceRef
+            ? { ...owner.binding, sourceRef: cause.sourceRef }
+            : owner.binding;
+        if (owner.head) {
+            throw createOwnedSuperContextFailure({
+                code,
+                head: owner.head,
+                cause,
+                binding,
+            });
+        }
+        // The role return boundary independently checks this trusted invocation
+        // binding against its canonical ledger head before routing the failure.
+        throw new SuperContextFailure(code, binding, cause);
+    }
+}
+function ownedSourceInvariantCode(cause) {
+    if (cause instanceof InvalidatedCompactionScopeError)
+        return cause.code;
+    if (!(cause instanceof Error))
+        return undefined;
+    switch (cause.message) {
+        case "operation_supervision_evidence_message_binding_invalid":
+        case "operation_supervision_evidence_context_binding_invalid":
+            return "context_compaction_execution_owner_invalid";
+        case "operation_supervision_evidence_exact_binding_invalid":
+        case "operation_supervision_evidence_exact_lane_invalid":
+            return "context_compaction_source_identity_conflict";
+        case "context_compaction_source_identity_conflict":
+        case "request_tool_results_compaction_source_missing":
+        case "request_tool_results_compaction_fingerprint_mismatch":
+        case "context_compaction_scope_invalidated":
+        case "context_compaction_checkpoint_revision_invalid":
+        case "context_compaction_checkpoint_content_invalid":
+        case "context_compaction_checkpoint_source_invalid":
+        case "context_compaction_checkpoint_invalid":
+        case "context_compaction_execution_owner_invalid":
+        case "context_compaction_snapshot_source_incompatible":
+            return cause.message;
+        default:
+            return undefined;
+    }
+}

package/dist/src/runtime/context/super-context-failure.d.ts

@@ -0,0 +1,28 @@
+import type { ModelStep } from "../../shared/model-steps.js";
+import type { RoleCallLedgerHead } from "../orchestration/role-calls/contracts.js";
+export type SuperContextFailureCode = "context_compaction_source_identity_conflict" | "request_tool_results_compaction_source_missing" | "request_tool_results_compaction_fingerprint_mismatch" | "context_compaction_scope_invalidated" | "context_compaction_checkpoint_revision_invalid" | "context_compaction_checkpoint_content_invalid" | "context_compaction_checkpoint_source_invalid" | "context_compaction_checkpoint_invalid" | "context_compaction_execution_owner_invalid" | "context_compaction_snapshot_source_incompatible";
+export type SuperContextFailureBinding = Readonly<{
+    requestId: string;
+    callId: string;
+    parentCallId: string | null;
+    contractId: string;
+    invocationAttempt: number;
+    sourceRevision: number;
+    modelStep: ModelStep;
+    phase: string;
+    scopeId: string;
+    sourceRef?: string;
+}>;
+/** Internal provenance only; never projects the caught error or source bodies. */
+export declare class SuperContextFailure extends Error {
+    readonly code: SuperContextFailureCode;
+    readonly binding: SuperContextFailureBinding;
+    constructor(code: SuperContextFailureCode, binding: SuperContextFailureBinding, cause: unknown);
+}
+/** Mint only at an owning context seam with a concrete frozen invocation. */
+export declare function createOwnedSuperContextFailure(params: {
+    code: SuperContextFailureCode;
+    binding: SuperContextFailureBinding;
+    head: RoleCallLedgerHead;
+    cause: unknown;
+}): SuperContextFailure;

package/dist/src/runtime/context/super-context-failure.js

@@ -0,0 +1,37 @@
+import { hasSuperContextContract } from "./super-context-policy.js";
+/** Internal provenance only; never projects the caught error or source bodies. */
+export class SuperContextFailure extends Error {
+    code;
+    binding;
+    constructor(code, binding, cause) {
+        super(code, { cause });
+        this.code = code;
+        this.name = "SuperContextFailure";
+        this.binding = Object.freeze({ ...binding });
+    }
+}
+/** Mint only at an owning context seam with a concrete frozen invocation. */
+export function createOwnedSuperContextFailure(params) {
+    if (!hasSuperContextContract(params.head.policy.authority, params.binding.contractId)) {
+        throw params.cause;
+    }
+    if (params.head.state.requestId !== params.binding.requestId)
+        throw params.cause;
+    const call = params.head.state.calls.find(({ callId }) => callId === params.binding.callId);
+    if (!call)
+        throw params.cause;
+    if (call.parentCallId !== params.binding.parentCallId)
+        throw params.cause;
+    if (call.activationCount !== params.binding.invocationAttempt)
+        throw params.cause;
+    if (params.head.revision !== params.binding.sourceRevision)
+        throw params.cause;
+    if (!isFailureContractBoundToRole(params.binding.contractId, call.roleId))
+        throw params.cause;
+    return new SuperContextFailure(params.code, params.binding, params.cause);
+}
+function isFailureContractBoundToRole(contractId, roleId) {
+    if (contractId === "supervisor")
+        return roleId === "supervisor";
+    return contractId === `delegated.${roleId}`;
+}

package/dist/src/runtime/context/super-context-policy.d.ts

@@ -0,0 +1,3 @@
+import { type ExecutionPolicyAuthoritySnapshot } from "../orchestration/role-calls/contracts.js";
+/** Opt-in follows the frozen registered contract, never a model or role name. */
+export declare function hasSuperContextContract(authority: ExecutionPolicyAuthoritySnapshot, contractId: string): boolean;