@abot-ai/runtime 1.8.0 → 1.8.1

package/dist/src/model-gateway/server/chat-stream-response.js

@@ -0,0 +1,25 @@
+export async function writeChatStreamResponse(params) {
+    const { invocation, response, abortSignal } = params;
+    let hasEmittedEvent = false;
+    response.setHeader("Content-Type", "application/x-ndjson; charset=utf-8");
+    response.setHeader("Cache-Control", "no-cache");
+    try {
+        await invocation.stream({
+            emit(event) {
+                response.write(`${JSON.stringify(event)}\n`);
+                hasEmittedEvent = true;
+            },
+        });
+    }
+    catch (error) {
+        if (abortSignal.aborted)
+            return;
+        // Before the first write, the handler can still send its normal HTTP error.
+        if (!hasEmittedEvent)
+            throw error;
+        console.error(error);
+        response.end(`${JSON.stringify({ type: "error", error: "server error" })}\n`);
+        return;
+    }
+    response.end();
+}

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-rejection.d.ts

@@ -1,8 +1,8 @@
 import type { CapabilityAdapterResult } from "../../orchestration/capability-adapters/index.js";
 import type { WorkerCapabilityAdapterResult, WorkerCapabilityExecutionFreshness } from "../../orchestration/worker-capabilities/index.js";
 import type { PayloadLifecycleEmitter } from "./payload-observability.js";
