@abot-ai/runtime 1.8.0 → 1.8.1

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

@@ -1,3 +1,4 @@
+import { isAssistantToolCallMessage, isStrictTextChatMessage, isToolResultMessage, } from "../../../model-gateway/message-contract.js";
 import { RUNTIME_ROOT_ROLE_ID } from "../roles.js";
 import { hasMemoryRecallIdentity, isBoundedMemoryRecallQuery, normalizeRoleMemoryRecallResult, } from "./memory-recall-decoder.js";
 import { exactKeys, isRecord } from "../../validation/strict-record.js";
@@ -119,3 +120,90 @@ function hasUnboundMemoryWait(state, pendingCount) {
         return true;
     return waitingCalls.some((call) => call.callId !== state.rootCallId);
 }
+/** The existing checkpoint carries this passive startup field, never a model action. */
+export function hasInitialMemoryContext(value, policyId) {
+    if (value === undefined)
+        return true;
+    if (policyId !== "execution-agent-v1" && policyId !== "supervisor-worker-v1")
+        return false;
+    if (!isRecord(value) || !exactKeys(value, [], ["message", "knowledge"]))
+        return false;
+    if (value.message !== undefined && !isInitialMemoryMessage(value.message))
+        return false;
+    if (value.knowledge === undefined)
+        return true;
+    return isInitialMemoryKnowledge(value.knowledge);
+}
+function isInitialMemoryMessage(value) {
+    if (isStrictTextChatMessage(value))
+        return true;
+    if (isAssistantToolCallMessage(value))
+        return true;
+    return isToolResultMessage(value);
+}
+function isInitialMemoryKnowledge(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.kind !== "learning_knowledge_reference_v1")
+        return false;
+    if (value.authority !== "passive_reference")
+        return false;
+    if (value.presenceEffect !== "does_not_authorize_actions_or_add_user_intent")
+        return false;
+    if (!isMemoryRevision(value.repositoryRevision))
+        return false;
+    if (!isMemoryRevision(value.knowledgeRevision))
+        return false;
+    if (!isMemoryRevision(value.omitted))
+        return false;
+    if (typeof value.referenceTime !== "string" || !Number.isFinite(Date.parse(value.referenceTime)))
+        return false;
+    if (!Array.isArray(value.entries) || value.entries.length > 12)
+        return false;
+    if (!value.entries.every(isInitialMemoryKnowledgeEntry))
+        return false;
+    const identities = value.entries.map(entry => JSON.stringify([entry.kind, entry.id]));
+    return new Set(identities).size === identities.length;
+}
+function isMemoryRevision(value) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value))
+        return false;
+    return value >= 0;
+}
+function isInitialMemoryKnowledgeEntry(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.kind !== "candidate" && value.kind !== "memory")
+        return false;
+    if (typeof value.id !== "string" || value.id.length === 0)
+        return false;
+    if (typeof value.version !== "string" || value.version.length === 0)
+        return false;
+    if (typeof value.content !== "string")
+        return false;
+    if (!Array.isArray(value.tags) || !value.tags.every(tag => typeof tag === "string"))
+        return false;
+    if (typeof value.mutable !== "boolean")
+        return false;
+    if (value.score !== null && !isMemoryScore(value.score))
+        return false;
+    if (value.reason !== null && typeof value.reason !== "string")
+        return false;
+    if (!["observed", "inferred", "unspecified"].includes(value.certainty))
+        return false;
+    if (!isOptionalMemoryTime(value.lastReinforcedAt))
+        return false;
+    return isOptionalMemoryTime(value.reconsiderAt);
+}
+function isMemoryScore(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return false;
+    return value >= 0 && value <= 100;
+}
+function isOptionalMemoryTime(value) {
+    if (value === null)
+        return true;
+    if (typeof value !== "string")
+        return false;
+    return Number.isFinite(Date.parse(value));
+}

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

@@ -1,6 +1,6 @@
 import { type RoleCallPolicy, type RoleCallPolicyInput, type RoleCallState, type RoleCallTransitionResult, type RoleCallValidationIssue } from "./contracts.js";
 export { hasRoleCallCapabilityAuthority } from "./candidate-validation.js";
