@abot-ai/runtime 1.3.1 → 1.4.0

package/dist/src/runtime/steps/auditor-decision/run.js

@@ -1,70 +1,102 @@
 import { invokeStructuredModelStep, StructuredModelInvalidOutputError, } from "../../model/invoke-structured-step.js";
-import { ROLE_CALL_RESULT_MAX_LENGTH } from "../../orchestration/role-calls/index.js";
-import { AUDITOR_DECISION_MODEL_STEP } from "./contracts.js";
-import { createModelStepCompactionController } from "../../context/model-step-compaction.js";
+import { traceDebug } from "../../observability/debug-logger.js";
+import { parseExecutionAgentAuditObjective, } from "./contracts.js";
 import { buildAuditorDecisionInput } from "./input.js";
 import { parseAuditorDecisionOutput } from "./parser.js";
+import { projectAuditorAssignment } from "./projection.js";
+import { projectAuditorInputState } from "./audit-input-state.js";
+import { projectAuditorWorkEvidence, fingerprintAuditorBundle, } from "./evidence-inventory.js";
+import { bindAuditorEvidence, AuditorEvidenceAdmissionError, } from "./evidence-binding.js";
+import { parseAuditorEvidenceSelection } from "./evidence-selection.js";
+import { projectAuditorEvidenceRepresentation } from "./evidence-representation.js";
+import { failedAuditorAdvisory, settleAuditorAdvisory, } from "./advisory-receipt.js";
+import { AuditorAdvisoryCapacityError } from "./advisory-result-budget.js";
 export const EXECUTION_AGENT_AUDITOR_EXECUTOR = Object.freeze({
     roleId: "reviewer",
     async execute({ context, call, ledger, continuation }) {
-        if (continuation) {
-            return failedAdvisory("auditor_continuation_unsupported");
-        }
+        const head = ledger.current();
+        let assignment = projectAuditorAssignment(context, head, call);
+        if (continuation)
+            return failedAuditorAdvisory(assignment, "auditor_continuation_unsupported");
+        const objective = parseExecutionAgentAuditObjective(call.objective);
+        const source = projectAuditorWorkEvidence(head, assignment.callerCallId);
+        const state = projectAuditorInputState(head, assignment.callerCallId, objective.requestSteeringVersion, objective.criterionIds, source);
+        if (!state.available)
+            return failedAuditorAdvisory(assignment, state.reason);
         try {
-            const input = buildAuditorDecisionInput(context, ledger.current(), call);
-            const decision = await runAuditorDecision(context, input, {
-                call,
-                sourceRevision: ledger.current().revision,
-            });
-            const summary = JSON.stringify({
-                kind: "runtime_execution_agent_auditor_advisory_v1",
-                authority: "model_advisory",
-                presenceEffect: "passive_result_not_execution_or_completion",
-                ...decision,
-            });
-            if (summary.length > ROLE_CALL_RESULT_MAX_LENGTH) {
-                return failedAdvisory("auditor_result_not_admissible");
-            }
-            return Object.freeze({
-                kind: "terminal",
-                outcome: "completed",
-                summary,
+            const selectedIds = assignment.pendingEvidenceIds ??
+                (await invokeAuditorPhase(context, buildAuditorDecisionInput(context, assignment, "selection"), (text) => parseAuditorEvidenceSelection(text, assignment))).selectedEvidenceIds;
+            assignment = bindAuditorEvidence(assignment, source, selectedIds);
+            const decision = await invokeAuditorPhase(context, buildAuditorDecisionInput(context, assignment, "review"), (text) => parseAuditorDecisionOutput(text, assignment));
+            traceDebug("runtime.auditor", "review.completed", {
+                requestId: context.requestId,
+                callId: call.callId,
+                phase: "review",
+                workFingerprint: assignment.workFingerprint,
+                bundleFingerprint: fingerprintAuditorBundle(assignment.workFingerprint, selectedIds),
+                verdict: decision.verdict,
+                requestedEvidenceIds: decision.requestedEvidenceIds,
+                requestedEvidenceCount: decision.requestedEvidenceIds.length,
             });
+            return settleAuditorAdvisory(assignment, decision);
         }
         catch (error) {
-            if (error instanceof StructuredModelInvalidOutputError) {
-                return failedAdvisory("invalid_auditor_decision");
-            }
-            throw error;
+            const reason = auditorFailureReason(error);
+            if (!reason)
+                throw error;
+            traceDebug("runtime.auditor", "evidence.rejected", {
+                requestId: context.requestId,
+                callId: call.callId,
+                phase: assignment.selectedEvidenceIds.length > 0 ? "review" : "selection",
+                workFingerprint: assignment.workFingerprint,
+                selectedEvidenceCount: assignment.selectedEvidenceIds.length,
+                reason,
+            });
+            return failedAuditorAdvisory(assignment, reason);
         }
     },
 });
-async function runAuditorDecision(request, input, options) {
+async function invokeAuditorPhase(request, input, parse) {
+    traceDebug("runtime.auditor", "phase.started", {
+        requestId: request.requestId,
+        callId: input.assignment.auditId,
+        phase: input.phase,
+        workFingerprint: input.assignment.workFingerprint,
+        inventoryCount: input.assignment.inventory.length,
+        selectedEvidenceIds: input.assignment.selectedEvidenceIds,
+        selectedEvidenceCount: input.assignment.evidence.length,
+        selectedEvidenceChars: input.assignment.evidence.reduce((total, entry) => total +
+            JSON.stringify(projectAuditorEvidenceRepresentation(entry)).length, 0),
+        canonicalEvidenceChars: input.assignment.evidence.reduce((total, entry) => total + JSON.stringify(entry).length, 0),
+    });
     return invokeStructuredModelStep({
         request,
         modelStep: input.modelStep,
         format: input.format,
         messages: input.context.messages,
-        contextCompaction: createModelStepCompactionController(request, {
-            call: options.call,
-            sourceRevision: options.sourceRevision,
-            allowedConsumers: Object.freeze([AUDITOR_DECISION_MODEL_STEP]),
-        }),
         timeoutReason: "auditor_decision_timeout",
         invalidOutputReason: "invalid_auditor_decision",
-        parse: (text) => parseAuditorDecisionOutput(text, input.assignment),
+        parse,
     });
 }
-function failedAdvisory(reason) {
-    return Object.freeze({
-        kind: "terminal",
-        outcome: "failed",
-        summary: JSON.stringify({
-            kind: "runtime_execution_agent_auditor_advisory_v1",
-            authority: "runtime_validation",
-            presenceEffect: "passive_result_not_execution_or_completion",
-            outcome: "invalid",
-            reason,
-        }),
-    });
+function auditorFailureReason(error) {
+    if (error instanceof StructuredModelInvalidOutputError)
+        return "invalid_auditor_decision";
+    if (error instanceof AuditorEvidenceAdmissionError)
+        return error.message;
+    if (error instanceof AuditorAdvisoryCapacityError)
+        return error.message;
+    if (!(error instanceof Error))
+        return undefined;
+    if (error.message === "request_context_required_content_exceeds_budget")
+        return "auditor_exact_context_exceeds_budget";
+    if (error.message === "request_context_pinned_content_exceeds_budget")
+        return "auditor_exact_context_exceeds_budget";
+    if (error.message === "request_context_compaction_required")
+        return "auditor_exact_context_requires_compaction";
+    if (error.message === "request_context_final_envelope_exceeds_window")
+        return "auditor_exact_context_exceeds_budget";
+    if (error.message === "model_context_window_exceeded")
+        return "auditor_exact_context_exceeds_budget";
+    return undefined;
 }

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

@@ -1,4 +1,5 @@
 import type { MemoryRecallDecision } from "../memory-recall-decision.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";
 export declare const EXECUTION_AGENT_DECISION_MODEL_STEP: "execution.decision";
@@ -11,6 +12,7 @@ export declare const EXECUTION_AGENT_ACKNOWLEDGEMENT_MAX_LENGTH = 220;
 export declare const EXECUTION_AGENT_TITLE_MAX_LENGTH = 80;
 export declare const EXECUTION_AGENT_AUDIT_CRITERION_ID_MAX_LENGTH = 128;
 export declare const EXECUTION_AGENT_AUDIT_CRITERION_COUNT_MAX = 32;
+export declare const EXECUTION_AGENT_CAPABILITY_BATCH_COUNT_MAX = 64;
 export declare const EXECUTION_AGENT_CAPABILITY_SCOPE_GROUP_COUNT_MAX = 64;
 export type ExecutionAgentDecisionAction = (typeof EXECUTION_AGENT_DECISION_ACTIONS)[number];
 export type ExecutionAgentDecisionPresentation = Readonly<{
@@ -59,7 +61,10 @@ export type ExecutionAgentInvokeAuditorDecision = Readonly<ExecutionAgentDecisio
     action: "invoke_auditor";
     criterionIds: readonly string[];
 }>;
-export type ExecutionAgentDecision = MemoryRecallDecision | ExecutionAgentOpenCapabilityScopeDecision | ExecutionAgentExtendCapabilityScopeDecision | ExecutionAgentRespondDecision | ExecutionAgentBlockedDecision | ExecutionAgentInvokeCapabilityDecision | ExecutionAgentInvokeCapabilitiesDecision | ExecutionAgentInvokePlannerDecision | ExecutionAgentInvokeAuditorDecision;
+type ExecutionAgentAction = MemoryRecallDecision | ExecutionAgentOpenCapabilityScopeDecision | ExecutionAgentExtendCapabilityScopeDecision | ExecutionAgentRespondDecision | ExecutionAgentBlockedDecision | ExecutionAgentInvokeCapabilityDecision | ExecutionAgentInvokeCapabilitiesDecision | ExecutionAgentInvokePlannerDecision | ExecutionAgentInvokeAuditorDecision;
+export type ExecutionAgentDecision = ExecutionAgentAction & Readonly<{
+    workPlan?: ExecutionWorkPlanReport;
+}>;
 /** Runtime-only transition emitted when controls refinement exhausts validation. */
 export type ExecutionAgentReconsiderCapabilitySelectionDecision = Readonly<{
     action: "reconsider_capability_selection";
@@ -88,6 +93,7 @@ export type ExecutionAgentDecisionParseResult = Readonly<{
     issues: readonly ExecutionAgentDecisionValidationIssue[];
 }>;
 export type ExecutionAgentDecisionContractOptions = Readonly<{
+    workPlan?: ExecutionWorkPlanOptions;
     capabilities?: readonly CapabilityDescriptor[];
     capabilityCatalogGroupIds?: readonly string[];
     activeCapabilityCatalogGroupIds?: readonly string[] | null;
@@ -101,3 +107,4 @@ export type ExecutionAgentDecisionContractOptions = Readonly<{
     availableAuditCriterionIds?: readonly string[];
     includeWorkingDirectory?: boolean;
 }>;
+export {};

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

@@ -19,4 +19,6 @@ export const EXECUTION_AGENT_ACKNOWLEDGEMENT_MAX_LENGTH = 220;
 export const EXECUTION_AGENT_TITLE_MAX_LENGTH = 80;
 export const EXECUTION_AGENT_AUDIT_CRITERION_ID_MAX_LENGTH = 128;
 export const EXECUTION_AGENT_AUDIT_CRITERION_COUNT_MAX = 32;
+// Batch execution stays independently bounded as the available catalog grows.
+export const EXECUTION_AGENT_CAPABILITY_BATCH_COUNT_MAX = 64;
 export const EXECUTION_AGENT_CAPABILITY_SCOPE_GROUP_COUNT_MAX = CAPABILITY_CATALOG_GROUP_COUNT_MAX;

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

@@ -1,10 +1,14 @@
 import { readStructuredDecisionEnvelope } from "../../model/structured-decision-envelope.js";
+import { parseDecisionWithWorkPlan } from "./work-plan-decision-parsing.js";
 import { isMemoryRecallDecisionRecord, parseMemoryRecallDecision, } from "../memory-recall-decision.js";
 import { EXECUTION_AGENT_ACKNOWLEDGEMENT_MAX_LENGTH, EXECUTION_AGENT_TITLE_MAX_LENGTH, EXECUTION_AGENT_AUDIT_CRITERION_COUNT_MAX, EXECUTION_AGENT_AUDIT_CRITERION_ID_MAX_LENGTH, EXECUTION_AGENT_DECISION_ACTIONS, EXECUTION_AGENT_RESPONSE_MAX_LENGTH, } from "./contracts.js";
 import { prepareExecutionAgentDecisionContract } from "./format.js";
 import { parseCapabilityCatalogGroupIds, parseCapabilityBatch, parseCapabilityInvocation, parseWorkingDirectory, } from "./capability-decision-parsing.js";
 import { parsePresentation, presentationKeys, exactPresentationKeys, validateObjective, parseBoundedTextArray, validateBoundedText, readAction, exactKeys, rejectEnvelope, issue, asRecord, deepFreeze, } from "./decision-validation.js";
 export function parseExecutionAgentDecisionOutput(text, options = {}) {
+    return parseDecisionWithWorkPlan(text, options, parseExecutionAgentActionOutput);
+}
+function parseExecutionAgentActionOutput(text, options) {
     const contract = prepareExecutionAgentDecisionContract(options);
     let decoded;
     try {

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

@@ -1,8 +1,9 @@
 import { createMemoryRecallDecisionSchema } from "../memory-recall-decision.js";
+import { withExecutionWorkPlanVariants } from "./work-plan-contract.js";
 import { isToolCatalogGroupId } from "../../../capabilities/tool-types.js";
 import { createStructuredDecisionEnvelopeSchema } from "../../model/structured-decision-envelope.js";
 import { CAPABILITY_COUNT_MAX, CAPABILITY_INTENT_MAX_LENGTH, EXECUTION_WORKING_DIRECTORY_MAX_LENGTH, EXECUTION_WORKING_DIRECTORY_PATTERN, canOfferCapabilityBatchSelection, normalizeCapabilityDescriptor, normalizeCapabilityControlsSchema, partitionCapabilityControlsSchema, } 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_OBJECTIVE_MAX_LENGTH, EXECUTION_AGENT_RESPONSE_MAX_LENGTH, EXECUTION_AGENT_TITLE_MAX_LENGTH, } from "./contracts.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 { executionOperationObjectiveSchema, requiresExecutionOperationObjective, } from "./capability-invocation-contract.js";
 export function createExecutionAgentDecisionFormat(options = {}) {
     const contract = prepareExecutionAgentDecisionContract(options);
@@ -115,7 +116,7 @@ export function createExecutionAgentDecisionFormat(options = {}) {
             ]
             : []),
     ];
-    const schema = createStructuredDecisionEnvelopeSchema(variants);
+    const schema = createStructuredDecisionEnvelopeSchema(withExecutionWorkPlanVariants(variants, options.workPlan));
     return {
         type: "json_schema",
         name: "execution_agent_decision",
@@ -181,7 +182,7 @@ export function prepareExecutionAgentDecisionContract(options) {
         uniqueIds.size !== suppliedCapabilities.length ||
         !Number.isInteger(maxBatchCapabilityExecutions) ||
         maxBatchCapabilityExecutions < 0 ||
-        maxBatchCapabilityExecutions > CAPABILITY_COUNT_MAX) {
+        maxBatchCapabilityExecutions > EXECUTION_AGENT_CAPABILITY_BATCH_COUNT_MAX) {
         throw new Error("execution_agent_capabilities_invalid");
     }
     const capabilities = Object.freeze(suppliedCapabilities.map((capability) => {

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

@@ -6,12 +6,13 @@ import { buildRequestTemporalContextMessage } from "../../context/request-tempor
 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 { CAPABILITY_COUNT_MAX, projectCapabilityCatalogGroups, projectCapabilityScope, } from "../../orchestration/capability-adapters/index.js";
+import { projectCapabilityCatalogGroups, projectCapabilityScope, } from "../../orchestration/capability-adapters/index.js";
 import { resolveRequestWorkerCapabilities, } from "../../request/execution-scope.js";
 import { appendRequestSteeringContext } from "../../request/request-steering-context.js";
-import { EXECUTION_AGENT_ROOT_AUDIT_CRITERION_ID } from "../auditor-decision/index.js";
-import { EXECUTION_AGENT_DECISION_MODEL_STEP, } from "./contracts.js";
+import { EXECUTION_AGENT_ROOT_AUDIT_CRITERION_ID, projectAuditorInputState, } from "../auditor-decision/index.js";
+import { EXECUTION_AGENT_CAPABILITY_BATCH_COUNT_MAX, EXECUTION_AGENT_DECISION_MODEL_STEP, } from "./contracts.js";
 import { createExecutionAgentDecisionFormat } from "./format.js";
+import { projectExecutionWorkPlanOptions } from "./work-plan-sources.js";
 import { buildExecutionAgentInstructions } from "./prompt.js";
 import { buildExecutionCapabilityCatalogMessage, buildExecutionCapabilityGroupCatalogMessage, buildExecutionContinuationMessages, buildExecutionDecisionStateMessage, } from "./state-context.js";
 export function buildExecutionAgentInput(request, options) {
@@ -40,19 +41,16 @@ export function buildExecutionAgentInput(request, options) {
             : hasInactiveGroup
                 ? "extend"
                 : null;
-    const hasCurrentEvidence = options.head.state.capabilityExecutions.some((execution) => execution.callId === options.call.callId &&
-        execution.status === "settled") ||
-        options.head.state.results.some((result) => {
-            const producer = options.head.state.calls.find((candidate) => candidate.callId === result.producerCallId);
-            return producer?.parentCallId === options.call.callId;
-        });
-    const availableAuditCriterionIds = options.allowAuditor && hasCurrentEvidence
+    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])
         : Object.freeze([]);
     const memoryRecallMessage = request.longTermMemory?.enabled
         ? options.memoryRecallMessage
         : undefined;
+    const workPlan = projectExecutionWorkPlanOptions(options.head, options.call);
     const contract = Object.freeze({
+        ...(workPlan ? { workPlan } : {}),
         allowMemoryRecall: canOfferMemoryRecall({
             enabled: request.longTermMemory?.enabled === true,
             recallCount: options.head.state.memoryRecalls.length,
@@ -61,7 +59,7 @@ export function buildExecutionAgentInput(request, options) {
         capabilities,
         capabilityCatalogGroupIds: knownGroupIds,
         activeCapabilityCatalogGroupIds,
-        maxBatchCapabilityExecutions: Math.min(CAPABILITY_COUNT_MAX, Math.max(0, remainingExecutions)),
+        maxBatchCapabilityExecutions: Math.min(EXECUTION_AGENT_CAPABILITY_BATCH_COUNT_MAX, Math.max(0, remainingExecutions)),
         includeAcknowledgement: options.includeAcknowledgement,
         includeTitle: options.includeTitle,
         allowRespond: true,
@@ -72,6 +70,7 @@ export function buildExecutionAgentInput(request, options) {
     });
     const format = createExecutionAgentDecisionFormat(contract);
     const instructions = buildExecutionAgentInstructions({
+        allowWorkPlan: workPlan !== undefined,
         allowMemoryRecall: contract.allowMemoryRecall,
         hasMemoryRecallContext: memoryRecallMessage !== undefined,
         hasCapabilities: capabilities.length > 0,

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

@@ -3,6 +3,7 @@ export declare function buildExecutionAgentInstructions(params: {
     hasCapabilityCatalogGroups: boolean;
     capabilityScopeAction: "open" | "extend" | null;
     allowPlanner: boolean;
+    allowWorkPlan?: boolean;
     availableAuditCriterionCount: number;
     allowRespond: boolean;
     allowMemoryRecall?: boolean;

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

@@ -23,7 +23,8 @@ export function buildExecutionAgentInstructions(params) {
             ? "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."
             : "Respond is not available because the canonical completion gate is closed. Continue through an offered action or report a truthful blocker.",
         "The user's explicit request is already the authority to perform the offered action within its stated scope. Treat 'can you', 'could you', 'would you', and equivalent phrasing in any language followed by an action as a request to perform that action, not as a request for another confirmation. Do not ask for confirmation merely because an offered capability has an external effect; the runtime enforces any approval that is actually required.",
-        "Before changing an existing resource, establish from the active user request and user-established context both the intended target and the permitted scope of change. Discovering, reading, or having access to a resource does not authorize selecting it as the target. For a creation request, create a new resource without damaging existing resources. When the target and scope are already clear and authorized, proceed without asking for confirmation again.",
+        "Before changing an existing resource, establish from the active user request and user-established context both the intended target and the permitted scope of change. A selected project folder or working directory defines the execution location, not permission to repurpose an existing application discovered there. Discovery, accessible source files, related functionality, and similar names do not establish the user's intended mutation target. When an existing target and update scope are explicitly authorized, proceed without duplicate confirmation.",
+        "For a requested new application or project without an explicitly selected existing target, choose a separate new destination within the allowed working root and observe that it is unoccupied before writing. Preserve unrelated existing applications. If read-only observation leaves the user's intended target or reuse permission ambiguous, ask one focused question before mutation. An established immutable working directory does not select the application: use explicit paths relative to that base for the authorized destination.",
         "Use blocked for a truthful user-facing blocker when no offered action can establish the missing outcome, or when material ambiguity about the intended target or permitted scope of any change to an existing resource requires user clarification. If an offered read-only observation can resolve the ambiguity, perform it before asking. If the ambiguity remains, stop before mutation and put one focused clarification question in blocked.response. Availability of a mutation capability does not resolve missing user intent. Runtime or provider failures are not blocked decisions.",
         params.hasCapabilities
             ? `When external observation or an authorized effect is required, select one offered capability and provide a short client-facing status in intent, at most ${CAPABILITY_INTENT_MAX_LENGTH} characters. Intent is presentation metadata only: do not put sources, controls, payload details, or execution instructions in it. When the invocation schema requires operationObjective, state the complete bounded operation for that invocation alone. operationObjective is internal execution input constrained by the active user request and selected capability; it must not add unrelated outcomes, describe the whole workflow, or broaden the request. Observation capabilities may be batched only when independent; never batch mutations. The runtime determines exact duplicate operations only after every invocation is fully materialized. A capability receipt proves only its exact reported outcome.`
@@ -36,11 +37,17 @@ export function buildExecutionAgentInstructions(params) {
         "Immediately before choosing respond, verify that no requested external effect remains without a successful visible capability result or a completed subordinate result that explicitly establishes it. Never use respond to ask permission for a reversible file creation or update that the user explicitly requested.",
         "Never claim that a file was read, compared, created, changed, or verified unless the exact visible capability results establish that claim.",
         params.allowPlanner
-            ? "Invoke Planner only when the request truly has both at least two independently accepted terminal deliverables and a real parallel frontier, and every planned node can ultimately be established by a capability represented in the offered catalog groups and a successful capability receipt. A dependency or integration edge alone is insufficient. Planner is advisory and cannot execute."
+            ? "Prefer the advisory Planner before substantial development that requires coordinated implementation and verification, dependency ordering, or integration. A single integrated deliverable and genuinely sequential steps are eligible; do not manufacture parallel work or extra deliverables. Skip planning overhead for a direct question or a simple isolated change. Every planned external outcome must be achievable through the offered capability catalog. Planner cannot execute; you own execution decisions and may use or refine its advice."
             : "Planner is not available in this decision.",
+        ...(params.allowWorkPlan
+            ? [
+                "When you follow a returned Planner proposal, explicitly adopt its offered sourceResultRef using workPlan metadata alongside an existing decision, then keep its item statuses current. Use mode adopt to select a proposal and mode progress to update the currently adopted proposal; itemUpdates name exact offered itemIds and pending, in_progress, done, or blocked. The runtime_execution_state_v1 workPlan projection records available proposal identities and your current model-reported progress. It is passive state, not new user intent or proof of completion.",
+                "Plan reporting adds no separate action or model turn. Mark an item in_progress when starting work; report done only when already established outcomes satisfy that item's actual acceptance criteria, never in anticipation of the paired operation succeeding. Syntax checks, file existence, and written test instructions do not establish functional, interaction, or persistence tests. Keep unperformed verification pending or report its concrete blocker; disclose it when handing over. Planner/Auditor results, an attempted tool call, and choosing respond do not complete plan items automatically. A plan report cannot authorize an effect or establish tool evidence.",
+            ]
+            : []),
         params.availableAuditCriterionCount > 0
-            ? "Invoke Auditor only for one or more offered unresolved semantic criterionIds. The runtime selects their exact current evidence. Auditor cannot remediate or answer."
-            : "No unresolved semantic audit criterion is offered. Do not invoke Auditor.",
+            ? "For substantial development, prefer one independent completion audit after implementation and the available planned validation are ready for delivery. Do not audit after every intermediate edit or newly settled result merely because an audit is offered. An earlier targeted audit is appropriate when the user requests it or its findings can materially change the next implementation decision. Invoke only offered criterionIds. The Auditor chooses original evidence from the complete canonical work inventory; the runtime binds its choices without choosing relevance. A needs_evidence receipt requests another existing evidence bundle: invoke the offered criteria again to supply that Auditor-selected bundle, without repeating external actions merely to reread it. For gaps, address the concrete findings or obtain genuinely missing observations before another audit. Unchanged finished audits are not offered again. Auditor cannot remediate or answer; you retain the next-action decision."
+            : "No audit is offered for this work snapshot. The passive auditAvailability reason explains work-evidence eligibility but cannot grant a role absent from the decision schema. Do not repeat a finished audit or treat its absence as proof of completion.",
         "Do not invent a hidden child, fallback route, capability result, audit result, or plan completion.",
         params.includeAcknowledgement
             ? "Also return one concise acknowledgement in the user's language. It describes the understood outcome without claiming work already occurred."

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

@@ -1,5 +1,7 @@
 import { projectImmediateRoleOperationSupervisionNotices } from "../../orchestration/role-calls/index.js";
 import { projectImmediateCapabilityReconsideration } from "./reconsideration-context.js";
+import { projectAuditorInputState } from "../auditor-decision/audit-input-state.js";
+import { projectExecutionWorkPlanContext } from "./work-plan-sources.js";
 export const EXECUTION_STATE_MESSAGE_KIND = "runtime_execution_state_v1";
 export const EXECUTION_CAPABILITY_CATALOG_MESSAGE_KIND = "runtime_execution_capability_catalog_v1";
 export const EXECUTION_CAPABILITY_GROUP_CATALOG_MESSAGE_KIND = "runtime_execution_capability_group_catalog_v1";
@@ -43,8 +45,16 @@ function buildExecutionStateMessageForConsumer(head, call, projection, steeringV
             stateRevision: head.revision,
             callId: call.callId,
             activationCount: call.activationCount,
+            ...(steeringVersion !== undefined
+                ? { workPlan: projectExecutionWorkPlanContext(head, call) }
+                : {}),
             workingDirectory: call.workingDirectory ?? null,
             activeCapabilityScope: call.workerCapabilityScope ?? null,
+            ...(steeringVersion !== undefined
+                ? {
+                    auditAvailability: projectAuditorInputState(head, call.callId, steeringVersion),
+                }
+                : {}),
             settledCapabilityExecutionCount: head.state.capabilityExecutions.filter((execution) => execution.callId === call.callId && execution.status === "settled").length,
             completedSubordinateResults: head.state.results
                 .filter((result) => {

package/dist/src/runtime/steps/execution-agent/work-plan-contract.d.ts

@@ -0,0 +1,18 @@
+import { type ModelWorkPlanItemUpdate } from "../../orchestration/role-calls/work-plan-contracts.js";
+export type ExecutionWorkPlanReport = Readonly<{
+    mode: "adopt" | "progress";
+    sourceResultRef: string;
+    itemUpdates: readonly ModelWorkPlanItemUpdate[];
+}>;
+export type ExecutionWorkPlanSource = Readonly<{
+    sourceResultRef: string;
+    itemIds: readonly string[];
+}>;
+export type ExecutionWorkPlanOptions = Readonly<{
+    sources: readonly ExecutionWorkPlanSource[];
+    current?: ExecutionWorkPlanSource;
+}>;
+/** Parse only offered canonical identities. The model cannot author a new definition here. */
+export declare function parseExecutionWorkPlanReport(value: unknown, options?: ExecutionWorkPlanOptions): ExecutionWorkPlanReport | undefined;
+/** Optional metadata uses explicit schema variants; existing variants stay byte-for-byte available. */
+export declare function withExecutionWorkPlanVariants(variants: readonly Record<string, unknown>[], options?: ExecutionWorkPlanOptions): readonly Record<string, unknown>[];

package/dist/src/runtime/steps/execution-agent/work-plan-contract.js

@@ -0,0 +1,86 @@
+import { exactKeys, isRecord } from "../../validation/strict-record.js";
+import { MODEL_WORK_PLAN_ITEM_LIMIT, MODEL_WORK_PLAN_STATUSES, } from "../../orchestration/role-calls/work-plan-contracts.js";
+import { parseModelWorkPlanItemUpdates } from "../../orchestration/role-calls/work-plan-validation.js";
+/** Parse only offered canonical identities. The model cannot author a new definition here. */
+export function parseExecutionWorkPlanReport(value, options) {
+    if (!options || !isRecord(value))
+        return undefined;
+    if (!exactKeys(value, ["mode", "sourceResultRef"], ["itemUpdates"]))
+        return undefined;
+    if (value.mode !== "adopt" && value.mode !== "progress")
+        return undefined;
+    const source = resolveOfferedWorkPlanSource(value.mode, value.sourceResultRef, options);
+    if (!source)
+        return undefined;
+    const itemUpdates = parseModelWorkPlanItemUpdates(value.itemUpdates ?? []);
+    if (!itemUpdates || (value.mode === "progress" && itemUpdates.length === 0))
+        return undefined;
+    if (itemUpdates.some((item) => !source.itemIds.includes(item.itemId)))
+        return undefined;
+    return {
+        mode: value.mode,
+        sourceResultRef: source.sourceResultRef,
+        itemUpdates,
+    };
+}
+function resolveOfferedWorkPlanSource(mode, sourceResultRef, options) {
+    if (mode === "adopt")
+        return options.sources.find((candidate) => candidate.sourceResultRef === sourceResultRef);
+    if (options.current?.sourceResultRef !== sourceResultRef)
+        return undefined;
+    return options.current;
+}
+/** Optional metadata uses explicit schema variants; existing variants stay byte-for-byte available. */
+export function withExecutionWorkPlanVariants(variants, options) {
+    const reports = createReportSchemas(options);
+    if (reports.length === 0)
+        return variants;
+    return variants.flatMap((variant) => [
+        variant,
+        {
+            ...variant,
+            properties: {
+                ...variant.properties,
+                workPlan: { anyOf: reports },
+            },
+            required: [...variant.required, "workPlan"],
+        },
+    ]);
+}
+function createReportSchemas(options) {
+    if (!options)
+        return [];
+    const schemas = options.sources.map((source) => reportSchema("adopt", source));
+    if (options.current)
+        schemas.push(reportSchema("progress", options.current));
+    return schemas;
+}
+function reportSchema(mode, source) {
+    const itemIds = [...new Set(source.itemIds)];
+    return {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            mode: { type: "string", enum: [mode] },
+            sourceResultRef: {
+                type: "string",
+                enum: [source.sourceResultRef],
+            },
+            itemUpdates: {
+                type: "array",
+                minItems: mode === "progress" ? 1 : 0,
+                maxItems: MODEL_WORK_PLAN_ITEM_LIMIT,
+                items: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        itemId: { type: "string", enum: itemIds },
+                        status: { type: "string", enum: [...MODEL_WORK_PLAN_STATUSES] },
+                    },
+                    required: ["itemId", "status"],
+                },
+            },
+        },
+        required: ["mode", "sourceResultRef", "itemUpdates"],
+    };
+}

package/dist/src/runtime/steps/execution-agent/work-plan-decision-parsing.d.ts

@@ -0,0 +1,2 @@
+import type { ExecutionAgentDecisionContractOptions, ExecutionAgentDecisionParseResult } from "./contracts.js";
+export declare function parseDecisionWithWorkPlan(text: string, options: ExecutionAgentDecisionContractOptions, parseAction: (text: string, options: ExecutionAgentDecisionContractOptions) => ExecutionAgentDecisionParseResult): ExecutionAgentDecisionParseResult;

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

@@ -0,0 +1,38 @@
+import { readStructuredDecisionEnvelope } from "../../model/structured-decision-envelope.js";
+import { parseExecutionWorkPlanReport } from "./work-plan-contract.js";
+export function parseDecisionWithWorkPlan(text, options, parseAction) {
+    let value;
+    try {
+        value = JSON.parse(text.trim());
+    }
+    catch {
+        return parseAction(text, options);
+    }
+    const record = readStructuredDecisionEnvelope(value);
+    if (!record || !Object.hasOwn(record, "workPlan"))
+        return parseAction(text, options);
+    const workPlan = parseExecutionWorkPlanReport(record.workPlan, options.workPlan);
+    if (!workPlan)
+        return {
+            ok: false,
+            stage: "domain_parser",
+            issues: [
+                {
+                    code: "execution_agent_work_plan_invalid",
+                    path: "decision.workPlan",
+                    message: "workPlan must adopt an offered Planner result or update known items of the currently adopted plan.",
+                },
+            ],
+        };
+    const { workPlan: _report, ...action } = record;
+    const parsed = parseAction(JSON.stringify({ decision: action }), options);
+    if (!parsed.ok)
+        return parsed;
+    return {
+        ok: true,
+        decision: Object.freeze({
+            ...parsed.decision,
+            workPlan: Object.freeze(workPlan),
+        }),
+    };
+}

package/dist/src/runtime/steps/execution-agent/work-plan-sources.d.ts

@@ -0,0 +1,6 @@
+import type { RoleCallFrame, RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
+import type { ModelWorkPlanDefinition } from "../../orchestration/role-calls/work-plan-contracts.js";
+import type { ExecutionWorkPlanOptions } from "./work-plan-contract.js";
+export declare function resolveExecutionWorkPlanDefinition(head: RoleCallLedgerHead, call: RoleCallFrame, sourceResultRef: string): ModelWorkPlanDefinition | undefined;
+export declare function projectExecutionWorkPlanOptions(head: RoleCallLedgerHead, call: RoleCallFrame): ExecutionWorkPlanOptions | undefined;
+export declare function projectExecutionWorkPlanContext(head: RoleCallLedgerHead, call: RoleCallFrame): Record<string, unknown> | undefined;

package/dist/src/runtime/steps/execution-agent/work-plan-sources.js

@@ -0,0 +1,54 @@
+import { resolveModelWorkPlanSourceDefinition } from "../../orchestration/role-calls/work-plan-source.js";
+export function resolveExecutionWorkPlanDefinition(head, call, sourceResultRef) {
+    return resolveModelWorkPlanSourceDefinition(head.state, call, sourceResultRef, head.policy);
+}
+export function projectExecutionWorkPlanOptions(head, call) {
+    if (head.policy.authority.modelWorkPlanAuthority !== "root")
+        return undefined;
+    const sources = head.state.results.flatMap((result) => {
+        const definition = resolveExecutionWorkPlanDefinition(head, call, result.resultRef);
+        return definition
+            ? [
+                {
+                    sourceResultRef: result.resultRef,
+                    itemIds: definition.items.map((item) => item.itemId),
+                },
+            ]
+            : [];
+    });
+    const plan = call.adoptedWorkPlan;
+    if (sources.length === 0 && !plan)
+        return undefined;
+    return {
+        sources,
+        ...(plan
+            ? {
+                current: {
+                    sourceResultRef: plan.sourceResultRef,
+                    itemIds: plan.definition.items.map((item) => item.itemId),
+                },
+            }
+            : {}),
+    };
+}
+export function projectExecutionWorkPlanContext(head, call) {
+    const options = projectExecutionWorkPlanOptions(head, call);
+    if (!options)
+        return undefined;
+    const plan = call.adoptedWorkPlan;
+    return {
+        authority: "model_reported_progress_not_completion_evidence",
+        availableProposals: options.sources,
+        ...(plan
+            ? {
+                adopted: {
+                    sourceResultRef: plan.sourceResultRef,
+                    items: plan.itemStates.map((item) => ({
+                        itemId: item.itemId,
+                        status: item.status,
+                    })),
+                },
+            }
+            : {}),
+    };
+}