@abot-ai/runtime 1.8.1 → 2.0.0

package/dist/src/runtime/steps/execution-agent/capability-result-context.js

@@ -1,8 +1,9 @@
 import { projectCanonicalRequestToolResult } from "../../context/canonical-capability-result.js";
+import { createSemanticCompactionSha256Fingerprint, } from "../../context/semantic-compaction/contracts.js";
 export const EXECUTION_CAPABILITY_RESULT_MESSAGE_KIND = "runtime_execution_capability_result_v1";
 export const EXECUTION_CAPABILITY_TOOL_NAME = "runtime_capability";
-/** One exact native result representation for active input and saved-source compatibility. */
-export function buildExecutionCapabilityResultMessage(head, execution) {
+/** Canonical bytes stay stable; only the model view may omit an exact duplicate. */
+export function buildExecutionCapabilityResultMessage(head, execution, projection = "canonical") {
     if (execution.status !== "settled" || execution.exactResult === undefined) {
         throw new Error("execution_agent_continuation_result_invalid");
     }
@@ -19,7 +20,9 @@ export function buildExecutionCapabilityResultMessage(head, execution) {
                 capabilityId: execution.capabilityId,
                 outcome: canonical.outcome,
                 observedEffect: canonical.observedEffect,
-                summary: canonical.summary,
+                ...(canOmitDuplicateSummary(projection, canonical)
+                    ? {}
+                    : { summary: canonical.summary }),
                 adapterResult: execution.exactResult,
             },
         }),
@@ -27,3 +30,19 @@ export function buildExecutionCapabilityResultMessage(head, execution) {
         toolName: EXECUTION_CAPABILITY_TOOL_NAME,
     });
 }
+/** Reuse the original native-message identity for compaction and approval resume. */
+export function buildExecutionCapabilityResultSource(head, execution) {
+    const content = JSON.stringify(buildExecutionCapabilityResultMessage(head, execution));
+    return Object.freeze({
+        sourceRef: `tool-result:${execution.executionId}`,
+        sourceFingerprint: createSemanticCompactionSha256Fingerprint(content),
+        content,
+    });
+}
+function canOmitDuplicateSummary(projection, result) {
+    if (projection !== "model")
+        return false;
+    if (result.adapterResult?.kind !== "registered_tool_execution_result_v1")
+        return false;
+    return result.summary === result.adapterResult.result.output;
+}

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