-export declare function createInitialRoleCallState(requestId: string): RoleCallState;
+export declare function createInitialRoleCallState(requestId: string, initialMemory?: RoleCallState["initialMemory"]): RoleCallState;
 export declare function applyRoleCallCommand(state: RoleCallState, commandInput: unknown, policy: RoleCallPolicy, admittedHeadRevision?: number): RoleCallTransitionResult;
 export declare function validateRoleCallCandidate(params: {
     state: RoleCallState;

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

@@ -8,7 +8,7 @@ import { issueInitialRoleCapabilitySelectionSupervisionState } from "./capabilit
 import { createInitialRoleOperationSupervisionState } from "./operation-supervision.js";
 import { reject, seal } from "./reducer-primitives.js";
 export { hasRoleCallCapabilityAuthority } from "./candidate-validation.js";
-export function createInitialRoleCallState(requestId) {
+export function createInitialRoleCallState(requestId, initialMemory) {
     const state = seal({
         contractVersion: ROLE_CALL_LEDGER_CONTRACT_VERSION,
         requestId,
@@ -23,6 +23,7 @@ export function createInitialRoleCallState(requestId) {
         plans: [],
         capabilityExecutions: [],
         memoryRecalls: [],
+        ...(initialMemory !== undefined ? { initialMemory } : {}),
         operationSupervision: createInitialRoleOperationSupervisionState(),
         capabilitySelectionSupervision: createInitialRoleCapabilitySelectionSupervisionState(),
         rootResponse: null,

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 { TOOL_NORMAL_INVOCATION_STRING_MAX_LENGTH as WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH, } from "../../../capabilities/normal-invocation/contracts.js";
+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;
@@ -165,6 +165,8 @@ export type WorkerCapabilityPreparedExecution = Readonly<{
     onAdmitted?(executionId: string): void;
     approvalRequest?: ToolApprovalRequest;
     applyApprovalDecision?(decision: BoundApprovalDecision): void;
+    /** Project a fenced rejection with adapter-owned lifecycle and evidence; never execute. */
+    rejectBeforeExecution?(executionId: string, code: string, message: string): WorkerCapabilityAdapterResult;
     execute(executionId: string): Promise<WorkerCapabilityAdapterResult>;
 }>;
 export type WorkerCapabilityAdapterPreparationInput<TContext> = Readonly<Omit<WorkerCapabilityAdapterExecutionInput<TContext>, "executionId"> & {

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 { TOOL_NORMAL_INVOCATION_STRING_MAX_LENGTH as WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH, } from "../../../capabilities/normal-invocation/contracts.js";
+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/approval-group.js

@@ -1,3 +1,4 @@
+import { fenceRestoredApprovalExecution } from "./execution-freshness.js";
 import { restorePreparationRejection } from "./preparation-rejection.js";
 import { isDeepStrictEqual } from "node:util";
 import { settleAdmittedPreparedGroup } from "./settle-prepared.js";
@@ -132,7 +133,10 @@ export async function restoreCapabilityApprovalGroup(params) {
                 ledger: params.ledger,
                 expectedHead: head,
                 call,
-                invocations,
+                invocations: invocations.map((invocation) => ({
+                    ...invocation,
+                    prepared: fenceRestoredApprovalExecution(invocation.prepared, params.executionFreshness),
+                })),
                 executionIds: group.entries.map((entry) => entry.executionId),
                 batch: group.batch,
                 diagnostic,

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

@@ -0,0 +1,5 @@
+import type { WorkerCapabilityExecutionFreshness, WorkerCapabilityPreparedExecution } from "../contracts.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.";
+/** Preserve the admitted identity and decision binding; only fence its dispatch. */
+export declare function fenceRestoredApprovalExecution(prepared: WorkerCapabilityPreparedExecution, freshness: WorkerCapabilityExecutionFreshness | undefined): WorkerCapabilityPreparedExecution;

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

@@ -0,0 +1,31 @@
+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.";
+/** Preserve the admitted identity and decision binding; only fence its dispatch. */
+export function fenceRestoredApprovalExecution(prepared, freshness) {
+    if (!freshness)
+        return prepared;
+    return Object.freeze({
+        ...prepared,
+        async execute(executionId) {
+            if (freshness.isCurrent())
+                return prepared.execute(executionId);
+            if (prepared.rejectBeforeExecution)
+                return prepared.rejectBeforeExecution(executionId, STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION, STEERING_SUPERSEDED_SUMMARY);
+            return Object.freeze({
+                outcome: "failed",
+                observedEffect: "none",
+                summary: STEERING_SUPERSEDED_SUMMARY,
+                // This is request control, not evidence of a repeatable tool failure.
+                failureOutcomeFingerprint: null,
+                exactResult: Object.freeze({
+                    kind: "runtime_capability_rejection_v1",
+                    authority: "runtime",
+                    status: "rejected",
+                    stage: "before_external_execution",
+                    code: STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION,
+                    message: STEERING_SUPERSEDED_SUMMARY,
+                }),
+            });
+        },
+    });
+}

package/dist/src/runtime/plugins/manifest-projection.js

@@ -41,6 +41,9 @@ export function projectManifestRuntimeContract(discovered, selectedCapabilityIds
             definition: {
                 name: capabilityId,
                 pluginName: manifest.name,
+                ...(manifest.description !== undefined
+                    ? { pluginDescription: manifest.description }
+                    : {}),
                 ...(capability.requiredPermissionMode
                     ? { requiredPermissionMode: capability.requiredPermissionMode }
                     : {}),

package/dist/src/runtime/request/capability-execution-freshness.js

@@ -22,7 +22,12 @@ export function restoreApprovalExecutionFreshness(token, requestSteering) {
     });
     if (!isDeepStrictEqual(current.token, token))
         throw new Error("request_approval_steering_mismatch");
-    if (!current.isCurrent())
+    // A newer accepted prefix invalidates execution, not the saved approval.
+    // A closed inbox has no current version and must remain terminal.
+    if (!hasLiveSteeringInbox(inbox))
         throw new Error("request_approval_steering_superseded");
     return Object.freeze({ token, isCurrent: current.isCurrent });
 }
+function hasLiveSteeringInbox(inbox) {
+    return inbox.isCurrent(inbox.snapshot().version);
+}

package/dist/src/runtime/request/execution-agent-root-execution.js

@@ -37,6 +37,8 @@ export const EXECUTION_AGENT_ROOT_CONTRACT = Object.freeze({
         });
     },
     async authorResponse(request, options) {
+        if (options.directResponse !== undefined)
+            return options.directResponse;
         const requestSteering = resolveRequestSteeringInbox(request.requestSteering);
         return runExecutionAgentAuthoredResponse(request, {
             head: options.head,
@@ -115,7 +117,15 @@ function projectKernelDecision(decision, steeringVersion) {
                 ...presentation,
             });
         case "respond":
-            return Object.freeze({ action: "respond", ...presentation });
+            return Object.freeze({
+                action: "respond", ...presentation,
+                ...(decision.response !== undefined ? {
+                    directResponse: Object.freeze({
+                        finalResponse: decision.response,
+                        memoryCandidates: decision.memoryCandidates ?? Object.freeze([]),
+                    }),
+                } : {}),
+            });
         case "blocked":
             return Object.freeze({
                 action: "blocked",

package/dist/src/runtime/request/root-contract.d.ts

@@ -19,6 +19,7 @@ export type RootContractCallIdentity = Readonly<{
 type RootContractAction = MemoryRecallDecision | Readonly<{
     action: "respond";
     responseRecommendation?: string;
+    directResponse?: RootAuthoredResponse;
     acknowledgement?: string;
     title?: string;
 }> | Readonly<{
@@ -99,6 +100,7 @@ export type RootContractAdapter<TRequest> = Readonly<{
         callFrame: RoleCallFrame;
         steeringVersion: number;
         responseRecommendation?: string;
+        directResponse?: RootAuthoredResponse;
         call: RootContractCallIdentity;
         toolResults: RequestToolResultsView;
         resume?: RoleChildReturnContext;

package/dist/src/runtime/request/root-execution-kernel.js

@@ -492,6 +492,7 @@ class RootExecutionSession {
             ? createPlainRootAuthoredResponse(decision.response)
             : await this.policy.rootContract.authorResponse(this.request, {
                 responseRecommendation: decision.responseRecommendation,
+                directResponse: decision.directResponse,
                 memoryRecallMessage: projectRootMemoryRecallMessage({
                     head: activation.head,
                     callId: activation.call.callId,

package/dist/src/runtime/request/runner.js

@@ -1,8 +1,9 @@
+import { prepareInitialMemory } from "../long-term-memory/initial-context.js";
 import { createRequestRoleCallPolicy } from "./role-call-policy.js";
 import { restoreApprovalExecutionFreshness } from "./capability-execution-freshness.js";
 import { captureRoleCallLedgerCheckpoint } from "../orchestration/role-calls/checkpoint.js";
 import { isRoleApprovalWait } from "../orchestration/role-executors/approval-continuation.js";
-import { resumeCapabilityApprovalGroup } from "../orchestration/worker-capabilities/execution/approval-group.js";
+import { restoreCapabilityApprovalGroup } from "../orchestration/worker-capabilities/execution/approval-group.js";
 import { createRoleApprovalContinuation, validateRequestApprovalContinuation, } from "./approval-continuation.js";
 import { createRoleCallLedger, resolveRoleCallTransactions, } from "../orchestration/role-calls/index.js";
 import { traceDebug } from "../observability/debug-logger.js";
@@ -26,8 +27,10 @@ export async function runRequestRunner(request, options = {}) {
             }
             : {}),
     });
+    const initialMemory = await prepareInitialMemory(request, options.continuation?.ledger.state.initialMemory);
     const ledger = createRoleCallLedger({
         requestId: request.requestId,
+        ...(initialMemory !== undefined ? { initialMemory } : {}),
         ...(options.continuation
             ? { checkpoint: options.continuation.ledger }
             : {}),
@@ -42,15 +45,18 @@ export async function runRequestRunner(request, options = {}) {
         let continuation;
         if (options.continuation) {
             validateRequestApprovalContinuation(options.continuation, ledger, request.workerCapabilities.provider.getDescriptors());
+            request.abortSignal.throwIfAborted();
             const executionFreshness = restoreApprovalExecutionFreshness(options.continuation.preparedGroup.executionFreshnessToken, request.requestSteering);
-            const settled = await resumeCapabilityApprovalGroup({
+            const prepared = await restoreCapabilityApprovalGroup({
                 ...(executionFreshness ? { executionFreshness } : {}),
                 ledger,
                 context: request.workerCapabilities.executionContext,
                 adapters: request.workerCapabilities.provider.getAdapters(),
                 group: options.continuation.preparedGroup,
-                decisions: options.decisions ?? [],
             });
+            request.abortSignal.throwIfAborted();
+            restoreApprovalExecutionFreshness(options.continuation.preparedGroup.executionFreshnessToken, request.requestSteering);
+            const settled = await prepared.execute(options.decisions ?? []);
             continuation = createRoleApprovalContinuation(options.continuation, settled.executionIds);
         }
         else {

package/dist/src/runtime/request/supervisor-root-execution.js

@@ -17,6 +17,9 @@ export const SUPERVISOR_ROOT_CONTRACT = Object.freeze({
             includeTitle: options.includeTitle,
             allowedRoleIds: options.allowedRoleIds,
             availableWorkerCapabilityCatalog: options.availableWorkerCapabilityCatalog,
+            ...(options.head.state.initialMemory?.message
+                ? { initialMemoryMessage: options.head.state.initialMemory.message }
+                : {}),
             ...(options.memoryRecallMessage
                 ? { memoryRecallMessage: options.memoryRecallMessage }
                 : {}),
@@ -28,6 +31,9 @@ export const SUPERVISOR_ROOT_CONTRACT = Object.freeze({
             responseRecommendation: options.responseRecommendation,
             call: options.call,
             toolResults: options.toolResults,
+            ...(options.head.state.initialMemory?.message
+                ? { initialMemoryMessage: options.head.state.initialMemory.message }
+                : {}),
             ...(options.memoryRecallMessage
                 ? { memoryRecallMessage: options.memoryRecallMessage }
                 : {}),

package/dist/src/runtime/steps/execution-agent/contracts.d.ts

@@ -1,4 +1,6 @@
 import type { MemoryRecallDecision } from "../memory-recall-decision.js";
+import type { MemoryCandidate } from "../../long-term-memory/contracts.js";
+import type { ConversationMemoryAuthoringContext } from "../../long-term-memory/conversation-authoring/context.js";
 import type { ExecutionWorkPlanOptions, ExecutionWorkPlanReport } from "./work-plan-contract.js";
 import type { RoleCapabilitySelectionProjection, RoleCapabilitySelectionReconsiderationCause } from "../../orchestration/role-calls/index.js";
 import { type CapabilityControls, type CapabilityDescriptor } from "../../orchestration/capability-adapters/index.js";
@@ -21,6 +23,10 @@ export type ExecutionAgentDecisionPresentation = Readonly<{
 }>;
 export type ExecutionAgentRespondDecision = Readonly<ExecutionAgentDecisionPresentation & {
     action: "respond";
+    /** Exact prevalidated short answer; absent keeps separate presentation. */
+    response?: string;
+    /** Assessed proposals bound to the same accepted direct response. */
+    memoryCandidates?: readonly MemoryCandidate[];
 }>;
 export type ExecutionAgentOpenCapabilityScopeDecision = Readonly<ExecutionAgentDecisionPresentation & {
     action: "open_capability_scope";
@@ -113,6 +119,10 @@ export type ExecutionAgentDecisionContractOptions = Readonly<{
     includeAcknowledgement?: boolean;
     includeTitle?: boolean;
     allowRespond?: boolean;
+    directResponseMaxLength?: number;
+    directResponseMemoryAuthoring?: Readonly<{
+        context?: ConversationMemoryAuthoringContext;
+    }>;
     allowMemoryRecall?: boolean;
     allowPlanner?: boolean;
     allowAuditor?: boolean;

package/dist/src/runtime/steps/execution-agent/decision-parsing.js

@@ -1,3 +1,4 @@
+import { parseDirectResponse, parseDirectResponseMemoryCandidates, } from "./direct-response-contract.js";
 import { readStructuredDecisionEnvelope } from "../../model/structured-decision-envelope.js";
 import { parseDecisionWithWorkPlan } from "./work-plan-decision-parsing.js";
 import { isMemoryRecallDecisionRecord, parseMemoryRecallDecision, } from "../memory-recall-decision.js";
@@ -62,12 +63,23 @@ function parseExecutionAgentActionOutput(text, options) {
         }
     }
     else if (selectedAction === "respond") {
-        exactKeys(record, ["action", ...presentationKeys(contract)], issues, "decision");
+        const response = parseDirectResponse(record, options.directResponseMaxLength, issues);
+        const memoryCandidates = response !== undefined
+            ? parseDirectResponseMemoryCandidates(record, options.directResponseMemoryAuthoring)
+            : undefined;
+        exactKeys(record, [
+            "action",
+            ...(response !== undefined ? ["response"] : []),
+            ...(memoryCandidates !== undefined ? ["memoryCandidates"] : []),
+            ...presentationKeys(contract),
+        ], issues, "decision");
         if (!contract.allowRespond) {
             issues.push(issue("execution_agent_response_not_allowed", "decision.action", "respond is not available until the canonical completion gate is open."));
         }
         decision = {
             action: "respond",
+            ...(response !== undefined ? { response } : {}),
+            ...(memoryCandidates !== undefined ? { memoryCandidates } : {}),
             ...presentation,
         };
     }

package/dist/src/runtime/steps/execution-agent/direct-response-configuration.d.ts

@@ -0,0 +1,3 @@
+import type { RequestExecutionScope } from "../../request/execution-scope.js";
+/** Preserve a separately configured response model/calibration instead of silently bypassing it. */
+export declare function hasCompatibleDirectResponseConfiguration(request: RequestExecutionScope): boolean;

package/dist/src/runtime/steps/execution-agent/direct-response-configuration.js

@@ -0,0 +1,64 @@
+import { isDeepStrictEqual } from "node:util";
+import { resolveModelInvocation } from "../../../model-gateway/invocation-policy.js";
+import { resolveModelStepTimeout } from "../../model/model-step-timeout-policy.js";
+import { EXECUTION_AGENT_DECISION_MODEL_STEP, EXECUTION_AGENT_RESPONSE_MODEL_STEP, } from "./contracts.js";
+/** Preserve a separately configured response model/calibration instead of silently bypassing it. */
+export function hasCompatibleDirectResponseConfiguration(request) {
+    try {
+        const decision = effectiveConfiguration(request, EXECUTION_AGENT_DECISION_MODEL_STEP);
+        const response = effectiveConfiguration(request, EXECUTION_AGENT_RESPONSE_MODEL_STEP);
+        if (!decision || !response)
+            return false;
+        return isDeepStrictEqual(decision, response);
+    }
+    catch {
+        // Resolution failures keep the existing deferred path and its diagnostics.
+        return false;
+    }
+}
+function effectiveConfiguration(request, modelStep) {
+    const step = request.runnerConfig.steps[modelStep];
+    if (!step)
+        return undefined;
+    const invocation = resolveModelInvocation({
+        modelStep,
+        agentMode: request.agentMode,
+        ...(request.modelPreference
+            ? { modelPreference: request.modelPreference }
+            : {}),
+        ...(request.modelPolicy ? { modelPolicy: request.modelPolicy } : {}),
+    });
+    if (hasSpecialResponseFormat(modelStep, invocation.format))
+        return undefined;
+    const { profile } = invocation;
+    return {
+        profileId: profile.id,
+        providerId: profile.providerId,
+        provider: profile.provider,
+        model: profile.model,
+        contextWindowTokens: profile.contextWindowTokens,
+        capabilities: profile.capabilities,
+        options: profile.options,
+        generation: profile.generation,
+        context: profile.context,
+        think: invocation.think,
+        instructions: invocation.instructions ?? [],
+        timeoutMs: resolveModelStepTimeout({
+            modelStep,
+            fallbackTimeoutMs: step.timeoutMs,
+            ...(request.modelPreference
+                ? { modelPreference: request.modelPreference }
+                : {}),
+            ...(request.modelPolicy ? { modelPolicy: request.modelPolicy } : {}),
+        }).timeoutMs,
+    };
+}
+function hasSpecialResponseFormat(modelStep, format) {
+    if (modelStep !== EXECUTION_AGENT_RESPONSE_MODEL_STEP)
+        return false;
+    if (format === undefined)
+        return false;
+    if (format && typeof format === "object" && "type" in format)
+        return format.type !== "text";
+    return true;
+}

package/dist/src/runtime/steps/execution-agent/direct-response-contract.d.ts

@@ -0,0 +1,7 @@
+import type { ExecutionAgentDecisionContractOptions, ExecutionAgentDecisionValidationIssue } from "./contracts.js";
+import type { MemoryCandidate } from "../../long-term-memory/contracts.js";
+/** A short-answer option, not a conversion from characters to model tokens. */
+export declare const EXECUTION_AGENT_DIRECT_RESPONSE_MAX_LENGTH = 1024;
+export declare function directResponseVariants(maxLength: number | undefined, presentation: Record<string, unknown>, memoryAuthoring?: boolean): Record<string, unknown>[];
+export declare function parseDirectResponse(record: Record<string, unknown>, maxLength: number | undefined, issues: ExecutionAgentDecisionValidationIssue[]): string | undefined;
+export declare function parseDirectResponseMemoryCandidates(record: Record<string, unknown>, authoring: ExecutionAgentDecisionContractOptions["directResponseMemoryAuthoring"]): readonly MemoryCandidate[] | undefined;

package/dist/src/runtime/steps/execution-agent/direct-response-contract.js

@@ -0,0 +1,56 @@
+import { conversationMemoryCandidatesSchema, parseConversationMemoryCandidates, } from "../../long-term-memory/conversation-authoring/contract.js";
+import { issue } from "./decision-validation.js";
+/** A short-answer option, not a conversion from characters to model tokens. */
+export const EXECUTION_AGENT_DIRECT_RESPONSE_MAX_LENGTH = 1_024;
+export function directResponseVariants(maxLength, presentation, memoryAuthoring = false) {
+    if (!isDirectResponseLimit(maxLength))
+        return [];
+    return [
+        {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                action: { type: "string", enum: ["respond"] },
+                response: { type: "string", minLength: 1, maxLength },
+                ...(memoryAuthoring
+                    ? { memoryCandidates: conversationMemoryCandidatesSchema }
+                    : {}),
+                ...presentation,
+            },
+            required: [
+                "action", "response",
+                ...(memoryAuthoring ? ["memoryCandidates"] : []),
+                ...Object.keys(presentation),
+            ],
+        },
+    ];
+}
+export function parseDirectResponse(record, maxLength, issues) {
+    if (!Object.hasOwn(record, "response"))
+        return undefined;
+    if (!isDirectResponseLimit(maxLength)) {
+        issues.push(issue("execution_agent_direct_response_unavailable", "decision.response", "This request requires the separate response authoring step."));
+        return undefined;
+    }
+    const response = record.response;
+    if (typeof response !== "string" || response.trim().length === 0) {
+        issues.push(issue("execution_agent_direct_response_invalid", "decision.response", "A direct response must contain the complete non-empty answer."));
+        return undefined;
+    }
+    if (response.length > maxLength) {
+        issues.push(issue("execution_agent_direct_response_too_long", "decision.response", `A direct response must fit ${maxLength} characters. Choose respond without response for a longer complete answer; do not shorten or truncate it.`));
+        return undefined;
+    }
+    return response;
+}
+export function parseDirectResponseMemoryCandidates(record, authoring) {
+    if (!authoring)
+        return undefined;
+    return parseConversationMemoryCandidates(record.memoryCandidates, authoring.context);
+}
+function isDirectResponseLimit(value) {
+    return (value !== undefined &&
+        Number.isInteger(value) &&
+        value > 0 &&
+        value <= EXECUTION_AGENT_DIRECT_RESPONSE_MAX_LENGTH);
+}

package/dist/src/runtime/steps/execution-agent/direct-response-policy.d.ts

@@ -0,0 +1,9 @@
+import type { RoleCallFrame, RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
+import type { RequestExecutionScope } from "../../request/execution-scope.js";
+import type { ExecutionMemoryProjection } from "../../long-term-memory/initial-context.js";
+/** Request-local offer only; neither prompt classification nor permission to omit required work. */
+export declare function resolveDirectResponseOffer(request: RequestExecutionScope, head: RoleCallLedgerHead, call: RoleCallFrame): Readonly<{
+    reason: string;
+    maxLength?: number;
+}>;
+export declare function canAuthorDirectResponseMemory(maxLength: number | undefined, memory: ExecutionMemoryProjection | undefined): memory is ExecutionMemoryProjection;

package/dist/src/runtime/steps/execution-agent/direct-response-policy.js

@@ -0,0 +1,30 @@
+import { EXECUTION_AGENT_DIRECT_RESPONSE_MAX_LENGTH } from "./direct-response-contract.js";
+import { hasCompatibleDirectResponseConfiguration } from "./direct-response-configuration.js";
+/** Request-local offer only; neither prompt classification nor permission to omit required work. */
+export function resolveDirectResponseOffer(request, head, call) {
+    if (request.automationOutputContract)
+        return { reason: "automation_output_contract" };
+    if (request.scheduledExecution)
+        return { reason: "scheduled_execution" };
+    if (request.sessionKind === "spark")
+        return { reason: "spark_session" };
+    if (head.state.capabilityExecutions.length > 0)
+        return { reason: "capability_work" };
+    if (head.state.calls.length !== 1)
+        return { reason: "delegated_work" };
+    if (head.state.results.length > 0)
+        return { reason: "subordinate_results" };
+    if (call.adoptedWorkPlan)
+        return { reason: "work_plan" };
+    if (!hasCompatibleDirectResponseConfiguration(request))
+        return { reason: "response_configuration" };
+    return {
+        reason: "eligible",
+        maxLength: Math.min(EXECUTION_AGENT_DIRECT_RESPONSE_MAX_LENGTH, head.policy.limits.maxResponseChars),
+    };
+}
+export function canAuthorDirectResponseMemory(maxLength, memory) {
+    if (maxLength === undefined)
+        return false;
+    return memory?.authoringEnabled === true;
+}

package/dist/src/runtime/steps/execution-agent/direct-response-prompt.d.ts

@@ -0,0 +1,7 @@
+import type { RequestRunnerConfig } from "../../config/runner/contracts.js";
+/** Presentation guidance applies only to the optional final-answer field, never to routing. */
+export declare function buildDirectResponseInstructions(maxLength: number | undefined, runnerConfig: RequestRunnerConfig, memoryAuthoringEnabled?: boolean): readonly string[];
+export declare function buildRespondDecisionInstruction(params: {
+    allowRespond: boolean;
+    allowDirectResponse?: boolean;
+}): string;