@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/orchestration/worker-capabilities/binding/invocation-preparation.js

@@ -17,14 +17,10 @@ export class CapabilityInvocationPreparer {
     #byCapabilityId;
     #capabilityScope;
     #diagnostic;
-    #workerPrincipal;
     constructor(params) {
         this.#byCapabilityId = params.byCapabilityId;
         this.#capabilityScope = params.capabilityScope;
         this.#diagnostic = params.diagnostic;
-        this.#workerPrincipal =
-            params.boundCall.roleId === "worker" &&
-                params.boundCall.parentCallId !== null;
     }
     prepareSingle(input) {
         const adapter = this.#resolveAvailableAdapter(input.capabilityId, SINGLE_CAPABILITY_LOOKUP_ISSUES);
@@ -39,7 +35,6 @@ export class CapabilityInvocationPreparer {
         const authoringObjective = normalizeAuthoringObjective({
             input,
             descriptor: adapter.descriptor,
-            workerPrincipal: this.#workerPrincipal,
         });
         if (!authoringObjective.ok) {
             this.#rejectSelection(authoringObjective.issueCode, input.capabilityId);
@@ -78,7 +73,6 @@ export class CapabilityInvocationPreparer {
         const authoringObjective = normalizeAuthoringObjective({
             input: candidate,
             descriptor: adapter.descriptor,
-            workerPrincipal: this.#workerPrincipal,
         });
         if (!authoringObjective.ok) {
             this.#rejectSelection(`batch_${authoringObjective.issueCode}`, candidate.capabilityId);
@@ -139,8 +133,7 @@ function normalizeCapabilityIntent(input) {
 }
 function normalizeAuthoringObjective(input) {
     const supplied = Object.hasOwn(input.input, "authoringObjective");
-    const required = input.workerPrincipal &&
-        input.descriptor.requiresPayloadAuthoringObjective === true;
+    const required = input.descriptor.requiresPayloadAuthoringObjective === true;
     if (!required && supplied) {
         return { ok: false, issueCode: "authoring_objective_forbidden" };
     }

package/dist/src/runtime/orchestration/worker-capabilities/contracts.d.ts

@@ -12,7 +12,7 @@ export declare const WORKER_CAPABILITY_SUMMARY_MAX_LENGTH = 512;
 export declare const WORKER_CAPABILITY_COUNT_MAX = 128;
 export declare const WORKER_CAPABILITY_CONTROL_COUNT_MAX = 16;
 export declare const WORKER_CAPABILITY_CONTROL_ID_MAX_LENGTH = 64;
-export declare const WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH = 4096;
+export { TOOL_NORMAL_INVOCATION_STRING_MAX_LENGTH as WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH, } from "../../../capabilities/normal-invocation/contracts.js";
 export declare const WORKER_CAPABILITY_CONTROL_ENUM_MAX_VALUES = 64;
 export declare const WORKER_CAPABILITY_CONTROL_ENUM_VALUE_MAX_LENGTH = 256;
 export declare const WORKER_CAPABILITY_CONTROL_ARRAY_MAX_ITEMS = 64;
@@ -95,7 +95,7 @@ export type WorkerCapabilityDescriptor = Readonly<{
     routingCapability?: ToolRoutingCapability;
     /** Manifest-owned development phases served by this capability. */
     developmentRoles?: readonly ToolDevelopmentRole[];
-    /** Canonical payload contract requires a Worker authoring receipt. */
+    /** Canonical payload contract requires an accepted authoring assignment. */
     requiresPayloadAuthoringObjective?: true;
 }>;
 export type WorkerCapabilityControls = Readonly<Record<string, unknown>>;
@@ -145,7 +145,7 @@ export type WorkerCapabilityAdapterExecutionInput<TContext> = Readonly<{
     executionId: string;
     /** Client-facing presentation metadata for lifecycle events only. */
     intent: string;
-    /** Worker-only payload assignment; forbidden for root and non-payload calls. */
+    /** Accepted payload assignment; forbidden for non-payload calls. */
     authoringObjective?: string;
     controls: WorkerCapabilityControls;
     settledCapabilityResults: readonly WorkerSettledCapabilityResult[];
@@ -266,4 +266,3 @@ export type WorkerCapabilityBinding<TContext> = Readonly<{
         }>[];
     }>): Promise<WorkerCapabilityBatchAttemptReference>;
 }>;
-export {};

package/dist/src/runtime/orchestration/worker-capabilities/contracts.js

@@ -8,7 +8,7 @@ export const WORKER_CAPABILITY_SUMMARY_MAX_LENGTH = 512;
 export const WORKER_CAPABILITY_COUNT_MAX = 128;
 export const WORKER_CAPABILITY_CONTROL_COUNT_MAX = 16;
 export const WORKER_CAPABILITY_CONTROL_ID_MAX_LENGTH = 64;
-export const WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH = 4_096;
+export { TOOL_NORMAL_INVOCATION_STRING_MAX_LENGTH as WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH, } from "../../../capabilities/normal-invocation/contracts.js";
 export const WORKER_CAPABILITY_CONTROL_ENUM_MAX_VALUES = 64;
 export const WORKER_CAPABILITY_CONTROL_ENUM_VALUE_MAX_LENGTH = 256;
 export const WORKER_CAPABILITY_CONTROL_ARRAY_MAX_ITEMS = 64;

package/dist/src/runtime/orchestration/worker-capabilities/execution/context-projection.js

@@ -1,5 +1,6 @@
 import { traceWorkerCapabilityContextProjected, traceWorkerCapabilityContextRejected, } from "../diagnostics.js";
 import { projectWorkerSettledCapabilityResults } from "../settled-results.js";
+import { bindSuperWorkerCompactionSources } from "../../../context/super-worker-compaction-sidecar.js";
 import { assertWorkerCapabilityWithinScope, WorkerCapabilityScopeError, } from "../scope.js";
 export function assertExecutionCapabilityScope(projection, descriptor, diagnostic) {
     try {
@@ -32,7 +33,7 @@ export function projectExecutionSettledCapabilityResults(params) {
     for (const descriptor of params.descriptors) {
         traceWorkerCapabilityContextProjected(params.diagnostic, descriptor, settledCapabilityResults);
     }
-    return settledCapabilityResults;
+    return bindSuperWorkerCompactionSources([...settledCapabilityResults], params.head, params.call.callId);
 }
 function settledResultProjectionIssueCode(error) {
     if (!(error instanceof Error)) {

package/dist/src/runtime/orchestration/worker-capabilities/payload-assignment-validation.js

@@ -2,21 +2,21 @@ import { WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH } from "./contracts.js
 import { isWorkerCapabilityPayloadSourceProvenanceValid } from "./payload-source-provenance.js";
 /** Validates payload assignment ownership before any model boundary is built. */
 export function isWorkerCapabilityPayloadAssignmentValid(input, principalKind, requestId) {
-    if (principalKind === "root") {
-        return (input.assignmentProvenance === undefined &&
-            !Object.hasOwn(input, "authoringObjective") &&
-            hasExecutionId(input.executionId));
-    }
     if (!hasExecutionId(input.executionId))
         return false;
-    if (!isWorkerCapabilityPayloadSourceProvenanceValid(input.assignmentProvenance, input.call, requestId)) {
-        return false;
-    }
     if (input.descriptor.requiresPayloadAuthoringObjective !== true)
         return false;
     if (!Object.hasOwn(input, "authoringObjective"))
         return false;
-    return isValidAuthoringObjective(input.authoringObjective);
+    if (!isValidAuthoringObjective(input.authoringObjective))
+        return false;
+    if (principalKind === "root") {
+        return input.assignmentProvenance === undefined;
+    }
+    if (!isWorkerCapabilityPayloadSourceProvenanceValid(input.assignmentProvenance, input.call, requestId)) {
+        return false;
+    }
+    return true;
 }
 function hasExecutionId(executionId) {
     return typeof executionId === "string" && executionId.length > 0;

package/dist/src/runtime/orchestration/worker-capabilities/payload-author.js

@@ -1,9 +1,11 @@
+import { immutableSnapshot } from "./payload-context-snapshot.js";
+import { projectWorkerPayloadCompactionInput } from "./payload-compaction-transport.js";
 import { isRoleCapabilityId, isRoleCallResultText, ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH, ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX, ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH, ROLE_CAPABILITY_EXECUTION_LIMIT_MAX, ROLE_CALL_RESULT_MAX_LENGTH, } from "../role-calls/index.js";
 import { normalizeCapabilityAdapterResult } from "../capability-adapters/result.js";
 import { traceWorkerCapabilityPayloadCompleted, traceWorkerCapabilityPayloadFailed, traceWorkerCapabilityPayloadStarted, } from "./payload-diagnostics.js";
 import { WORKER_CAPABILITY_RAW_PAYLOAD_MODEL_STEP, WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_CHARS, WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_COUNT, WorkerCapabilityPayloadBudgetExceededError, WorkerCapabilityPayloadValidationError, } from "./payload-contracts.js";
 import { ROOT_CAPABILITY_PAYLOAD_INSTRUCTIONS, ROOT_CAPABILITY_STAGED_RAW_PAYLOAD_INSTRUCTIONS, ROOT_CAPABILITY_STRUCTURED_PAYLOAD_INSTRUCTIONS, WORKER_CAPABILITY_PAYLOAD_INSTRUCTIONS, WORKER_CAPABILITY_STAGED_RAW_PAYLOAD_INSTRUCTIONS, WORKER_CAPABILITY_STRUCTURED_PAYLOAD_INSTRUCTIONS, } from "./payload-instructions.js";
-import { validateJsonSchemaValue } from "../../model/json-schema-value.js";
+import { normalizePayloadBody } from "./payload-body-normalization.js";
 import { isRuntimeDelegateRoleId } from "../roles.js";
 import { projectWorkerPayloadRequestSourceProjection } from "./payload-source-provenance.js";
 import { isWorkerCapabilityPayloadAssignmentValid } from "./payload-assignment-validation.js";
@@ -80,6 +82,7 @@ export function createWorkerCapabilityPayloadAuthor(params) {
             let output;
             try {
                 output = await params.model.invoke({
+                    ...projectWorkerPayloadCompactionInput(input, params.requestId),
                     executionId: input.executionId,
                     requestSourceProjection: "root" in context
                         ? "full_request"
@@ -107,10 +110,11 @@ export function createWorkerCapabilityPayloadAuthor(params) {
             if (typeof output !== "string") {
                 return failure(diagnostic, "payload_model_output_invalid");
             }
-            const body = normalizeAuthoredBody(output, input.contract.responseFormat);
-            if (body === undefined) {
+            const normalized = normalizePayloadBody(output, input.contract.responseFormat);
+            if (!normalized.ok) {
                 return failure(diagnostic, "payload_model_output_invalid");
             }
+            const body = normalized.body;
             const payloadBytes = Buffer.byteLength(body, "utf8");
             if (payloadBytes < input.contract.minBytes) {
                 return failure(diagnostic, "payload_body_too_small");
@@ -186,6 +190,7 @@ function capturePayloadContext(input, capabilityAuthorities, requestId) {
             acceptedCapability: {
                 capabilityId: input.descriptor.capabilityId,
                 summary: input.descriptor.summary,
+                authoringObjective: input.authoringObjective,
                 controls: input.controls,
             },
             ...sharedContext,
@@ -330,22 +335,6 @@ function normalizePayloadContextScope(input) {
         ? input
         : undefined;
 }
-function normalizeAuthoredBody(output, responseFormat) {
-    if (!responseFormat) {
-        return output;
-    }
-    try {
-        const parsed = JSON.parse(output);
-        if (responseFormat !== "json" &&
-            validateJsonSchemaValue(responseFormat, parsed)) {
-            return undefined;
-        }
-        return JSON.stringify(parsed);
-    }
-    catch {
-        return undefined;
-    }
-}
 function validResponseFormat(input) {
     return input === undefined || input === "json" || isPlainRecord(input);
 }
@@ -354,7 +343,7 @@ function validPayloadStage(input) {
         (Number.isSafeInteger(input.index) &&
             input.index > 0 &&
             Number.isSafeInteger(input.count) &&
-            input.count > 1 &&
+            input.count >= 1 &&
             input.index <= input.count &&
             typeof input.outputParam === "string" &&
             input.outputParam.trim().length > 0 &&
@@ -562,9 +551,6 @@ function failure(diagnostic, code, error) {
     traceWorkerCapabilityPayloadFailed(diagnostic, code, error);
     return Object.freeze({ status: "failed", code });
 }
-function immutableSnapshot(value) {
-    return deepFreeze(structuredClone(value));
-}
 function payloadAbort(reason) {
     const error = reason instanceof Error
         ? new Error(reason.message, { cause: reason })
@@ -572,13 +558,3 @@ function payloadAbort(reason) {
     error.name = "AbortError";
     return error;
 }
-function deepFreeze(value, seen = new WeakSet()) {
-    if (typeof value !== "object" || value === null || seen.has(value)) {
-        return value;
-    }
-    seen.add(value);
-    for (const child of Object.values(value)) {
-        deepFreeze(child, seen);
-    }
-    return Object.freeze(value);
-}

package/dist/src/runtime/orchestration/worker-capabilities/payload-body-normalization.d.ts

@@ -0,0 +1,12 @@
+import { type JsonSchemaValueValidationIssue } from "../../model/json-schema-value.js";
+import type { WorkerCapabilityPayloadResponseFormat } from "./payload-contracts.js";
+type PayloadBodyNormalization = Readonly<{
+    ok: true;
+    body: string;
+}> | Readonly<{
+    ok: false;
+    issue: JsonSchemaValueValidationIssue;
+}>;
+/** Normalizes declared JSON payloads without discarding repeated members. */
+export declare function normalizePayloadBody(body: string, responseFormat: WorkerCapabilityPayloadResponseFormat | undefined): PayloadBodyNormalization;
+export {};

package/dist/src/runtime/orchestration/worker-capabilities/payload-body-normalization.js

@@ -0,0 +1,80 @@
+import { validateJsonSchemaValue, } from "../../model/json-schema-value.js";
+/** Normalizes declared JSON payloads without discarding repeated members. */
+export function normalizePayloadBody(body, responseFormat) {
+    if (!responseFormat)
+        return Object.freeze({ ok: true, body });
+    try {
+        if (hasDuplicateJsonObjectMembers(body)) {
+            return invalidPayloadJson("JSON object member names must be unique within each object.");
+        }
+        const parsed = JSON.parse(body);
+        const issue = responseFormat === "json"
+            ? undefined
+            : validateJsonSchemaValue(responseFormat, parsed);
+        if (issue)
+            return Object.freeze({ ok: false, issue });
+        return Object.freeze({ ok: true, body: JSON.stringify(parsed) });
+    }
+    catch {
+        return invalidPayloadJson("Return one valid JSON value matching the frozen response format.");
+    }
+}
+function invalidPayloadJson(message) {
+    return Object.freeze({
+        ok: false,
+        issue: Object.freeze({ path: "output", message }),
+    });
+}
+/** Only checks member identity; JSON.parse remains the syntax/value decoder. */
+function hasDuplicateJsonObjectMembers(body) {
+    const containers = [];
+    for (let offset = 0; offset < body.length; offset += 1) {
+        const token = body[offset];
+        if (token === "{") {
+            containers.push(new Set());
+            continue;
+        }
+        if (token === "[") {
+            containers.push(undefined);
+            continue;
+        }
+        if (token === "}" || token === "]") {
+            containers.pop();
+            continue;
+        }
+        if (token !== '"')
+            continue;
+        const start = offset;
+        const end = jsonStringEnd(body, start);
+        offset = end;
+        const members = containers.at(-1);
+        if (!isJsonObjectMember(body, end, members))
+            continue;
+        const member = JSON.parse(body.slice(start, end + 1));
+        if (members.has(member))
+            return true;
+        members.add(member);
+    }
+    return false;
+}
+function isJsonObjectMember(body, stringEnd, members) {
+    if (!members)
+        return false;
+    let next = stringEnd + 1;
+    while (/[ \t\r\n]/u.test(body[next] ?? ""))
+        next += 1;
+    return body[next] === ":";
+}
+function jsonStringEnd(body, start) {
+    let offset = start + 1;
+    while (offset < body.length) {
+        if (body[offset] === "\\") {
+            offset += 2;
+            continue;
+        }
+        if (body[offset] === '"')
+            return offset;
+        offset += 1;
+    }
+    throw new SyntaxError("Unterminated JSON string.");
+}

package/dist/src/runtime/orchestration/worker-capabilities/payload-compaction-transport.d.ts

@@ -0,0 +1,3 @@
+import type { WorkerCapabilityPayloadAuthor, WorkerCapabilityPayloadModelRequest } from "./payload-contracts.js";
+/** Runtime-only sidecar bypasses the cloned/model-visible payload context. */
+export declare function projectWorkerPayloadCompactionInput(input: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0], requestId: string): Pick<WorkerCapabilityPayloadModelRequest, "superWorkerCompaction">;

package/dist/src/runtime/orchestration/worker-capabilities/payload-compaction-transport.js

@@ -0,0 +1,14 @@
+import { assertSuperWorkerCompactionSidecarBinding, readSuperWorkerCompactionSidecar, } from "../../context/super-worker-compaction-sidecar.js";
+/** Runtime-only sidecar bypasses the cloned/model-visible payload context. */
+export function projectWorkerPayloadCompactionInput(input, requestId) {
+    if (input.call.roleId !== "worker")
+        return {};
+    const sidecar = readSuperWorkerCompactionSidecar(input.settledCapabilityResults);
+    if (!sidecar)
+        return {};
+    assertSuperWorkerCompactionSidecarBinding(sidecar, {
+        requestId,
+        callId: input.call.callId,
+    });
+    return { superWorkerCompaction: sidecar };
+}

package/dist/src/runtime/orchestration/worker-capabilities/payload-context-snapshot.d.ts

@@ -0,0 +1,2 @@
+/** Captures payload data without retaining mutable adapter-owned objects. */
+export declare function immutableSnapshot<T>(value: T): T;

package/dist/src/runtime/orchestration/worker-capabilities/payload-context-snapshot.js

@@ -0,0 +1,12 @@
+/** Captures payload data without retaining mutable adapter-owned objects. */
+export function immutableSnapshot(value) {
+    return deepFreeze(structuredClone(value));
+}
+function deepFreeze(value, seen = new WeakSet()) {
+    if (typeof value !== "object" || value === null || seen.has(value))
+        return value;
+    seen.add(value);
+    for (const child of Object.values(value))
+        deepFreeze(child, seen);
+    return Object.freeze(value);
+}

package/dist/src/runtime/orchestration/worker-capabilities/payload-contracts.d.ts

@@ -1,3 +1,4 @@
+import type { SuperWorkerCompactionSidecar } from "../../context/super-worker-compaction-sidecar.js";
 import type { RoleCallDependencyResult, RoleCallFrame } from "../role-calls/index.js";
 import type { WorkerCapabilityControls, WorkerCapabilityDescriptor, WorkerCapabilityExecutionFreshness, WorkerCapabilityPayloadSourceProvenance, WorkerSettledCapabilityResult } from "./contracts.js";
 export declare const WORKER_CAPABILITY_RAW_PAYLOAD_MODEL_STEP: "tool_payload.raw";
@@ -74,10 +75,13 @@ export type WorkerCapabilityPayloadContext = Readonly<{
     acceptedCapability: Readonly<{
         capabilityId: string;
         summary: string;
+        authoringObjective: string;
         controls: WorkerCapabilityControls;
     }>;
 } & WorkerCapabilityPayloadSharedContext>;
 export type WorkerCapabilityPayloadModelRequest = Readonly<{
+    /** Internal SUPER evidence; never copied into context or tool parameters. */
+    superWorkerCompaction?: SuperWorkerCompactionSidecar;
     /** Runtime-only binding; it is not projected into the model payload. */
     executionId: string;
     /** Runtime-only selection of reference context for this assignment. */
@@ -104,7 +108,7 @@ export type WorkerCapabilityPayloadAuthor = Readonly<{
         assignmentProvenance?: WorkerCapabilityPayloadSourceProvenance;
         executionId: string;
         descriptor: WorkerCapabilityDescriptor;
-        /** Required for Worker payloads and forbidden for direct-root payloads. */
+        /** Required bounded assignment for Worker and direct-root payloads. */
         authoringObjective?: string;
         controls: WorkerCapabilityControls;
         contextScope?: WorkerCapabilityPayloadContextScope;

package/dist/src/runtime/orchestration/worker-capabilities/payload-instructions.js

@@ -26,7 +26,7 @@ export const WORKER_CAPABILITY_STRUCTURED_PAYLOAD_INSTRUCTIONS = [
     "Canonical assignment metadata is transported as structured JSON. Current target and related artifact contents, when supplied, are separate verbatim reference messages; read their literal characters and line breaks exactly.",
     "Return one JSON value matching the supplied response format. Do not wrap it in Markdown fences or commentary.",
 ].join("\n");
-const ROOT_ASSIGNMENT_OBJECTIVE_INSTRUCTION = "The exact current user request in runtime_request_source_v1.currentRequest and root.updates through the frozen root.steeringVersion define the complete bounded assignment objective. Apply root.updates in sequence. acceptedCapability.controls are the immutable execution parameters for that objective. Do not expand, replace, or reinterpret the objective sources, updates, or controls.";
+const ROOT_ASSIGNMENT_OBJECTIVE_INSTRUCTION = "acceptedCapability.authoringObjective is the complete bounded content-authoring assignment for this invocation. It is constrained by the exact current user request in runtime_request_source_v1.currentRequest and root.updates through the frozen root.steeringVersion. Apply root.updates in sequence. Use precedingTurn only to resolve references in the current request, never as independent work or authorization. acceptedCapability.controls are the immutable execution parameters for that objective. Do not expand, replace, or reinterpret the assignment, objective sources, updates, or controls.";
 export const ROOT_CAPABILITY_PAYLOAD_INSTRUCTIONS = [
     "Author only the raw body required by the immutable capability payload assignment.",
     ROOT_ASSIGNMENT_OBJECTIVE_INSTRUCTION,

package/dist/src/runtime/passive-learning/background-dependencies.d.ts

@@ -16,7 +16,6 @@ export type LearningProactiveLifecycle = Readonly<{
     knowledgeChanged(): void;
     beginInteractive(): () => void;
     status(): Promise<ProactiveStatus>;
-    dismiss(id: string): Promise<void>;
     sessionDeleted?(sessionId: string): Promise<void>;
 }>;
 export type LearningReassessmentLifecycle = Readonly<{

package/dist/src/runtime/passive-learning/contracts.d.ts

@@ -2,7 +2,6 @@ import type { HostObservationEvent, PassiveObservation, PassiveCollectionState }
 import type { ObservationMemoryProposal } from "../long-term-memory/observation-contracts.js";
 import type { LearningCandidateRecord, LearningKnowledgeContext, LearningMemoryDecision, LearningReviewCause, MaturationPolicy } from "../long-term-memory/maturation/contracts.js";
 import type { CoWorkerResourceLimits, CoWorkerResourceUsage } from "./resources/contracts.js";
-import type { ProactiveProposal } from "./proactive/contracts.js";
 import type { LearningApplicationSummary } from "./application-catalog.js";
 import type { CoWorkerReviewProgress, ReviewProgressPort } from "./review-progress.js";
 export type PassiveLearningPreferences = Readonly<{
@@ -27,6 +26,8 @@ export type PassiveLearningPreferences = Readonly<{
     proactiveEnabled?: boolean;
     /** Absent inherits the learning model; null explicitly clears an override. */
     proactiveModelProfileId?: string | null;
+    /** Explicit companion-chat permissions, independent of collection authorization. */
+    sparkToolPermissionMode?: "ask" | "full_access" | "full_plus";
     proactiveIntervalMinutes?: number;
     proactiveWindow?: LearningAnalysisWindow | null;
     proactiveMessagesPerDay?: number;
@@ -108,7 +109,6 @@ export type ProactiveStatus = Readonly<{
     deliveredToday?: number;
     nextReviewAt?: string;
     reason?: string;
-    proposals: readonly ProactiveProposal[];
 }>;
 export type LearningChangedEvent = Readonly<{
     type: "proposal_delivered";
@@ -161,7 +161,6 @@ export type PassiveLearningService = Readonly<{
     flush(): Promise<void>;
     beginInteractive(): () => void;
     subscribe(listener: (event?: LearningChangedEvent) => void): () => void;
-    dismissProposal?(id: string): Promise<void>;
     sessionDeleted?(sessionId: string): Promise<void>;
     notifyKnowledgeChanged?(): void;
     candidates?(): Promise<readonly Omit<LearningCandidateRecord, "embedding">[]>;

package/dist/src/runtime/passive-learning/proactive/agent.d.ts

@@ -1,5 +1,6 @@
 import type { LearningMemoryService } from "../../long-term-memory/maturation/contracts.js";
 import type { SessionStore } from "../../ports.js";
+import type { SessionRequestAdmission } from "../../request/session-admission.js";
 import type { LearningBackgroundContext } from "../background-dependencies.js";
 import type { ProactiveStatus } from "../contracts.js";
 import type { CoWorkerResourceBudget } from "../resources/budget.js";
@@ -24,6 +25,7 @@ export declare class CoWorkerProactiveAgent {
         memory: LearningMemoryService;
         model: ReturnType<typeof createRuntimeProactiveModel>;
         sessions: SessionStore;
+        deliveryAdmission?: Pick<SessionRequestAdmission, "run">;
         budget: CoWorkerResourceBudget;
         now?: () => number;
     });
@@ -40,6 +42,7 @@ export declare class CoWorkerProactiveAgent {
     private run;
     private deliverPending;
     private deliver;
+    private withDeliveryAdmission;
     private arm;
     private scheduleKey;
     private publishScheduleChange;

package/dist/src/runtime/passive-learning/proactive/agent.js

@@ -1,10 +1,12 @@
 import { randomUUID } from "node:crypto";
+import { SPARK_SESSION_ID } from "../../../sessions/spark-session.js";
+import { hasVisibleAssistantInitiative } from "../../../sessions/assistant-initiative-append.js";
 import { LearningAnalysisClock } from "../analysis-clock.js";
 import { isWithinAnalysisWindow, nextAnalysisInstant } from "../analysis-schedule.js";
 import { canDeliverProactiveProposal, hasProactiveReviewAttempt, isPendingProposalCurrent, isProactiveReviewEligible } from "./contracts.js";
 import { countProactiveDeliveries, createProactiveStateStore } from "./store.js";
 import { runStagedProactiveAgentReview } from "./staged-agent-review.js";
-import { canResumeStagedProactiveAttempt, hasCompletedStagedProactiveProgress, hasExpiredStagedProactiveProgress } from "./staged-progress-store.js";
+import { canResumeStagedProactiveAttempt, hasExpiredStagedProactiveProgress } from "./staged-progress-store.js";
 export class CoWorkerProactiveAgent {
     options;
     store;
@@ -96,7 +98,7 @@ export class CoWorkerProactiveAgent {
     }
     async status() {
         const [state, usage] = await Promise.all([this.store.read(), this.options.budget.status()]);
-        return { state: this.stateLabel(), proposals: state.proposals.slice(-20),
+        return { state: this.stateLabel(),
             deliveredToday: countProactiveDeliveries(state, usage.startedAt),
             ...(this.reason ? { reason: this.reason } : {}),
             ...(this.clock.scheduledAt ? { nextReviewAt: new Date(this.clock.scheduledAt).toISOString() } : {}) };
@@ -124,9 +126,9 @@ export class CoWorkerProactiveAgent {
         if (await this.deliverPending(state, signal, generation))
             return;
         const usage = await this.options.budget.status();
-        if (this.limitReached(state, usage, this.canCompleteSavedReview(state)))
-            return;
         const context = await this.options.memory.overview();
+        if (this.limitReached(state, usage, await this.canCompleteSavedReview(state, context, signal)))
+            return;
         const last = state.lastReviewedAt ? Date.parse(state.lastReviewedAt) : 0;
         const eligible = isProactiveReviewEligible({ enabled: this.canRun(), insideWindow: this.insideWindow(),
             interactiveBusy: this.options.context.isInteractiveBusy(), now: this.now(), nextAllowedAt: Math.max(this.retryNotBefore, this.reviewNotBefore, last + this.interval()),
@@ -201,15 +203,16 @@ export class CoWorkerProactiveAgent {
         return true;
     }
     deliver(proposal, signal, generation) {
-        const next = this.controls.then(async () => {
+        const next = this.controls.then(() => this.withDeliveryAdmission(async () => {
             this.assertCurrent(signal, generation);
             if (!this.insideWindow())
                 return;
-            if (!this.options.sessions.createAssistantConversation)
+            if (!this.options.sessions.appendAssistantInitiative)
                 throw new Error("proactive_session_delivery_unavailable");
-            await this.options.sessions.createAssistantConversation(proposal.sessionId, {
+            const conversation = await this.options.sessions.appendAssistantInitiative(SPARK_SESSION_ID, {
                 title: proposal.title, content: proposal.message,
-                initiative: { kind: "proactive_proposal_v1", proposalId: proposal.id, reason: proposal.reason, sources: proposal.sources },
+                initiative: { kind: "proactive_proposal_v1", proposalId: proposal.id, reason: proposal.reason, sources: proposal.sources,
+                    ...(proposal.handoffBrief === undefined ? {} : { handoffBrief: proposal.handoffBrief, handoffTitle: proposal.title }) },
                 assertCurrent: () => {
                     this.assertCurrent(signal, generation);
                     if (!this.insideWindow())
@@ -217,13 +220,22 @@ export class CoWorkerProactiveAgent {
                 },
             });
             const usage = await this.options.budget.ensureCurrentWindow();
-            await this.store.markDelivered(proposal.id, this.now(), usage.startedAt);
+            await this.store.markDelivered(proposal.id, this.now(), usage.startedAt, SPARK_SESSION_ID);
+            if (!hasVisibleAssistantInitiative(conversation, proposal.id))
+                return;
             if (this.canRun() && generation === this.generation && !signal.aborted)
-                this.options.context.changed({ type: "proposal_delivered", proposalId: proposal.id, sessionId: proposal.sessionId });
-        });
+                this.options.context.changed({ type: "proposal_delivered", proposalId: proposal.id, sessionId: SPARK_SESSION_ID });
+        }));
         this.controls = next.catch(() => { });
         return next;
     }
+    withDeliveryAdmission(deliver) {
+        if (!this.options.deliveryAdmission)
+            return deliver();
+        // Notifications share clear reservations, but do not resume requests or inherit
+        // their saved-approval eligibility. Keep the existing proactive eligibility checks.
+        return this.options.deliveryAdmission.run(SPARK_SESSION_ID, deliver, true);
+    }
     async arm() {
         const revision = ++this.armRevision;
         const before = this.scheduleKey();
@@ -265,7 +277,7 @@ export class CoWorkerProactiveAgent {
             earliest = Math.max(earliest, Date.parse(state.lastReviewedAt) + this.interval());
         if (!pending && !newKnowledge && state.nextReviewAt)
             earliest = Math.max(earliest, Date.parse(state.nextReviewAt));
-        if (this.limitReached(state, usage, pending || this.canCompleteSavedReview(state)))
+        if (this.limitReached(state, usage, pending || await this.canCompleteSavedReview(state, context)))
             earliest = Math.max(earliest, usage.resetsAt);
         const due = nextAnalysisInstant(earliest, this.preferences().proactiveWindow);
         if (!this.canRun() || this.active || revision !== this.armRevision)
@@ -320,10 +332,20 @@ export class CoWorkerProactiveAgent {
             return false;
         return state.reviewAttempt.profileId === profile;
     }
-    canCompleteSavedReview(state) {
+    async canCompleteSavedReview(state, context, signal = new AbortController().signal) {
         if (!this.usesStagedReview())
             return false;
-        return hasCompletedStagedProactiveProgress(state, this.now());
+        if (!canResumeStagedProactiveAttempt(state) || !state.reviewProgress)
+            return false;
+        const profile = this.preferences().proactiveModelProfileId ?? this.preferences().modelProfileId;
+        if (!profile || !hasProactiveReviewAttempt(state, context.knowledgeRevision, profile))
+            return false;
+        if (!this.options.model.canCompleteSavedReview)
+            return false;
+        return this.options.model.canCompleteSavedReview({ reviewId: state.reviewAttempt.reviewId,
+            modelProfileId: profile, context, recentProposals: state.proposals, signal,
+            progress: { read: () => state.reviewProgress,
+                async save() { throw new Error("proactive_replay_cannot_persist"); } } });
     }
     currentPreferencesKey() {
         const value = this.preferences();

package/dist/src/runtime/passive-learning/proactive/contracts.d.ts

@@ -1,5 +1,6 @@
 import type { LearningKnowledgeContext, LearningKnowledgeEntry } from "../../long-term-memory/maturation/contracts.js";
 import type { CoWorkerReviewProgress, ReviewProgressPort } from "../review-progress.js";
+import type { ProactiveConversationStyleReference } from "./conversation-style-reference.js";
 export declare const MAX_PROACTIVE_RECEIPTS = 100;
 export declare const MAX_PROACTIVE_STATE_BYTES: number;
 export declare const MAX_PROACTIVE_FUTURE_MS: number;
@@ -12,6 +13,7 @@ export type ProactiveDecision = Readonly<{
     kind: "none" | "proposal";
     title: string | null;
     message: string | null;
+    handoffBrief: string | null;
     reason: string;
     sources: readonly ProactiveSourceReference[];
     expiresAt: string | null;
@@ -24,6 +26,7 @@ export type ProactiveProposal = Readonly<{
     knowledgeRevision: number;
     title: string;
     message: string;
+    handoffBrief?: string;
     reason: string;
     sources: readonly ProactiveSourceReference[];
     createdAt: string;
@@ -63,6 +66,7 @@ export type ProactiveReviewInput = Readonly<{
     recentProposals: readonly ProactiveProposal[];
     signal: AbortSignal;
     progress?: ReviewProgressPort;
+    styleReference?: ProactiveConversationStyleReference;
 }>;
 /** Cadence, window and budget remain separate admission gates. */
 export declare function isProactiveReviewEligible(input: Readonly<{
@@ -85,6 +89,8 @@ export declare function canDeliverProactiveProposal(input: Readonly<{
     currentSources: readonly ProactiveSourceReference[];
 }>): boolean;
 export declare function hasExactProactiveSource(entries: readonly Pick<LearningKnowledgeEntry, "kind" | "id" | "version">[], source: ProactiveSourceReference): boolean;
-export declare function validateProactiveDecision(value: unknown, entries: readonly ProactiveSourceReference[], now: number): ProactiveDecision;
+export declare function validateProactiveDecision(value: unknown, entries: readonly ProactiveSourceReference[], now: number, options?: Readonly<{
+    allowLegacyProposalWithoutBrief?: boolean;
+}>): ProactiveDecision;
 export declare function validateProactiveFutureInstant(value: unknown, now: number): void;
 export declare function isBoundedProactiveText(value: unknown, maximum: number): value is string;