@@ -0,0 +1,17 @@
+import { type CapabilityCatalogGroup, type CapabilityDescriptor } from "../../orchestration/capability-adapters/index.js";
+import type { RoleCallFrame, RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
+import { type RequestExecutionScope } from "../../request/execution-scope.js";
+/** One decision-local capability offer shared by guidance loading and input. */
+export type ExecutionCapabilityScope = Readonly<{
+    capabilities: readonly CapabilityDescriptor[];
+    capabilityCatalogGroups: readonly CapabilityCatalogGroup[];
+    activeCapabilityCatalogGroupIds: readonly string[] | null;
+    knownGroupIds: readonly string[];
+    remainingExecutions: number;
+    capabilityScopeAction: "open" | "extend" | null;
+}>;
+export declare function resolveExecutionCapabilityScope(request: RequestExecutionScope, options: Readonly<{
+    head: RoleCallLedgerHead;
+    call: RoleCallFrame;
+}>): ExecutionCapabilityScope;
+export declare function assertExecutionAgentCanonicalSource(request: RequestExecutionScope, head: RoleCallLedgerHead, call: RoleCallFrame): void;

package/dist/src/runtime/steps/execution-agent/capability-scope.js

@@ -0,0 +1,54 @@
+import { projectCapabilityCatalogGroups, projectCapabilityScope, } from "../../orchestration/capability-adapters/index.js";
+import { resolveRequestWorkerCapabilities, } from "../../request/execution-scope.js";
+export function resolveExecutionCapabilityScope(request, options) {
+    assertExecutionAgentCanonicalSource(request, options.head, options.call);
+    const allCapabilities = resolveRequestWorkerCapabilities(request).provider.getDescriptors();
+    const capabilityCatalogGroups = projectCapabilityCatalogGroups(allCapabilities);
+    const activeCapabilityCatalogGroupIds = options.call.workerCapabilityScope
+        ? Object.freeze([...options.call.workerCapabilityScope.catalogGroupIds])
+        : null;
+    const remainingExecutions = options.head.policy.limits.maxCapabilityExecutions -
+        options.head.state.capabilityExecutions.length;
+    const capabilities = canOfferScopedCapabilities(activeCapabilityCatalogGroupIds, remainingExecutions)
+        ? projectCapabilityScope({
+            entries: allCapabilities,
+            scope: options.call.workerCapabilityScope,
+            descriptorOf: (entry) => entry,
+        }).entries
+        : Object.freeze([]);
+    const knownGroupIds = Object.freeze(capabilityCatalogGroups.map(({ groupId }) => groupId));
+    return Object.freeze({
+        capabilities,
+        capabilityCatalogGroups,
+        activeCapabilityCatalogGroupIds,
+        knownGroupIds,
+        remainingExecutions,
+        capabilityScopeAction: resolveCapabilityScopeAction(activeCapabilityCatalogGroupIds, knownGroupIds, remainingExecutions),
+    });
+}
+export function assertExecutionAgentCanonicalSource(request, head, call) {
+    if (head.state.requestId !== request.requestId ||
+        head.state.phase !== "running" ||
+        head.state.rootCallId !== call.callId ||
+        head.state.activeCallId !== call.callId ||
+        call.parentCallId !== null ||
+        call.status !== "active") {
+        throw new Error("execution_agent_head_invalid");
+    }
+}
+function canOfferScopedCapabilities(activeGroupIds, remainingExecutions) {
+    if (activeGroupIds === null)
+        return false;
+    return remainingExecutions > 0;
+}
+function resolveCapabilityScopeAction(activeGroupIds, knownGroupIds, remainingExecutions) {
+    if (remainingExecutions <= 0)
+        return null;
+    if (knownGroupIds.length === 0)
+        return null;
+    if (activeGroupIds === null)
+        return "open";
+    if (knownGroupIds.some((groupId) => !activeGroupIds.includes(groupId)))
+        return "extend";
+    return null;
+}

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

@@ -1,17 +1,18 @@
 import type { RequestSteeringSnapshot } from "../../request/request-steering.js";
 import type { ModelStep } from "../../../shared/model-steps.js";
-import type { RoleCallFrame } from "../../orchestration/role-calls/index.js";
+import type { RoleCallFrame, RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
 import type { RequestExecutionScope } from "../../request/execution-scope.js";
 type ExecutionAgentCompactionOptions = Readonly<{
     call: RoleCallFrame;
     steeringSnapshot: RequestSteeringSnapshot;
-    sourceRevision: number;
+    head: RoleCallLedgerHead;
     consumer?: ModelStep;
     allowedConsumers: readonly ModelStep[];
     scopeSuffix?: string;
 }>;
 export declare function createExecutionAgentCompactionController(request: RequestExecutionScope, options: ExecutionAgentCompactionOptions): Readonly<{
     project(messages: readonly import("../../../model-gateway/types.js").ChatMessage[]): import("../../../model-gateway/types.js").ChatMessage[];
+    projectForCompaction?(messages: readonly import("../../../model-gateway/types.js").ChatMessage[]): readonly import("../../../model-gateway/types.js").ChatMessage[];
     hasExhaustedVerifiedCompactionSources?(messages: readonly import("../../../model-gateway/types.js").ChatMessage[]): boolean;
     getStages(): readonly import("../../model/context-compaction-contracts.js").ModelStepCompactionStage[];
 }>;

package/dist/src/runtime/steps/execution-agent/compaction.js

@@ -1,18 +1,42 @@
+import { resolveExecutionEvidenceCheckpoint } from "../../context/execution-compaction-checkpoint-selection.js";
 import { executionCompactionScopeId, projectExecutionCompactionObjective, } from "../../context/execution-compaction-objective.js";
 import { createModelStepCompactionController } from "../../context/model-step-compaction.js";
+import { buildExecutionCapabilityResultSource } from "./capability-result-context.js";
 export function createExecutionAgentCompactionController(request, options) {
     const objective = projectExecutionCompactionObjective(request.prompt, options.steeringSnapshot.updates);
     const call = Object.freeze({ ...options.call, objective });
+    const scopeId = executionCompactionScopeId({
+        callId: call.callId,
+        prompt: request.prompt,
+        objective,
+        ...(options.scopeSuffix ? { scopeSuffix: options.scopeSuffix } : {}),
+    });
+    const checkpoint = resolveExecutionEvidenceCheckpoint({
+        requestId: request.requestId,
+        prompt: request.prompt,
+        objective,
+        callId: call.callId,
+        store: request.contextCompactionStore,
+        updates: options.steeringSnapshot.updates,
+        allowedConsumers: options.allowedConsumers,
+        scopeSuffix: options.scopeSuffix,
+        sourceRevision: options.head.revision,
+    });
     return createModelStepCompactionController(request, {
         call,
-        sourceRevision: options.sourceRevision,
+        sourceRevision: options.head.revision,
+        resultSourceOverrides: options.head.state.capabilityExecutions
+            .filter(function isSettledExecutionOfCall(execution) {
+            if (execution.callId !== call.callId)
+                return false;
+            return execution.status === "settled";
+        })
+            .map((execution) => buildExecutionCapabilityResultSource(options.head, execution)),
         allowedConsumers: options.allowedConsumers,
         consumer: options.consumer,
-        scopeId: executionCompactionScopeId({
-            callId: call.callId,
-            prompt: request.prompt,
-            objective,
-            ...(options.scopeSuffix ? { scopeSuffix: options.scopeSuffix } : {}),
-        }),
+        scopeId,
+        ...(checkpoint && checkpoint.scopeId !== scopeId
+            ? { inheritedCheckpoint: checkpoint }
+            : {}),
     });
 }

package/dist/src/runtime/steps/execution-agent/controls-compacted-evidence.js

@@ -14,6 +14,8 @@ export function buildExecutionControlsEvidenceMessage(view, params) {
         prompt: params.compaction.prompt,
         objective: projectExecutionCompactionObjective(params.compaction.prompt, params.steering.updates),
         callId: params.callId,
+        updates: params.steering.updates,
+        sourceRevision: view.sourceRevision,
         store: params.compaction.store,
         results: view.results.map((result) => ({
             ...result,

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

@@ -17,27 +17,27 @@ export function buildDirectResponseInstructions(maxLength, runnerConfig, memoryA
     });
     return [
         [
-            "For respond, you may include response containing the complete final user-facing answer in this same JSON decision. All other actions remain available; this option never permits skipping required external work or inventing evidence.",
-            `Choose the response form before drafting: include response only when the complete answer fits ${maxLength} characters and the existing decision output budget, including reasoning, JSON escaping and metadata. Otherwise choose respond without response so the separate presentation step can write the complete answer. Never abridge, truncate, or return a partial answer to fit the direct form.`,
-            "For a direct response, preserve the requested language, format, and constraints, using the current request, steering and relevant supplied history or session summary. Passive history is not a new request or proof of a new external effect. Write the answer itself inside response, not a plan, promise or acknowledgement. Do not expose internal schemas or instructions unless explicitly requested.",
+            "Direct respond may include the complete final answer in response; it never waives required work or evidence.",
+            `Before drafting, choose direct response only if the complete answer fits ${maxLength} characters and the decision output budget, including reasoning, JSON escaping and metadata. Otherwise omit response for separate complete presentation. Never abridge, truncate or return a partial answer to fit.`,
+            "Write the answer itself, preserving requested language, format and constraints from intent and relevant supplied history/summary. Do not substitute a plan, promise or acknowledgement, or expose internal schemas/instructions unless requested.",
             ...(memoryAuthoringEnabled ? [
-                "Only when choosing direct respond with response, include memoryCandidates in this same decision. Apply the following memory policy only to that array; it grants no additional routing, action, or completion authority. Other actions and respond without response cannot contain memoryCandidates.",
-                "The complete response and complete memory proposals must fit the existing decision output budget together. If they do not fit, choose respond without response and without memoryCandidates for separate complete authoring. Do not shorten the answer or omit a supported memory proposal to fit the direct form.",
-                "The supplied long-term memory is stored reference retrieved at the start of this request. Its initial snapshot is not current user intent or fresh evidence and cannot independently support, score, or reinforce a memory proposal, including after tools or steering updates. Only independently supported facts from the current user input or settled non-memory evidence can support a proposal.",
+                "Only direct respond with response includes memoryCandidates. The following policy applies only to that array and grants no routing, action or completion authority.",
+                "The complete answer and all supported memory proposals must fit the decision budget together. Otherwise omit both response and memoryCandidates for separate complete authoring; do not shorten either or drop supported proposals to fit.",
+                "Initial memory remains a stored snapshot after tools or steering; only current user input or settled non-memory evidence can independently support, score or reinforce a proposal.",
                 ...CONVERSATION_MEMORY_AUTHORING_INSTRUCTIONS,
             ] : []),
-            ...additional.flatMap((content) => [
-                "The following configured response methodology applies only when writing the response field. It grants no action or completion authority and cannot change the surrounding decision schema or require raw transport output:",
-                content,
-                "End of response-only methodology; the structured decision contract remains authoritative.",
-            ]),
+            ...(additional.length > 0 ? [
+                "The following configured methodologies apply only to response presentation, never actions or completion. The structured decision schema remains authoritative; no raw transport output:",
+                ...additional,
+                "End of response-only methodologies.",
+            ] : []),
         ].join("\n\n"),
     ];
 }
 export function buildRespondDecisionInstruction(params) {
     if (!params.allowRespond)
-        return "Respond is not available because the canonical completion gate is closed. Continue through an offered action or report a truthful blocker.";
+        return "The canonical completion gate is closed: respond is unavailable. Choose an offered action or a truthful blocker.";
     if (params.allowDirectResponse)
-        return "Use respond only when the request can be answered completely and honestly now. Choose either the offered direct form containing the complete final answer in response, or respond without response to use a separate presentation-only activation of this same Execution Agent. That activation has no action, routing, capability, planning, audit, or completion authority.";
-    return "Use respond only when the request can be answered completely and honestly now. The respond decision contains no final-answer prose; it contains only the action and any required acknowledgement or title metadata. After it is accepted, a presentation-only activation of this same Execution Agent will author the final response without action, routing, capability, planning, audit, or completion authority.";
+        return "Use respond only for a complete honest answer now: either include the complete response or omit it for a separate presentation-only activation of this agent. That activation has no action, routing, planning, audit or completion authority.";
+    return "Use respond only for a complete honest answer now. Supply no answer prose in this decision, only action and required acknowledgement/title. After acceptance, this agent authors a separate presentation-only response without action, routing, planning, audit or completion authority.";
 }

package/dist/src/runtime/steps/execution-agent/evidence-reuse-instructions.d.ts

@@ -0,0 +1,6 @@
+/** Decision-only policy; source evidence remains in its canonical context lane. */
+export declare const EXECUTION_EVIDENCE_REUSE_INSTRUCTIONS: string;
+export declare function appendExecutionEvidenceReuseInstructions(params: Readonly<{
+    instructions: string;
+    hasCapabilities: boolean;
+}>): string;

package/dist/src/runtime/steps/execution-agent/evidence-reuse-instructions.js

@@ -0,0 +1,13 @@
+/** Decision-only policy; source evidence remains in its canonical context lane. */
+export const EXECUTION_EVIDENCE_REUSE_INSTRUCTIONS = [
+    "Use the latest supplied continuation checkpoint and settled evidence as your working memory. First establish what they already tell you about the next requested outcome. When that evidence is sufficient, continue the work; do not reread just to restore the original wording or the complete file after compaction.",
+    "A read has real latency and token cost and can cause another compaction. Before selecting a repeated observation, identify the concrete fact still missing from the supplied evidence, or the relevant change that makes the evidence stale. Choose the smallest lookup or range that resolves that gap rather than collecting the same file again.",
+    "For an existing-file edit, the selected editor loads the current target itself. Reuse the collected interface and dependency facts to specify the change; do not reread the target solely to supply its full body to that editor. Related files still require evidence when their relevant contract is not already supplied.",
+    "Conserve reads without weakening grounding: never invent missing values, treat omissions as absence, ignore a relevant change, or skip required verification merely to save a call. If a necessary fact is genuinely missing, obtain it with a focused observation.",
+    "",
+].join("\n");
+export function appendExecutionEvidenceReuseInstructions(params) {
+    if (!params.hasCapabilities)
+        return params.instructions;
+    return [params.instructions, EXECUTION_EVIDENCE_REUSE_INSTRUCTIONS].join("\n\n");
+}

package/dist/src/runtime/steps/execution-agent/format.js

@@ -2,8 +2,9 @@ import { directResponseVariants } from "./direct-response-contract.js";
 import { createMemoryRecallDecisionSchema } from "../memory-recall-decision.js";
 import { createExecutionWorkPlanDecisionSchema } from "./work-plan-schema.js";
 import { isToolCatalogGroupId } from "../../../capabilities/tool-types.js";
-import { CAPABILITY_COUNT_MAX, EXECUTION_WORKING_DIRECTORY_MAX_LENGTH, EXECUTION_WORKING_DIRECTORY_PATTERN, canOfferCapabilityBatchSelection, normalizeCapabilityDescriptor, normalizeCapabilityControlsSchema, partitionCapabilityControlsSchema, } from "../../orchestration/capability-adapters/index.js";
+import { CAPABILITY_COUNT_MAX, EXECUTION_WORKING_DIRECTORY_MAX_LENGTH, EXECUTION_WORKING_DIRECTORY_PATTERN, canOfferCapabilityBatchSelection, normalizeCapabilityDescriptor, } from "../../orchestration/capability-adapters/index.js";
 import { EXECUTION_AGENT_ACKNOWLEDGEMENT_MAX_LENGTH, EXECUTION_AGENT_AUDIT_CRITERION_COUNT_MAX, EXECUTION_AGENT_AUDIT_CRITERION_ID_MAX_LENGTH, EXECUTION_AGENT_CAPABILITY_SCOPE_GROUP_COUNT_MAX, EXECUTION_AGENT_CAPABILITY_BATCH_COUNT_MAX, EXECUTION_AGENT_OBJECTIVE_MAX_LENGTH, EXECUTION_AGENT_RESPONSE_MAX_LENGTH, EXECUTION_AGENT_TITLE_MAX_LENGTH, } from "./contracts.js";
+import { partitionExecutionCapabilityControls } from "./capability-controls-partition.js";
 import { projectCapabilitySelectionProperties } from "./capability-selection-schema.js";
 import { freezeControlsEvidenceEligibility } from "./controls-evidence-contract.js";
 export function createExecutionAgentDecisionFormat(options = {}) {
@@ -183,11 +184,7 @@ export function prepareExecutionAgentDecisionContract(options) {
         if (!normalized.ok) {
             throw new Error("execution_agent_capabilities_invalid");
         }
-        const controls = normalizeCapabilityControlsSchema(normalized.value.controls);
-        if (!controls.ok) {
-            throw new Error("execution_agent_capabilities_invalid");
-        }
-        const partition = partitionCapabilityControlsSchema(controls.value, normalized.value.selectionControlIds);
+        const partition = partitionExecutionCapabilityControls(normalized.value);
         if (!partition.ok) {
             throw new Error("execution_agent_capabilities_invalid");
         }

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

@@ -2,11 +2,13 @@ import type { ChatMessage, ModelGatewayJsonSchemaFormat } from "../../../model-g
 import type { RequestContextProjection } from "../../context/request-context-contracts.js";
 import type { ExecutionMemoryProjection } from "../../long-term-memory/initial-context.js";
 import type { RoleCallFrame, RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
-import { type CapabilityCatalogGroup, type CapabilityDescriptor } from "../../orchestration/capability-adapters/index.js";
+import type { CapabilityCatalogGroup, CapabilityDescriptor } from "../../orchestration/capability-adapters/index.js";
 import { type RequestExecutionScope } from "../../request/execution-scope.js";
 import { appendRequestSteeringContext } from "../../request/request-steering-context.js";
 import type { RequestSteeringSnapshot } from "../../request/request-steering.js";
 import { EXECUTION_AGENT_DECISION_MODEL_STEP, type ExecutionAgentDecisionContractOptions } from "./contracts.js";
+import { type ExecutionCapabilityScope } from "./capability-scope.js";
+import { type ExecutionObservationGuidance } from "./observation-guidance.js";
 export type ExecutionAgentInput = Readonly<{
     context: RequestContextProjection;
     messages: ReturnType<typeof appendRequestSteeringContext>;
@@ -27,6 +29,8 @@ type BuildExecutionAgentInputOptions = Readonly<{
     allowAuditor: boolean;
     memoryRecallMessage?: ChatMessage;
     memoryContext?: ExecutionMemoryProjection;
+    capabilityScope?: ExecutionCapabilityScope;
+    observationGuidance?: readonly ExecutionObservationGuidance[];
 }>;
 export declare function buildExecutionAgentInput(request: RequestExecutionScope, options: BuildExecutionAgentInputOptions): ExecutionAgentInput;
 export {};

package/dist/src/runtime/steps/execution-agent/input.js

@@ -1,3 +1,4 @@
+import { projectAvailableSkillsInstructions } from "../../knowledge-skills/available-skills-projection.js";
 import { buildRuntimeFilesystemScopeMessage, canEstablishRuntimeWorkingDirectory, } from "../../context/runtime-filesystem-scope.js";
 import { canAuthorDirectResponseMemory, resolveDirectResponseOffer } from "./direct-response-policy.js";
 import { buildDirectResponseInstructions } from "./direct-response-prompt.js";
@@ -6,13 +7,13 @@ import { buildSparkConversationInstructions } from "../../context/spark-conversa
 import { projectRequestContext } from "../../context/request-context.js";
 import { projectRootSessionMemory } from "../../context/session-memory/root-projection.js";
 import { buildConversationMemoryAvailabilityInstructions } from "../../long-term-memory/conversation-authoring/prompt.js";
+import { buildConversationMemoryAuthoringPlainTextMessage } from "../../long-term-memory/conversation-authoring/plain-text-context.js";
 import { canOfferMemoryRecall } from "../../long-term-memory/recall-policy.js";
 import { projectMemoryRecallContinuations } from "../../long-term-memory/recall-continuation.js";
 import { buildRequestTemporalContextMessage } from "../../context/request-temporal-context.js";
 import { projectScheduledExecutionContext } from "../../context/scheduled-execution-context.js";
 import { buildImmediateOperationSupervisionEvidenceMessage } from "../../context/operation-supervision-evidence.js";
 import { resolveModelContextBudget } from "../../model/model-context-budget.js";
-import { projectCapabilityCatalogGroups, projectCapabilityScope, } from "../../orchestration/capability-adapters/index.js";
 import { resolveRequestWorkerCapabilities, } from "../../request/execution-scope.js";
 import { resolveRequestCapabilityBriefEntries } from "../../request/capability-brief.js";
 import { appendRequestSteeringContext } from "../../request/request-steering-context.js";
@@ -22,34 +23,15 @@ import { projectEligibleControlsEvidenceExecutionIds, requiresControlsEvidenceSe
 import { createExecutionAgentDecisionFormat, prepareExecutionAgentDecisionContract, } from "./format.js";
 import { projectExecutionWorkPlanOptions } from "./work-plan-sources.js";
 import { buildExecutionAgentInstructions } from "./prompt.js";
+import { appendExecutionEvidenceReuseInstructions } from "./evidence-reuse-instructions.js";
+import { assertExecutionAgentCanonicalSource, resolveExecutionCapabilityScope, } from "./capability-scope.js";
+import { buildExecutionObservationGuidanceInstructions, } from "./observation-guidance.js";
 import { buildExecutionCapabilityCatalogMessage, buildExecutionCapabilityGroupCatalogMessage, buildExecutionContinuationMessages, buildExecutionDecisionStateMessage, } from "./state-context.js";
 export function buildExecutionAgentInput(request, options) {
-    assertCanonicalSource(request, options.head, options.call);
+    assertExecutionAgentCanonicalSource(request, options.head, options.call);
     const directResponse = resolveDirectResponseOffer(request, options.head, options.call);
-    const allCapabilities = resolveRequestWorkerCapabilities(request).provider.getDescriptors();
-    const capabilityCatalogGroups = projectCapabilityCatalogGroups(allCapabilities);
-    const activeCapabilityCatalogGroupIds = options.call.workerCapabilityScope?.catalogGroupIds ?? null;
+    const { capabilities, capabilityCatalogGroups, activeCapabilityCatalogGroupIds, knownGroupIds, remainingExecutions, capabilityScopeAction, } = options.capabilityScope ?? resolveExecutionCapabilityScope(request, options);
     const eligibleSessionArtifactPaths = projectEligibleSessionArtifactPaths(request.sessionArtifactPaths, options.head, options.call);
-    const remainingExecutions = options.head.policy.limits.maxCapabilityExecutions -
-        options.head.state.capabilityExecutions.length;
-    const scopedCapabilities = activeCapabilityCatalogGroupIds !== null && remainingExecutions > 0
-        ? projectCapabilityScope({
-            entries: allCapabilities,
-            scope: options.call.workerCapabilityScope,
-            descriptorOf: (entry) => entry,
-        }).entries
-        : Object.freeze([]);
-    const capabilities = scopedCapabilities;
-    const knownGroupIds = Object.freeze(capabilityCatalogGroups.map(({ groupId }) => groupId));
-    const hasInactiveGroup = activeCapabilityCatalogGroupIds !== null &&
-        knownGroupIds.some((groupId) => !activeCapabilityCatalogGroupIds.includes(groupId));
-    const capabilityScopeAction = remainingExecutions <= 0 || knownGroupIds.length === 0
-        ? null
-        : activeCapabilityCatalogGroupIds === null
-            ? "open"
-            : hasInactiveGroup
-                ? "extend"
-                : null;
     const auditInput = projectAuditorInputState(options.head, options.call.callId, options.steeringSnapshot.version);
     const availableAuditCriterionIds = options.allowAuditor && auditInput.available
         ? Object.freeze([EXECUTION_AGENT_ROOT_AUDIT_CRITERION_ID])
@@ -112,6 +94,7 @@ export function buildExecutionAgentInput(request, options) {
             includeTitle: options.includeTitle,
             includeWorkingDirectory: options.call.workingDirectory === undefined,
         }),
+        ...buildExecutionObservationGuidanceInstructions(capabilities, options.observationGuidance ?? []),
         ...buildDirectResponseInstructions(directResponse.maxLength, request.runnerConfig, directMemoryAuthoring !== undefined),
         ...buildConversationMemoryAvailabilityInstructions(request.longTermMemory?.enabled === true),
         ...buildSparkConversationInstructions(request.sessionKind),
@@ -131,7 +114,8 @@ export function buildExecutionAgentInput(request, options) {
         ...(filesystemMessage ? [filesystemMessage] : []),
         ...scheduledExecution.referenceMessages,
         ...(automaticMemoryMessage ? [automaticMemoryMessage] : []),
-        ...(directMemoryAuthoring?.context ? [directMemoryAuthoring.context.message] : []),
+        ...(directMemoryAuthoring?.context
+            ? [buildConversationMemoryAuthoringPlainTextMessage(directMemoryAuthoring.context)] : []),
         ...(request.temporalContext
             ? [buildRequestTemporalContextMessage(request.temporalContext)]
             : []),
@@ -152,8 +136,11 @@ export function buildExecutionAgentInput(request, options) {
         requestId: request.requestId, reason: directResponse.reason,
         maxLength: directResponse.maxLength ?? null,
     });
-    const context = projectRequestContext({
-        instructions: scheduledExecution.instructions,
+    const contextInput = {
+        instructions: appendExecutionEvidenceReuseInstructions({
+            instructions: scheduledExecution.instructions,
+            hasCapabilities: capabilities.length > 0,
+        }),
         format,
         ...sessionMemory,
         prompt: request.prompt,
@@ -168,6 +155,15 @@ export function buildExecutionAgentInput(request, options) {
             callId: options.call.callId,
         },
         onEvent: request.onEvent,
+    };
+    const skills = remainingExecutions > 0
+        ? resolveRequestWorkerCapabilities(request).provider.getAvailableSkills?.() ?? []
+        : [];
+    const context = projectRequestContext({
+        ...contextInput,
+        instructions: projectAvailableSkillsInstructions({
+            skills, context: contextInput,
+        }),
     });
     return Object.freeze({
         context,
@@ -193,13 +189,3 @@ function projectEligibleSessionArtifactPaths(sessionArtifactPaths, head, call) {
         .slice(0, 8)
         .filter((target) => !currentRequestTargets.has(target)));
 }
-function assertCanonicalSource(request, head, call) {
-    if (head.state.requestId !== request.requestId ||
-        head.state.phase !== "running" ||
-        head.state.rootCallId !== call.callId ||
-        head.state.activeCallId !== call.callId ||
-        call.parentCallId !== null ||
-        call.status !== "active") {
-        throw new Error("execution_agent_head_invalid");
-    }
-}

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

@@ -0,0 +1,11 @@
+import type { CapabilityDescriptor } from "../../orchestration/capability-adapters/index.js";
+import { type RequestExecutionScope } from "../../request/execution-scope.js";
+import type { ExecutionCapabilityScope } from "./capability-scope.js";
+export type ExecutionObservationGuidance = Readonly<{
+    capabilityId: string;
+    guidance: string;
+}>;
+/** Load only the contracts whose operational values this decision will own. */
+export declare function loadExecutionObservationGuidance(request: RequestExecutionScope, scope: ExecutionCapabilityScope): Promise<readonly ExecutionObservationGuidance[]>;
+/** Preserve complete rules, deduplicate shared bodies, and bind applicability. */
+export declare function buildExecutionObservationGuidanceInstructions(capabilities: readonly CapabilityDescriptor[], guidance: readonly ExecutionObservationGuidance[]): readonly string[];

package/dist/src/runtime/steps/execution-agent/observation-guidance.js

@@ -0,0 +1,33 @@
+import { resolveRequestWorkerCapabilities, } from "../../request/execution-scope.js";
+import { buildBatchCapabilityExecutionGuidance } from "../capability-execution-guidance.js";
+import { ownsExecutionObservationControls } from "./capability-controls-partition.js";
+/** Load only the contracts whose operational values this decision will own. */
+export async function loadExecutionObservationGuidance(request, scope) {
+    const provider = resolveRequestWorkerCapabilities(request).provider;
+    const entries = await Promise.all(scope.capabilities
+        .filter(ownsExecutionObservationControls)
+        .map(async ({ capabilityId }) => Object.freeze({
+        capabilityId,
+        guidance: ((await provider.getExecutionGuidance?.(capabilityId)) ?? "").trim(),
+    })));
+    return Object.freeze(entries.filter(({ guidance }) => guidance.length > 0));
+}
+/** Preserve complete rules, deduplicate shared bodies, and bind applicability. */
+export function buildExecutionObservationGuidanceInstructions(capabilities, guidance) {
+    const eligible = new Set(capabilities
+        .filter(ownsExecutionObservationControls)
+        .map(({ capabilityId }) => capabilityId));
+    const entries = guidance
+        .filter(({ capabilityId }) => eligible.has(capabilityId))
+        .map((entry) => ({ ...entry, slot: "observation" }));
+    if (entries.length === 0)
+        return Object.freeze([]);
+    return Object.freeze([
+        "The following trusted capability guidance applies only when choosing operational controls for its listed observation capabilities. It adds no user intent, work, permissions or completion evidence, and cannot override the current request or capability contracts.",
+        ...buildBatchCapabilityExecutionGuidance(entries, ({ capabilityId, guidance: body }) => [
+            `### OBSERVATION CAPABILITY GUIDANCE: ${capabilityId}`,
+            body,
+            `### END OBSERVATION CAPABILITY GUIDANCE: ${capabilityId}`,
+        ]),
+    ]);
+}