-export declare const STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION: "steering_superseded_before_external_execution";
-export declare const STEERING_SUPERSEDED_SUMMARY = "steering_superseded_before_external_execution: No external execution occurred because a newer active-request update superseded this capability invocation.";
+import { STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION, STEERING_SUPERSEDED_SUMMARY } from "../../orchestration/worker-capabilities/execution/execution-freshness.js";
+export { STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION, STEERING_SUPERSEDED_SUMMARY, };
 export type PayloadLifecycleContext = Readonly<Omit<Parameters<PayloadLifecycleEmitter["emitPayloadLifecycle"]>[0], "phase" | "errorCode">>;
 export declare function rejectPayloadLifecycle(params: {
     executor: PayloadLifecycleEmitter;

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-rejection.js

@@ -1,7 +1,7 @@
 import { boundedSummary, requireCapabilityAdapterResult, } from "./result-observer.js";
 import { createRegisteredToolWorkerFailureOutcomeFingerprint } from "./failure-outcome-fingerprint.js";
-export const STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION = "steering_superseded_before_external_execution";
-export const STEERING_SUPERSEDED_SUMMARY = "steering_superseded_before_external_execution: No external execution occurred because a newer active-request update superseded this capability invocation.";
+import { STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION, STEERING_SUPERSEDED_SUMMARY, } from "../../orchestration/worker-capabilities/execution/execution-freshness.js";
+export { STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION, STEERING_SUPERSEDED_SUMMARY, };
 export function rejectPayloadLifecycle(params) {
     const failed = params.executor.emitPayloadLifecycle({
         ...params.lifecycle,

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/prepared-execution.js

@@ -1,9 +1,23 @@
 import { traceRegisteredToolWorkerCapabilityExecutionStarted, traceRegisteredToolWorkerCapabilityExecutionCompleted, traceRegisteredToolWorkerCapabilityExecutionFailed, } from "../registered-tool-worker-capability-diagnostics.js";
 import { executionFreshnessRejection } from "./payload-lifecycle.js";
+import { payloadRejection } from "./payload-rejection.js";
 import { RegisteredToolWorkerCapabilityExecutionError } from "./errors.js";
 import { observeExternalResult, attachTargetReferences, } from "./result-observer.js";
 export function createPreparedWorkerInvocation(params, input, normalPreparation, selectedTargetReferences, payloadObservability) {
     const operationId = params.projection.operation.operationId;
+    const rejectBeforeExecution = (executionId, code, message) => {
+        payloadObservability.release(executionId);
+        const rejectedExecution = payloadRejection(code, message);
+        normalPreparation.emitRejection({
+            executionId,
+            executorIdentity: input.call,
+            errorCode: code,
+        });
+        return attachTargetReferences({
+            ...rejectedExecution.result,
+            exactResult: rejectedExecution.exactResult,
+        }, selectedTargetReferences);
+    };
     return Object.freeze({
         actionFingerprint: normalPreparation.actionFingerprint,
         acceptedControls: normalPreparation.acceptedControls,
@@ -18,22 +32,14 @@ export function createPreparedWorkerInvocation(params, input, normalPreparation,
             : {}),
         applyApprovalDecision: normalPreparation.applyApprovalDecision,
         onAdmitted: payloadObservability.release,
+        rejectBeforeExecution,
         execute: async (executionId) => {
             try {
                 payloadObservability.release(executionId);
                 traceRegisteredToolWorkerCapabilityExecutionStarted(params.diagnostic, operationId, input.call, executionId, input.intent.length, Object.keys(input.controls).length);
                 const rejectedExecution = executionFreshnessRejection(input.executionFreshness);
-                if (rejectedExecution) {
-                    normalPreparation.emitRejection({
-                        executionId,
-                        executorIdentity: input.call,
-                        errorCode: rejectedExecution.sourceIssueCode,
-                    });
-                    return attachTargetReferences({
-                        ...rejectedExecution.result,
-                        exactResult: rejectedExecution.exactResult,
-                    }, selectedTargetReferences);
-                }
+                if (rejectedExecution)
+                    return rejectBeforeExecution(executionId, rejectedExecution.sourceIssueCode, rejectedExecution.result.summary);
                 const externalResult = await normalPreparation.execute(executionId, input.call, selectedTargetReferences);
                 const observed = observeExternalResult(externalResult, params.projection.operation.effect, input.call.parentCallId === null, selectedTargetReferences);
                 const observedResult = observed.result;

package/dist/src/runtime/capabilities/tool-availability.js

@@ -3,6 +3,12 @@ export function projectAvailableTools(registrations) {
         return undefined;
     const entries = registrations.flatMap((registration) => registration.contract.operations.map((operation) => Object.freeze({
         toolName: registration.toolName,
+        ...(registration.definition.pluginName !== undefined
+            ? { pluginName: registration.definition.pluginName }
+            : {}),
+        ...(registration.definition.pluginDescription !== undefined
+            ? { pluginDescription: registration.definition.pluginDescription }
+            : {}),
         operationId: operation.operationId,
         summary: operation.summary,
         catalogGroups: Object.freeze([

package/dist/src/runtime/context/capability-brief.d.ts

@@ -1,10 +1,10 @@
 import type { ChatMessage, ModelTokenEstimationConfig } from "../../model-gateway/types.js";
 import type { ToolAvailabilityEntry } from "../../capabilities/tool-types.js";
-import { type ToolAvailabilityOverviewGroup, type ToolAvailabilityOverviewLevel } from "../../plugin-sdk/tool-availability-overview.js";
+import { type ToolAvailabilityOverviewGroup } from "../../plugin-sdk/tool-availability-overview.js";
 import type { projectRequestContext } from "./request-context.js";
 export declare const CAPABILITY_BRIEF_KIND = "runtime_capability_brief_v1";
 export declare const CAPABILITY_BRIEF_MAX_TOKENS = 512;
-export type CapabilityBriefLevel = ToolAvailabilityOverviewLevel | "descriptions" | "none";
+export type CapabilityBriefLevel = "groups" | "descriptions" | "none";
 export type CapabilityBriefProjection = Readonly<{
     level: CapabilityBriefLevel;
     message?: ChatMessage;

package/dist/src/runtime/context/capability-brief.js

@@ -1,6 +1,6 @@
 import { buildToolAvailabilityOverview, } from "../../plugin-sdk/tool-availability-overview.js";
 import { resolveCapabilityBriefHeadroom } from "./capability-brief-budget.js";
-import { buildCapabilityDescriptions } from "./capability-descriptions.js";
+import { buildPluginDiscoveryCatalogText } from "./capability-descriptions.js";
 import { estimateMessageTokens } from "./token-estimator.js";
 export const CAPABILITY_BRIEF_KIND = "runtime_capability_brief_v1";
 export const CAPABILITY_BRIEF_MAX_TOKENS = 512;
@@ -22,12 +22,12 @@ export function projectCapabilityBriefAtHeadroom(params) {
         return omittedBrief(compactBudgetTokens, "empty_catalog");
     }
     const levels = hasCompleteCapabilityBriefEntries(params.entries, params.groups)
-        ? ["descriptions", "detailed", "titles", "groups"]
+        ? ["descriptions", "groups"]
         : ["groups"];
     for (const level of levels) {
         const budgetTokens = level === "descriptions" ? headroom : compactBudgetTokens;
         const body = level === "descriptions"
-            ? buildCapabilityDescriptions(params.entries ?? [])
+            ? buildPluginDiscoveryCatalogText(params.groups.map(({ groupId }) => groupId), params.entries)
             : buildToolAvailabilityOverview(params.entries ?? [], params.groups, level);
         const message = Object.freeze({
             role: "system",

package/dist/src/runtime/context/capability-descriptions.d.ts

@@ -1,3 +1,4 @@
 import type { ToolAvailabilityEntry } from "../../capabilities/tool-types.js";
-/** Complete request-registry facts; neither a selected subset nor tool schemas. */
-export declare function buildCapabilityDescriptions(entries: readonly ToolAvailabilityEntry[]): string;
+export declare const PLUGIN_DISCOVERY_CATALOG_HEADER = "Tool groups:";
+/** Passive discovery: selectable groups first, with plugin descriptions once. */
+export declare function buildPluginDiscoveryCatalogText(catalogGroupIds: readonly string[], entries?: readonly ToolAvailabilityEntry[]): string;

package/dist/src/runtime/context/capability-descriptions.js

@@ -1,23 +1,60 @@
-/** Complete request-registry facts; neither a selected subset nor tool schemas. */
-export function buildCapabilityDescriptions(entries) {
-    const ordered = [...entries].sort(compareCapabilityDescriptions);
-    return JSON.stringify(ordered.map(({ toolName, operationId, summary, catalogGroups }) => ({
-        toolName,
-        operationId,
-        summary,
-        catalogGroups: [...new Set(catalogGroups)].sort(compareAscii),
-    })));
+export const PLUGIN_DISCOVERY_CATALOG_HEADER = "Tool groups:";
+/** Passive discovery: selectable groups first, with plugin descriptions once. */
+export function buildPluginDiscoveryCatalogText(catalogGroupIds, entries = []) {
+    const offeredGroups = new Set(catalogGroupIds);
+    const toolsByGroup = new Map();
+    const descriptions = new Map();
+    for (const entry of entries) {
+        const groupIds = entry.catalogGroups.filter((id) => offeredGroups.has(id));
+        if (groupIds.length === 0)
+            continue;
+        // The empty owner denotes a native tool, never a fabricated plugin.
+        const owner = entry.pluginName ?? "";
+        for (const id of groupIds) {
+            const owners = toolsByGroup.get(id) ?? new Map();
+            const toolNames = owners.get(owner) ?? new Set();
+            toolNames.add(entry.toolName);
+            owners.set(owner, toolNames);
+            toolsByGroup.set(id, owners);
+        }
+        if (!entry.pluginName)
+            continue;
+        const description = descriptions.get(entry.pluginName)
+            || formatPluginDiscoveryDescription(entry.pluginDescription);
+        if (description)
+            descriptions.set(entry.pluginName, description);
+    }
+    const hasOfferedToolBindings = toolsByGroup.size > 0;
+    if (!hasOfferedToolBindings) {
+        return catalogGroupIds.length > 0
+            ? `${PLUGIN_DISCOVERY_CATALOG_HEADER} ${catalogGroupIds.join(", ")}`
+            : PLUGIN_DISCOVERY_CATALOG_HEADER;
+    }
+    const groupEntries = [...offeredGroups].sort().map((id) => {
+        const owners = toolsByGroup.get(id);
+        if (!owners)
+            return id;
+        const bindings = [...owners.keys()].sort().map((owner) => {
+            const names = [...owners.get(owner)].sort().map(formatPluginDiscoveryToolName).join(", ");
+            return owner ? `${owner} [${names}]` : names;
+        });
+        return `${id}: ${bindings.join(", ")}`;
+    });
+    const catalog = `${PLUGIN_DISCOVERY_CATALOG_HEADER} ${groupEntries.join(" | ")}`;
+    const pluginDescriptions = [...descriptions.keys()].sort().map((name) => `${name}: ${descriptions.get(name)}`);
+    return pluginDescriptions.length > 0
+        ? `${catalog}\nPlugin descriptions: ${pluginDescriptions.join(" | ")}`
+        : catalog;
 }
-function compareCapabilityDescriptions(left, right) {
-    const byOperation = compareAscii(left.operationId, right.operationId);
-    if (byOperation !== 0)
-        return byOperation;
-    return compareAscii(left.toolName, right.toolName);
+function formatPluginDiscoveryToolName(name) {
+    return name.replace(/[%\\[\],;:|\s\u0000-\u001f\u007f]/gu, (character) => encodeURIComponent(character));
 }
-function compareAscii(left, right) {
-    if (left < right)
-        return -1;
-    if (left > right)
-        return 1;
-    return 0;
+function formatPluginDiscoveryDescription(description) {
+    if (description === undefined)
+        return undefined;
+    const normalized = description.replaceAll("|", "/").replace(/\s+/gu, " ").trim();
+    const characters = Array.from(normalized);
+    if (characters.length <= 160)
+        return normalized;
+    return `${characters.slice(0, 160).join("")}....`;
 }

package/dist/src/runtime/long-term-memory/conversation-authoring/context.d.ts

@@ -1,7 +1,7 @@
 import type { ChatMessage } from "../../../model-gateway/types.js";
 import type { RequestExecutionScope } from "../../request/execution-scope.js";
 import type { RequestSteeringSnapshot } from "../../request/request-steering.js";
-import type { LearningKnowledgeEntry } from "../maturation/contracts.js";
+import type { LearningKnowledgeEntry, LearningKnowledgeContext } from "../maturation/contracts.js";
 import type { ConversationMemoryEvidence } from "../maturation/evidence-contracts.js";
 export type ConversationMemoryAuthoringContext = Readonly<{
     evidence: ConversationMemoryEvidence;
@@ -12,3 +12,8 @@ export type ConversationMemoryAuthoringContext = Readonly<{
 export declare function canAuthorConversationMemory(request: Pick<RequestExecutionScope, "longTermMemory">, context: ConversationMemoryAuthoringContext | undefined): boolean;
 /** Request-local authoring reference; never part of ordinary recall or routing. */
 export declare function prepareConversationMemoryAuthoring(request: Pick<RequestExecutionScope, "longTermMemory" | "requestId" | "sessionId" | "prompt" | "abortSignal">, steering: RequestSteeringSnapshot): Promise<ConversationMemoryAuthoringContext | undefined>;
+export declare function prepareConversationMemoryKnowledge(request: Pick<RequestExecutionScope, "longTermMemory" | "requestId" | "sessionId" | "prompt" | "abortSignal">, steering: RequestSteeringSnapshot): Promise<LearningKnowledgeContext | undefined>;
+/** Shared deterministic binding for decision and response authoring. No retrieval. */
+export declare function buildConversationMemoryAuthoringContext(request: Pick<RequestExecutionScope, "requestId" | "sessionId" | "prompt">, steering: RequestSteeringSnapshot, context: Pick<LearningKnowledgeContext, "entries" | "omitted" | "referenceTime">): ConversationMemoryAuthoringContext;
+/** The same contract projection must precede ledger cloning and durable approval capture. */
+export declare function projectConversationMemoryKnowledge(context: LearningKnowledgeContext): LearningKnowledgeContext;

package/dist/src/runtime/long-term-memory/conversation-authoring/context.js

@@ -10,6 +10,10 @@ export function canAuthorConversationMemory(request, context) {
 }
 /** Request-local authoring reference; never part of ordinary recall or routing. */
 export async function prepareConversationMemoryAuthoring(request, steering) {
+    const context = await prepareConversationMemoryKnowledge(request, steering);
+    return context ? buildConversationMemoryAuthoringContext(request, steering, context) : undefined;
+}
+export async function prepareConversationMemoryKnowledge(request, steering) {
     const learning = request.longTermMemory?.learning;
     if (!request.longTermMemory?.enabled || !learning)
         return undefined;
@@ -19,31 +23,7 @@ export async function prepareConversationMemoryAuthoring(request, steering) {
             abortSignal: request.abortSignal,
             debugRequestId: request.requestId,
         });
-        const evidence = Object.freeze({
-            sourceSessionId: request.sessionId,
-            sourceRequestId: request.requestId,
-            observedAt: context.referenceTime,
-            evidenceDigest: createHash("sha256").update(JSON.stringify([
-                request.prompt, ...steering.updates.map(({ text }) => text),
-            ])).digest("hex"),
-        });
-        const entries = structuredClone(context.entries);
-        const targets = new Map(entries.map((entry, index) => [`k${index + 1}`, Object.freeze(entry)]));
-        return Object.freeze({
-            evidence, targets,
-            userMessages: Object.freeze([request.prompt, ...steering.updates.map(({ text }) => text)]),
-            message: Object.freeze({ role: "system", content: JSON.stringify({
-                    kind: "conversation_memory_authoring_reference_v1",
-                    authority: "passive_memory_reference",
-                    purpose: "assess_lasting_user_knowledge_and_resolve_optional_update_targets",
-                    applicability: "memoryCandidates_only",
-                    presenceEffect: "not_user_intent_fresh_evidence_or_action_authority",
-                    targetPolicy: "null_creates_candidate_only_use_supplied_mutable_refs_for_updates",
-                    omitted: context.omitted,
-                    omissionMeaning: "unlisted_knowledge_is_unknown_and_cannot_be_targeted",
-                    entries: [...targets].map(([ref, { id: _id, version: _version, ...entry }]) => ({ ref, ...entry })),
-                }) }),
-        });
+        return context;
     }
     catch (error) {
         request.abortSignal.throwIfAborted();
@@ -53,3 +33,49 @@ export async function prepareConversationMemoryAuthoring(request, steering) {
         return undefined;
     }
 }
+/** Shared deterministic binding for decision and response authoring. No retrieval. */
+export function buildConversationMemoryAuthoringContext(request, steering, context) {
+    const evidence = Object.freeze({
+        sourceSessionId: request.sessionId,
+        sourceRequestId: request.requestId,
+        observedAt: context.referenceTime,
+        evidenceDigest: createHash("sha256").update(JSON.stringify([
+            request.prompt, ...steering.updates.map(({ text }) => text),
+        ])).digest("hex"),
+    });
+    // Project only contract fields, including when entries come from a saved checkpoint.
+    const entries = context.entries.map(projectConversationMemoryKnowledgeEntry);
+    const targets = new Map(entries.map((entry, index) => [`k${index + 1}`, Object.freeze(entry)]));
+    return Object.freeze({
+        evidence, targets,
+        userMessages: Object.freeze([request.prompt, ...steering.updates.map(({ text }) => text)]),
+        message: Object.freeze({ role: "system", content: JSON.stringify({
+                kind: "conversation_memory_authoring_reference_v1",
+                authority: "passive_memory_reference",
+                purpose: "assess_lasting_user_knowledge_and_resolve_optional_update_targets",
+                applicability: "memoryCandidates_only",
+                presenceEffect: "not_user_intent_fresh_evidence_or_action_authority",
+                targetPolicy: "null_creates_candidate_only_use_supplied_mutable_refs_for_updates",
+                omitted: context.omitted,
+                omissionMeaning: "unlisted_knowledge_is_unknown_and_cannot_be_targeted",
+                entries: [...targets].map(([ref, { id: _id, version: _version, ...entry }]) => ({ ref, ...entry })),
+            }) }),
+    });
+}
+/** The same contract projection must precede ledger cloning and durable approval capture. */
+export function projectConversationMemoryKnowledge(context) {
+    return {
+        kind: context.kind, authority: context.authority, presenceEffect: context.presenceEffect,
+        repositoryRevision: context.repositoryRevision, knowledgeRevision: context.knowledgeRevision,
+        referenceTime: context.referenceTime, omitted: context.omitted,
+        entries: context.entries.map(projectConversationMemoryKnowledgeEntry),
+    };
+}
+function projectConversationMemoryKnowledgeEntry(entry) {
+    return {
+        kind: entry.kind, id: entry.id, version: entry.version,
+        content: entry.content, tags: [...entry.tags], mutable: entry.mutable,
+        score: entry.score, reason: entry.reason, certainty: entry.certainty,
+        lastReinforcedAt: entry.lastReinforcedAt, reconsiderAt: entry.reconsiderAt,
+    };
+}

package/dist/src/runtime/long-term-memory/initial-context.d.ts

@@ -0,0 +1,17 @@
+import type { RequestExecutionScope } from "../request/execution-scope.js";
+import type { ChatMessage } from "../../model-gateway/types.js";
+import { type RequestSteeringSnapshot } from "../request/request-steering.js";
+import type { RoleInitialMemory } from "../orchestration/role-calls/memory-recall-contract.js";
+/** Prepared once as part of the existing request ledger initialization. */
+export declare function prepareInitialMemory(request: RequestExecutionScope, restored?: RoleInitialMemory): Promise<RoleInitialMemory | undefined>;
+export declare function projectExecutionAgentMemory(request: RequestExecutionScope, initial: RoleInitialMemory | undefined, steering: RequestSteeringSnapshot): Readonly<{
+    memoryMessage: ChatMessage | undefined;
+    authoringContext: Readonly<{
+        evidence: import("./maturation/evidence-contracts.js").ConversationMemoryEvidence;
+        targets: ReadonlyMap<string, import("./maturation/contracts.js").LearningKnowledgeEntry>;
+        userMessages: readonly string[];
+        message: ChatMessage;
+    }> | undefined;
+    authoringEnabled: boolean;
+}>;
+export type ExecutionMemoryProjection = ReturnType<typeof projectExecutionAgentMemory>;

package/dist/src/runtime/long-term-memory/initial-context.js

@@ -0,0 +1,57 @@
+import { resolveRequestSteeringInbox } from "../request/request-steering.js";
+import { retrieveResponseLongTermMemory } from "./response-context.js";
+import { prepareConversationMemoryKnowledge, buildConversationMemoryAuthoringContext, canAuthorConversationMemory, projectConversationMemoryKnowledge, } from "./conversation-authoring/context.js";
+/** Prepared once as part of the existing request ledger initialization. */
+export async function prepareInitialMemory(request, restored) {
+    if (!usesInitialMemory(request))
+        return undefined;
+    if (restored !== undefined)
+        return restored;
+    request.abortSignal.throwIfAborted();
+    const steering = resolveRequestSteeringInbox(request.requestSteering).snapshot();
+    const message = await retrieveResponseLongTermMemory(request, steering);
+    request.abortSignal.throwIfAborted();
+    // EA prepares authoring targets at startup; Supervisor keeps its terminal step.
+    const knowledge = usesInitialExecutionMemory(request)
+        ? await prepareConversationMemoryKnowledge(request, steering)
+        : undefined;
+    request.abortSignal.throwIfAborted();
+    return Object.freeze({
+        ...(message ? { message: projectPersistentMemoryMessage(message) } : {}),
+        ...(knowledge ? { knowledge: projectConversationMemoryKnowledge(knowledge) } : {}),
+    });
+}
+function projectPersistentMemoryMessage(message) {
+    if (!message.attachments)
+        return message;
+    return { ...message, attachments: message.attachments.filter(isPersistentMemoryAttachment) };
+}
+function isPersistentMemoryAttachment(attachment) {
+    return attachment.toolEvidence === undefined;
+}
+function usesInitialMemory(request) {
+    if (!request.longTermMemory?.enabled)
+        return false;
+    if (request.executionPolicy.authority.id === "execution-agent-v1")
+        return true;
+    return request.executionPolicy.authority.id === "supervisor-worker-v1";
+}
+export function projectExecutionAgentMemory(request, initial, steering) {
+    if (!usesInitialExecutionMemory(request))
+        return { memoryMessage: undefined, authoringContext: undefined, authoringEnabled: false };
+    const authoringContext = initial?.knowledge
+        ? buildConversationMemoryAuthoringContext(request, steering, {
+            ...initial.knowledge, referenceTime: new Date().toISOString(),
+        })
+        : undefined;
+    return Object.freeze({
+        memoryMessage: initial?.message,
+        authoringContext,
+        authoringEnabled: canAuthorConversationMemory(request, authoringContext),
+    });
+}
+function usesInitialExecutionMemory(request) {
+    if (!request.longTermMemory?.enabled)
+        return false;
+    return request.executionPolicy.authority.id === "execution-agent-v1";
+}

package/dist/src/runtime/long-term-memory/projection.js

@@ -32,7 +32,7 @@ function serializeProjection(records) {
     return JSON.stringify({
         kind: LONG_TERM_MEMORY_MESSAGE_KIND,
         authority: "passive_reference",
-        purpose: "support_personalized_terminal_response_authoring",
+        purpose: "support_root_decisions_and_response_authoring",
         memories: records.map((record) => ({
             content: record.content,
             tags: record.tags,

package/dist/src/runtime/orchestration/role-calls/candidate-validation.js

@@ -2,7 +2,7 @@ import { isRuntimeDelegateRoleId, RUNTIME_ROOT_ROLE_ID, RUNTIME_ROLE_IDS, } from
 import { createRoleCapabilitySelectionFingerprint, normalizeRoleCapabilitySelectionProjection, } from "./capability-selection-reconsideration.js";
 import { isRoleCapabilitySelectionSupervisionState, } from "./capability-selection-supervision.js";
 import { isValidRoleCapabilitySelectionSupervision } from "./capability-selection-supervision-validation.js";
-import { validateRoleMemoryRecalls } from "./memory-recall-state-validation.js";
+import { hasInitialMemoryContext, validateRoleMemoryRecalls } from "./memory-recall-state-validation.js";
 import { isValidAdoptedModelWorkPlan } from "./work-plan-validation.js";
 import { isRoleOperationFingerprint, isRoleOperationOutcomeFingerprintForOutcome, isSameRoleOperationIdentity, replayRoleOperationSupervisionEvidence, } from "./operation-supervision.js";
 import { isIssuedRoleOperationSupervisionInterventionForRequest } from "./operation-supervision-issuance.js";
@@ -48,6 +48,7 @@ export function validateRoleCallState(state, policy) {
         !Array.isArray(state?.plans) ||
         !Array.isArray(state?.capabilityExecutions) ||
         !Array.isArray(state?.memoryRecalls) ||
+        !hasInitialMemoryContext(state?.initialMemory, policy.authority.id) ||
         !isRoleOperationSupervisionState(state?.operationSupervision) ||
         !isRoleCapabilitySelectionSupervisionState(state?.capabilitySelectionSupervision) ||
         !Number.isInteger(state?.callSequence) ||

package/dist/src/runtime/orchestration/role-calls/checkpoint-state.d.ts

@@ -1,4 +1,4 @@
 import type { RoleCallLedgerCheckpoint } from "./checkpoint-contract.js";
 import type { RoleCallPolicy, RoleCallState } from "./contracts.js";
 /** Hydrate only an admitted, parked capability; no model or reducer command replay. */
-export declare function restoreCheckpointState(checkpoint: RoleCallLedgerCheckpoint, requestId: string, policy: RoleCallPolicy): RoleCallState;
+export declare function restoreCheckpointState(checkpoint: RoleCallLedgerCheckpoint, requestId: string, policy: RoleCallPolicy, initialMemory?: RoleCallState["initialMemory"]): RoleCallState;

package/dist/src/runtime/orchestration/role-calls/checkpoint-state.js

@@ -4,14 +4,17 @@ import { validateRoleCallCandidate } from "./reducer.js";
 import { issueInitialRoleCapabilitySelectionSupervisionState } from "./capability-selection-supervision-issuance.js";
 import { restoreRoleOperationSupervisionIssuance } from "./operation-supervision-issuance.js";
 /** Hydrate only an admitted, parked capability; no model or reducer command replay. */
-export function restoreCheckpointState(checkpoint, requestId, policy) {
+export function restoreCheckpointState(checkpoint, requestId, policy, initialMemory) {
     if (!isCheckpointEnvelope(checkpoint))
         throw new Error("role_call_checkpoint_invalid");
     if (!hasCheckpointRequestIdentity(checkpoint, requestId))
         throw new Error("role_call_checkpoint_request_mismatch");
     if (!hasCheckpointPolicy(checkpoint, policy))
         throw new Error("role_call_checkpoint_policy_mismatch");
-    const state = seal(structuredClone(checkpoint.state));
+    const state = seal(structuredClone({ ...checkpoint.state,
+        ...(checkpoint.state.initialMemory === undefined && initialMemory !== undefined
+            ? { initialMemory } : {}),
+    }));
     if (!isParkedCapabilityState(state))
         throw new Error("role_call_checkpoint_not_parked");
     if (!issueInitialRoleCapabilitySelectionSupervisionState(state))

package/dist/src/runtime/orchestration/role-calls/contracts.d.ts

@@ -5,7 +5,7 @@ import type { RoleOperationFingerprint, RoleOperationOutcomeFingerprint, RoleOpe
 import type { RoleCapabilitySelectionSupervisionStage, RoleCapabilitySelectionSupervisionState, RoleCapabilitySelectionSupervisionTrigger } from "./capability-selection-supervision.js";
 import type { RoleCapabilitySelectionReconsiderationCause } from "./reconsideration-cause.js";
 import type { RoleCallResultReceipt } from "./result-receipt.js";
-import type { RoleMemoryRecall, RoleMemoryRecallCommand, RoleMemoryRecallCommitEffect, RoleMemoryRecallTransactions } from "./memory-recall-contract.js";
+import type { RoleInitialMemory, RoleMemoryRecall, RoleMemoryRecallCommand, RoleMemoryRecallCommitEffect, RoleMemoryRecallTransactions } from "./memory-recall-contract.js";
 import type { AdoptedModelWorkPlan, UpdateModelWorkPlanCommand, ModelWorkPlanCommitEffect, ModelWorkPlanTransactions } from "./work-plan-contracts.js";
 export declare const ROLE_CALL_LEDGER_CONTRACT_VERSION = 18;
 export declare const ROLE_CALL_LEDGER_HEAD_KIND: "runtime_role_call_ledger_v18";
@@ -191,6 +191,7 @@ export type RoleCallState = Readonly<{
     plans: readonly RoleCallPlanState[];
     capabilityExecutions: readonly RoleCapabilityExecution[];
     memoryRecalls: readonly RoleMemoryRecall[];
+    initialMemory?: RoleInitialMemory;
     operationSupervision: RoleOperationSupervisionState;
     capabilitySelectionSupervision: RoleCapabilitySelectionSupervisionState;
     rootResponse: string | null;

package/dist/src/runtime/orchestration/role-calls/ledger.d.ts

@@ -1,9 +1,10 @@
 import type { RoleCallLedgerCheckpoint } from "./checkpoint-contract.js";
-import { type RoleCallLedger, type RoleCallLedgerHead, type RoleCallPolicyInput } from "./contracts.js";
+import { type RoleCallLedger, type RoleCallLedgerHead, type RoleCallPolicyInput, type RoleCallState } from "./contracts.js";
 export declare function createRoleCallLedger(params: {
     requestId: string;
     policy: RoleCallPolicyInput;
     checkpoint?: RoleCallLedgerCheckpoint;
+    initialMemory?: RoleCallState["initialMemory"];
 }): RoleCallLedger;
 /** Confirms exact current-head ownership without trusting structural ledgers. */
 export declare function isCurrentRoleCallLedgerHead(ledger: RoleCallLedger, head: RoleCallLedgerHead): boolean;

package/dist/src/runtime/orchestration/role-calls/ledger.js

@@ -15,8 +15,8 @@ const issuedRoleCallLedgerHeads = new WeakMap();
 export function createRoleCallLedger(params) {
     const policy = sealRoleCallPolicy(params.policy);
     const initialState = params.checkpoint
-        ? restoreCheckpointState(params.checkpoint, params.requestId, policy)
-        : createInitialRoleCallState(params.requestId);
+        ? restoreCheckpointState(params.checkpoint, params.requestId, policy, params.initialMemory)
+        : createInitialRoleCallState(params.requestId, params.initialMemory);
     const capabilitySelectionSupervisionIssuanceAuthority = resolveRoleCapabilitySelectionSupervisionIssuanceAuthority(initialState);
     if (!capabilitySelectionSupervisionIssuanceAuthority) {
         throw new Error("role_call_capability_selection_supervision_issuance_authority_missing");

package/dist/src/runtime/orchestration/role-calls/memory-recall-contract.d.ts

@@ -1,3 +1,5 @@
+import type { ChatMessage } from "../../../model-gateway/types.js";
+import type { LearningKnowledgeContext } from "../../long-term-memory/maturation/contracts.js";
 import type { LongTermMemoryRecord } from "../../long-term-memory/contracts.js";
 import type { RoleCallTransactionInput, RoleCallTransactionResult } from "./contracts.js";
 export declare const ROLE_MEMORY_RECALL_QUERY_MAX_LENGTH = 1024;
@@ -49,3 +51,8 @@ export type RoleMemoryRecallTransactions = Readonly<{
     beginMemoryRecall(input: RoleCallTransactionInput<BeginRoleMemoryRecallCommand>): Promise<RoleCallTransactionResult<"memory_recall_begun", "memory_recall_transition_invalid">>;
     settleMemoryRecall(input: RoleCallTransactionInput<SettleRoleMemoryRecallCommand>): Promise<RoleCallTransactionResult<"memory_recall_settled", "memory_recall_transition_invalid">>;
 }>;
+/** Initial automatic reference; never a model recall or an activation. */
+export type RoleInitialMemory = Readonly<{
+    message?: ChatMessage;
+    knowledge?: LearningKnowledgeContext;
+}>;

package/dist/src/runtime/orchestration/role-calls/memory-recall-state-validation.d.ts

@@ -1,3 +1,5 @@
 import type { RoleCallState, RoleCallValidationIssue } from "./contracts.js";
 export declare function validateRoleMemoryRecalls(state: RoleCallState): RoleCallValidationIssue[];
 export declare function hasSettledMemoryRecallActivationRange(state: RoleCallState, callId: string, fromActivation: number, toActivation: number): boolean;
+/** The existing checkpoint carries this passive startup field, never a model action. */
+export declare function hasInitialMemoryContext(value: unknown, policyId: string): boolean;