eve 0.37.0 → 0.37.1

package/dist/src/execution/subagent-hitl-proxy.js

@@ -1 +1 @@
-import{createInputRequestedEvent}from"#protocol/message.js";import{emitTurnEpilogue,getHarnessEmissionState,setHarnessEmissionState}from"#harness/emission.js";import{getProxyInputRequests,toProxyInputRequestEntries}from"#harness/proxy-input-requests.js";import{SESSION_LIMIT_STOP_OPTION_ID}from"#harness/session-limit-continuation.js";async function emitProxiedInputRequest(i){await i.emit(createInputRequestedEvent({requests:i.hookPayload.event.requests,sequence:i.hookPayload.event.sequence,stepIndex:i.hookPayload.event.stepIndex,turnId:i.hookPayload.event.turnId}));let o=i.session;if(i.mode===`conversation`){let e=getHarnessEmissionState(i.session.state),a=await emitTurnEpilogue(i.emit,e,i.mode);o=setHarnessEmissionState(i.session,a)}return{entries:toProxyInputRequestEntries(i.hookPayload),session:o}}function routeDeliverPayload(e){let t=getProxyInputRequests(e.state),n=e.payload.inputResponses??[],r=new Map,a=[],s;for(let e of n){let n=t.get(e.requestId);if(n===void 0){a.push(e);continue}n.kind===`session-limit`&&e.optionId===SESSION_LIMIT_STOP_OPTION_ID&&(s={kind:`cancel-turn`});let i=r.get(n.childContinuationToken);i===void 0?r.set(n.childContinuationToken,{responses:[e],routes:[n]}):(i.responses.push(e),i.routes.push(n))}let c=[...r.entries()].map(([e,n])=>{let r=new Set(n.responses.map(e=>e.requestId)),i=new Set(r);for(let a of n.routes)if(a.batch!==void 0&&batchResolves({batch:a.batch,childContinuationToken:e,entries:t,responseIds:r}))for(let e of a.batch.requestIds)i.add(e);return{childContinuationToken:e,payload:{inputResponses:n.responses},retireRequestIds:[...i]}}),l={};for(let[t,n]of Object.entries(e.payload))t===`inputResponses`||n===void 0||(l[t]=n);return a.length>0&&(l.inputResponses=a),{forChildren:c,forSelf:Object.keys(l).length>0?l:void 0,parentAction:s}}function batchResolves(e){return e.batch.approvalRequestIds.length===0||e.batch.approvalRequestIds.every(t=>{let n=e.entries.get(t);return n===void 0||!sameBatch(n,e)||e.responseIds.has(t)})}function sameBatch(e,t){return e.childContinuationToken===t.childContinuationToken&&e.batch?.requestIds.length===t.batch.requestIds.length&&e.batch.requestIds.every((e,n)=>e===t.batch.requestIds[n])}export{emitProxiedInputRequest,routeDeliverPayload};
+import{createInputRequestedEvent}from"#protocol/message.js";import{emitTurnEpilogue,getHarnessEmissionState,setHarnessEmissionState}from"#harness/emission.js";import{getProxyInputRequests,toProxyInputRequestEntries}from"#harness/proxy-input-requests.js";import{SESSION_LIMIT_STOP_OPTION_ID}from"#harness/session-limit-continuation.js";async function emitProxiedInputRequest(i){await i.emit(createInputRequestedEvent({requests:i.hookPayload.event.requests,sequence:i.hookPayload.event.sequence,stepIndex:i.hookPayload.event.stepIndex,turnId:i.hookPayload.event.turnId}));let o=i.session;if(i.mode===`conversation`){let e=getHarnessEmissionState(i.session.state),a=await emitTurnEpilogue(i.emit,e,i.mode);o=setHarnessEmissionState(i.session,a)}return{entries:toProxyInputRequestEntries(i.hookPayload),session:o}}function routeDeliverPayload(e){let t=getProxyInputRequests(e.state),n=e.payload.inputResponses??[],r=new Map,a=[],s;for(let i of n){let n=t.get(i.requestId);if(n===void 0||e.allowRoute?.(i.requestId,n)===!1){a.push(i);continue}n.kind===`session-limit`&&i.optionId===SESSION_LIMIT_STOP_OPTION_ID&&(s={kind:`cancel-turn`});let c=n.taskId===void 0?n.childContinuationToken:`${n.childContinuationToken}\0${n.childResponseUrl??`local`}\0${n.taskId}`,l=r.get(c);l===void 0?r.set(c,{childContinuationToken:n.childContinuationToken,parentRequestIds:[i.requestId],responses:[toChildInputResponse(i,n)],routes:[n],...n.childResponseUrl!==void 0&&{childResponseUrl:n.childResponseUrl},...n.taskId!==void 0&&{taskId:n.taskId}}):(l.parentRequestIds.push(i.requestId),l.responses.push(toChildInputResponse(i,n)),l.routes.push(n))}let c=[...r.values()].map(({childContinuationToken:e,childResponseUrl:n,parentRequestIds:r,responses:i,routes:a,taskId:o})=>{let s=new Set(r),c=new Set(s);for(let n of a)if(n.batch!==void 0&&batchResolves({batch:n.batch,childContinuationToken:e,entries:t,responseIds:s}))for(let e of n.batch.requestIds)c.add(e);return{childContinuationToken:e,payload:{inputResponses:i},retireRequestIds:[...c],...n!==void 0&&{childResponseUrl:n},...o!==void 0&&{taskId:o}}}),l={};for(let[t,n]of Object.entries(e.payload))t===`inputResponses`||n===void 0||(l[t]=n);return a.length>0&&(l.inputResponses=a),{forChildren:c,forSelf:Object.keys(l).length>0?l:void 0,parentAction:s}}function batchResolves(e){return e.batch.approvalRequestIds.length===0||e.batch.approvalRequestIds.every(t=>{let n=e.entries.get(t);return n===void 0||!sameBatch(n,e)||e.responseIds.has(t)})}function sameBatch(e,t){return e.childContinuationToken===t.childContinuationToken&&e.batch?.requestIds.length===t.batch.requestIds.length&&e.batch.requestIds.every((e,n)=>e===t.batch.requestIds[n])}function toChildInputResponse(e,t){return t.childRequestId===void 0?e:{...e,requestId:t.childRequestId}}export{emitProxiedInputRequest,routeDeliverPayload};

package/dist/src/execution/subagent-start-local.d.ts

@@ -0,0 +1,29 @@
+import type { DispatchOutcome, RuntimeSession } from "#execution/agent-handle-dispatch.js";
+import { buildSubagentRunInput, type SubagentInputSource } from "#execution/subagent-tool.js";
+import { createWorkflowRuntime } from "#execution/workflow-runtime.js";
+import type { RuntimeSubagentCallActionRequest } from "#runtime/actions/types.js";
+import type { CompiledBundle } from "#runtime/sessions/runtime-context-keys.js";
+type DynamicSubagentAgentConfig = Parameters<typeof createWorkflowRuntime>[0]["dynamicSubagentAgentConfig"];
+/** Starts one local subagent after dispatch planning has selected its target. */
+export declare function startLocalSubagent(input: {
+    readonly action: RuntimeSubagentCallActionRequest;
+    readonly auth: Parameters<typeof buildSubagentRunInput>[0]["auth"];
+    readonly batchEvent: {
+        readonly sequence: number;
+        readonly turnId: string;
+    };
+    readonly bundle: CompiledBundle;
+    readonly capabilities: Parameters<typeof buildSubagentRunInput>[0]["capabilities"];
+    readonly channelMetadata: Parameters<typeof buildSubagentRunInput>[0]["channelMetadata"];
+    readonly currentSession: RuntimeSession;
+    readonly dynamicSubagentAgentConfig?: DynamicSubagentAgentConfig;
+    readonly fanoutSize: number;
+    readonly initiatorAuth: Parameters<typeof buildSubagentRunInput>[0]["initiatorAuth"];
+    readonly parentContinuationToken: string | undefined;
+    readonly parentTraceContext: Parameters<typeof buildSubagentRunInput>[0]["parentTraceContext"];
+    readonly persistentSessions: boolean;
+    readonly session: RuntimeSession;
+    readonly source: SubagentInputSource;
+    readonly taskOwned: boolean;
+}): Promise<DispatchOutcome>;
+export {};

package/dist/src/execution/subagent-start-local.js

@@ -0,0 +1 @@
+import{createLogger,logError}from"#internal/logging.js";import{isRuntimeSessionOwnershipConflictError}from"#execution/runtime-errors.js";import{toErrorMessage}from"#shared/errors.js";import{SUBAGENT_START_FAILED}from"#harness/agent-handle-errors.js";import{confirmAgentStarted,confirmTaskAgentAddress,prepareAgentStart,rejectAgentEffect}from"#harness/handles/transitions.js";import{createWorkflowRuntime}from"#execution/workflow-runtime.js";import{buildSubagentRunInput}from"#execution/subagent-tool.js";import{mintStartOperation}from"#execution/dispatch-start-operation.js";const log=createLogger(`execution.subagent-start-local`);async function startLocalSubagent(e){let{action:t,source:n}=e,r=createWorkflowRuntime({compiledArtifactsSource:e.bundle.compiledArtifactsSource,dynamicSubagentAgentConfig:e.dynamicSubagentAgentConfig,nodeId:t.nodeId}),{childContinuationToken:i,runInput:a}=buildSubagentRunInput({action:t,auth:e.auth,batchEvent:e.batchEvent,capabilities:e.capabilities,channelMetadata:e.channelMetadata,fanoutSize:e.fanoutSize,initiatorAuth:e.initiatorAuth,parentContinuationToken:e.parentContinuationToken,parentTraceContext:e.parentTraceContext,persistentSessions:e.persistentSessions,session:e.session,source:n}),o=n.type===`runtime`?`agent/self`:`agent/local`,{identity:s,operation:c}=mintStartOperation({callId:t.callId,name:t.subagentName,nodeId:t.nodeId,parentSessionId:e.session.sessionId,parentTurnId:e.batchEvent.turnId}),l=prepareAgentStart(e.currentSession,{identity:s,operation:c,target:{continuationToken:i,kind:o}}),u;try{u=(await r.createSession(a)).sessionId}catch(e){if(!isRuntimeSessionOwnershipConflictError(e))return logError(log,`local subagent start failed`,e,{callId:t.callId,nodeId:t.nodeId,subagentName:t.subagentName}),{kind:`error`,result:{callId:t.callId,isError:!0,kind:`subagent-result`,origin:`dispatch`,output:{code:SUBAGENT_START_FAILED,message:toErrorMessage(e)},subagentName:t.subagentName},session:rejectAgentEffect(l,{disposition:`dead`,operationId:c.id})};u=e.ownerSessionId}let d={continuationToken:i,kind:o,sessionId:u};return{address:d,callId:t.callId,kind:`called`,name:t.name,session:e.taskOwned?confirmTaskAgentAddress(l,{address:d,operationId:c.id}):confirmAgentStarted(l,{address:d,operationId:c.id}),toolName:t.subagentName}}export{startLocalSubagent};

package/dist/src/execution/subagent-start-remote.d.ts

@@ -0,0 +1,23 @@
+import type { DispatchOutcome, RuntimeSession } from "#execution/agent-handle-dispatch.js";
+import { resolveRemoteAgentForAction, startRemoteAgentSession } from "#execution/remote-agent-dispatch.js";
+import type { RuntimeRemoteAgentCallActionRequest } from "#runtime/actions/types.js";
+import type { CompiledBundle } from "#runtime/sessions/runtime-context-keys.js";
+/** Starts one remote subagent after dispatch planning has selected its target. */
+export declare function startRemoteSubagent(input: {
+    readonly action: RuntimeRemoteAgentCallActionRequest;
+    readonly auth: Parameters<typeof startRemoteAgentSession>[0]["auth"];
+    readonly batchEvent: {
+        readonly sequence: number;
+        readonly turnId: string;
+    };
+    readonly bundle: CompiledBundle;
+    readonly callbackBaseUrl: string | undefined;
+    readonly currentSession: RuntimeSession;
+    readonly dynamicRemoteAgent?: NonNullable<Parameters<typeof resolveRemoteAgentForAction>[0]["dynamicRemoteAgent"]>;
+    readonly initiatorAuth: Parameters<typeof startRemoteAgentSession>[0]["initiatorAuth"];
+    readonly parentContinuationToken: string | undefined;
+    readonly parentTraceContext: Parameters<typeof startRemoteAgentSession>[0]["parentTraceContext"];
+    readonly persistentSessions: boolean;
+    readonly session: RuntimeSession;
+    readonly taskOwned: boolean;
+}): Promise<DispatchOutcome>;

package/dist/src/execution/subagent-start-remote.js

@@ -0,0 +1 @@
+import{createLogger,logError}from"#internal/logging.js";import{resolveRemoteAgentForAction,startRemoteAgentSession}from"#execution/remote-agent-dispatch.js";import{confirmAgentStarted,confirmTaskAgentAddress,prepareAgentStart,rejectAgentEffect}from"#harness/handles/transitions.js";import{createRemoteAgentStartFailureResult}from"#execution/dispatch-action-failures.js";import{mintStartOperation}from"#execution/dispatch-start-operation.js";const log=createLogger(`execution.subagent-start-remote`);async function startRemoteSubagent(e){let{action:r}=e,i,a;try{if(e.callbackBaseUrl===void 0)throw Error(`Cannot dispatch remote agent without a callback base URL.`);i=e.callbackBaseUrl,a=resolveRemoteAgentForAction({dynamicRemoteAgent:e.dynamicRemoteAgent,nodeId:r.nodeId,remoteAgentName:r.remoteAgentName,registry:e.bundle.subagentRegistry.subagentsByNodeId})}catch(n){return logError(log,`remote agent start failed`,n,{remoteAgentName:r.remoteAgentName,nodeId:r.nodeId,callId:r.callId}),{kind:`error`,result:createRemoteAgentStartFailureResult({action:r,error:n}),session:e.currentSession}}let{identity:o,operation:s}=mintStartOperation({callId:r.callId,name:r.remoteAgentName,nodeId:r.nodeId,parentSessionId:e.session.sessionId,parentTurnId:e.batchEvent.turnId}),c=prepareAgentStart(e.currentSession,{identity:o,operation:s,target:{callbackBaseUrl:i,kind:`agent/remote`,url:a.url}});try{let t=await startRemoteAgentSession({action:r,auth:e.auth,callbackBaseUrl:i,callbackToken:e.parentContinuationToken,initiatorAuth:e.initiatorAuth,operationId:s.id,parentTraceContext:e.parentTraceContext,persistentSessions:e.persistentSessions,remote:a,session:e.session}),n={callbackBaseUrl:i,kind:`agent/remote`,sessionId:t.sessionId,url:a.url};return{address:n,callId:r.callId,kind:`called`,name:r.name,session:e.taskOwned?confirmTaskAgentAddress(c,{address:n,operationId:s.id}):confirmAgentStarted(c,{address:n,operationId:s.id}),toolName:r.remoteAgentName}}catch(e){return logError(log,`remote agent start failed`,e,{remoteAgentName:r.remoteAgentName,nodeId:r.nodeId,callId:r.callId}),{kind:`error`,result:createRemoteAgentStartFailureResult({action:r,error:e}),session:rejectAgentEffect(c,{disposition:`dead`,operationId:s.id})}}}export{startRemoteSubagent};

package/dist/src/execution/task-event-callback.d.ts

@@ -0,0 +1,13 @@
+import type { ContextContainer } from "#context/container.js";
+import type { UnstampedMessageStreamEvent } from "#protocol/message.js";
+/**
+ * Forwards one task child's blocking transition to its parent's session
+ * callback.
+ *
+ * Task children report HITL and authorization transitions to the parent's
+ * task run before local emission, so the run can block/unblock the task
+ * under one durable decision. A session without a callback capability
+ * (non-delegated runs) is a no-op, as is any event outside the three
+ * blocking transitions.
+ */
+export declare function forwardTaskEventToSessionCallback(ctx: ContextContainer, event: UnstampedMessageStreamEvent): Promise<void>;

package/dist/src/execution/task-event-callback.js

@@ -0,0 +1 @@
+import{ContinuationTokenKey,SessionCallbackKey,SessionIdKey}from"#context/keys.js";import{fireTaskEventCallbackStep}from"#execution/session-callback-step.js";async function forwardTaskEventToSessionCallback(e,t){let n=e.get(SessionCallbackKey);n!==void 0&&(t.type!==`input.requested`&&t.type!==`authorization.required`&&t.type!==`authorization.completed`||await fireTaskEventCallbackStep({callback:n,childContinuationToken:e.require(ContinuationTokenKey),childSessionId:e.require(SessionIdKey),event:t}))}export{forwardTaskEventToSessionCallback};

package/dist/src/execution/task-input-capability.d.ts

@@ -0,0 +1,4 @@
+/** Narrows one private create-once session token to task-input delivery only. */
+export declare function createTaskInputCapabilityToken(operationToken: string): string;
+/** Resolves a task-input capability to the create-once session hook it may address. */
+export declare function readTaskInputTargetToken(capabilityToken: string): string | undefined;

package/dist/src/execution/task-input-capability.js

@@ -0,0 +1 @@
+const OPERATION_TOKEN_PREFIX=`eve:eve:op:`,TASK_INPUT_TOKEN_PREFIX=`eve:task-input:`,TOKEN_DIGEST=/^[a-f0-9]{32}$/;function createTaskInputCapabilityToken(n){let r=readTokenDigest(n,OPERATION_TOKEN_PREFIX);if(r===void 0)throw Error(`Remote task input requires an eve create-once session capability.`);return`${TASK_INPUT_TOKEN_PREFIX}${r}`}function readTaskInputTargetToken(n){let r=readTokenDigest(n,TASK_INPUT_TOKEN_PREFIX);return r===void 0?void 0:`${OPERATION_TOKEN_PREFIX}${r}`}function readTokenDigest(e,t){if(!e.startsWith(t))return;let r=e.slice(t.length);return TOKEN_DIGEST.test(r)?r:void 0}export{createTaskInputCapabilityToken,readTaskInputTargetToken};

package/dist/src/execution/tasks/child/steps.d.ts

@@ -0,0 +1,46 @@
+import { type TaskInboundAnswerInput, type TaskInboundAuthorizationEvent, type TaskInboundInputRequest, type TaskView } from "#tasks/types.js";
+/**
+ * Appends one full task view to the owning task run's `eve.task`
+ * stream. Only the task run workflow calls this, which is what makes
+ * the run the single writer readers can trust without re-validating.
+ */
+export declare function appendTaskViewStep(input: {
+    readonly view: TaskView;
+}): Promise<void>;
+/** Re-emits a task-owned child authorization event through the parent channel. */
+export declare function wakeTaskAuthorizationParentStep(input: {
+    readonly request: TaskInboundAuthorizationEvent;
+    readonly taskId: string;
+    readonly token: string;
+}): Promise<void>;
+/**
+ * Wakes the parent session with a framework task notification.
+ *
+ * Rides the ordinary session delivery path: a parked parent starts a
+ * turn carrying this message, while an active turn observes it at the
+ * next safe boundary through the driver's normal delivery routing. A
+ * parent whose session already ended is a tolerated no-op.
+ */
+export declare function wakeTaskParentStep(input: {
+    readonly token: string;
+    readonly view: TaskView;
+}): Promise<void>;
+/** Sends an exact local-task HITL batch to the parent's pre-model router. */
+export declare function wakeTaskInputRequestParentStep(input: {
+    readonly request: TaskInboundInputRequest;
+    readonly taskId: string;
+    readonly token: string;
+}): Promise<void>;
+/**
+ * Forwards answered input to the blocked child.
+ *
+ * The task run performs this itself so the child unblocks and the
+ * view leaves `input_required` under one durable decision. Returns
+ * `unreachable` when the child hook is already gone, which leaves the
+ * outstanding batch untouched rather than reporting a task as working
+ * when nothing received the answer.
+ */
+export declare function deliverTaskInputResponsesStep(input: {
+    readonly answer: TaskInboundAnswerInput;
+    readonly requestIds: readonly string[];
+}): Promise<"delivered" | "unreachable">;

package/dist/src/execution/tasks/child/steps.js

@@ -0,0 +1 @@
+import{createLogger}from"#internal/logging.js";import{resumeHook}from"#internal/workflow/runtime.js";import{getWritable}from"#compiled/@workflow/core/index.js";import{isTaskWorkflowTargetGone}from"#execution/tasks/workflow-target.js";import{TASK_VIEW_STREAM_NAMESPACE,isTerminalTaskStatus,taskAuthorizationRequestId}from"#tasks/types.js";const log=createLogger(`execution.tasks.run`);async function appendTaskViewStep(e){"use step";let t=getWritable({namespace:TASK_VIEW_STREAM_NAMESPACE}).getWriter();try{await t.write(e.view)}finally{t.releaseLock()}}async function wakeTaskAuthorizationParentStep(e){"use step";let n={callId:e.request.callId,childSessionId:e.request.childSessionId,event:e.request.event,kind:`subagent-authorization-event`,subagentName:e.request.subagentName},r=e.request.event.data,i={task:{authorizationEvents:[{hookPayload:n,taskId:e.taskId}]}};e.request.event.type===`authorization.required`&&(i.message=`Background task ${e.taskId} needs authorization.`);let a={kind:`send`,payload:i,taskDeliveryId:`${e.taskId}:authorization:${e.request.event.type}:${r.turnId}:${r.stepIndex}:${r.sequence}:${taskAuthorizationRequestId(e.request.event)}`};try{await resumeHook(e.token,a)}catch(e){if(isTaskWorkflowTargetGone(e))return;throw e}}async function wakeTaskParentStep(e){"use step";let n={message:formatTaskNotification(e.view)};isTerminalTaskStatus(e.view.status)&&(n.task={views:[e.view]});let r={kind:`send`,payload:n,taskDeliveryId:`${e.view.taskId}:ready:${e.view.status}`};try{await resumeHook(e.token,r)}catch(t){if(isTaskWorkflowTargetGone(t)){log.warn(`task wake target is gone; the parent session already ended`,{status:e.view.status,taskId:e.view.taskId});return}throw t}}async function wakeTaskInputRequestParentStep(e){"use step";let n={kind:`send`,payload:{task:{inputRequests:[{hookPayload:e.request,taskId:e.taskId}]}},taskDeliveryId:`${e.taskId}:input:${e.request.event.turnId}:${e.request.event.stepIndex}:${e.request.event.sequence}`};try{await resumeHook(e.token,n)}catch(e){if(isTaskWorkflowTargetGone(e))return;throw e}}async function deliverTaskInputResponsesStep(e){"use step";let n=new Set(e.requestIds),r={auth:e.answer.auth,kind:`send`,payload:{inputResponses:e.answer.inputResponses.filter(e=>n.has(e.requestId))},taskDeliveryId:`${e.answer.taskId}:${[...e.requestIds].sort().join(`,`)}`};try{if(e.answer.childResponseUrl!==void 0){let t=await fetch(e.answer.childResponseUrl,{body:JSON.stringify({inputResponses:r.payload.inputResponses}),headers:{"content-type":`application/json`},method:`POST`,redirect:`error`});if(t.status===404)return`unreachable`;if(!t.ok)throw Error(`Remote task input delivery failed with HTTP ${t.status}.`)}else await resumeHook(e.answer.childContinuationToken,r);return`delivered`}catch(t){if(isTaskWorkflowTargetGone(t))return log.warn(`task input answer target is gone; the child turn already ended`,{taskId:e.answer.taskId}),`unreachable`;throw t}}function formatTaskNotification(e){let t=`Background task ${e.taskId} (${e.metadata.name})`;return e.status===`input_required`?`${t} needs input. Use task_peek to inspect the outstanding requests.`:`${t} is ${e.status}. Use task_peek to read its output.`}export{appendTaskViewStep,deliverTaskInputResponsesStep,wakeTaskAuthorizationParentStep,wakeTaskInputRequestParentStep,wakeTaskParentStep};

package/dist/src/execution/tasks/child/workflow.d.ts

@@ -0,0 +1,31 @@
+import { type TaskView } from "#tasks/types.js";
+/** Input for one durable task run. */
+export interface TaskRunWorkflowInput {
+    /** Private task inbox token; a routing credential, never model-visible. */
+    readonly taskInboxToken: string;
+    /** The creation view, normally `working`. */
+    readonly initialView: TaskView;
+    /** Parent session delivery token used to wake the task's owning parent. */
+    readonly parentContinuationToken: string;
+}
+/**
+ * The durable task run: single writer for one task's lifecycle.
+ *
+ * Consumes commands and child wire payloads over its private hook,
+ * applies the pure transition function, and appends a full `TaskView`
+ * per accepted command to its `eve.task` run stream. Competing
+ * completion, cancellation, and input transitions serialize here;
+ * rejected commands (for example a late child result after `cancelled`)
+ * change nothing.
+ *
+ * Wake policy: a transition into a ready status — terminal or
+ * `input_required` — delivers a framework notification to the parent
+ * session. A parked parent starts a turn; an active turn observes the
+ * delivery at its next safe boundary. Nothing else wakes the parent.
+ *
+ * The run ends when the task reaches a terminal status. Its view
+ * stream stays readable, so terminal tasks remain peekable; the
+ * disposed hook makes any later command fail loudly instead of queueing
+ * against a finished task.
+ */
+export declare function taskRunWorkflow(input: TaskRunWorkflowInput): Promise<void>;

package/dist/src/execution/tasks/child/workflow.js

@@ -0,0 +1 @@
+import{createHook}from"#compiled/@workflow/core/index.js";import{claimHookOwnership,disposeHook,isHookConflictError}from"#execution/hook-ownership.js";import{isReadyTaskStatus,isTerminalTaskStatus,readTaskInputRequestId,readTaskUsage}from"#tasks/types.js";import{appendTaskViewStep,deliverTaskInputResponsesStep,wakeTaskAuthorizationParentStep,wakeTaskInputRequestParentStep,wakeTaskParentStep}from"#execution/tasks/child/steps.js";import{applyTaskTransition}from"#tasks/transitions.js";import{translateTaskInboundPayload}from"#tasks/wire.js";function isTaskRunFinished(e,t){return!isTerminalTaskStatus(e.status)||!t?!1:e.status!==`cancelled`||e.executor?.lifecycle===`terminal`}async function taskRunWorkflow(i){"use workflow";let a=createHook({token:i.taskInboxToken}),o=a[Symbol.asyncIterator](),s=!1;try{try{await claimHookOwnership(a),s=!0}catch(e){if(isHookConflictError(e))return;throw e}let e=i.initialView,n,c=[],l=!1;for(await appendTaskViewStep({view:e});!isTaskRunFinished(e,l);){let t=await o.next();if(t.done===!0)return;let r=t.value.kind===`subagent-authorization-event`?{...t.value,kind:`authorization-event`}:t.value;if(r.kind===`authorization-event`&&(r.event.type===`approval.candidate`||r.event.type===`approval.settled`))continue;let a=r.kind===`task-command`&&r.command.kind===`ready`,s=r.kind===`task-command`&&r.command.kind===`reject-dispatch`;(a||s)&&(l=!0),r.kind===`subagent-input-request`&&(n=r),r.kind===`authorization-event`&&c.push(r);let u=e.status===`cancelled`&&r.kind===`runtime-action-result`,d=r.kind===`input-response`,f;if(u)f={kind:`settle-executor`,usage:readTaskUsage(r.results[0]?.outcome?.usageDelta)};else if(d){if(e.status!==`input_required`)continue;f=await resolveAnsweredCommand(e,r)}else f=translateTaskInboundPayload(r);if(f===void 0)continue;if(a&&isTerminalTaskStatus(e.status)){await wakeTaskParentStep({token:i.parentContinuationToken,view:e});continue}let p=applyTaskTransition(e,f);if(p.outcome!==`accepted`)continue;let m=!isTerminalTaskStatus(e.status)&&isTerminalTaskStatus(p.view.status),h=!isReadyTaskStatus(e.status)&&isReadyTaskStatus(p.view.status);e=p.view,await appendTaskViewStep({view:e});let g=l&&!m?c:[];for(let t of g)await wakeTaskAuthorizationParentStep({request:t,taskId:e.taskId,token:i.parentContinuationToken});(m||g.length>0)&&(c=[]),n!==void 0&&l&&e.status===`input_required`?(await wakeTaskInputRequestParentStep({request:n,taskId:e.taskId,token:i.parentContinuationToken}),n=void 0):!s&&g.length===0&&l&&(m||h&&n===void 0)&&await wakeTaskParentStep({token:i.parentContinuationToken,view:e}),e.status!==`input_required`&&(n=void 0)}}finally{s&&await disposeHook(a)}}async function resolveAnsweredCommand(e,t){if(t.taskId!==e.taskId)return;let n=new Set(e.inputRequests.flatMap(e=>{let t=readTaskInputRequestId(e);return t===void 0?[]:[t]})),r=t.inputResponses.map(e=>e.requestId).filter(e=>n.has(e));return r.length===0?void 0:await deliverTaskInputResponsesStep({answer:t,requestIds:r})===`delivered`?{kind:`answered`,requestIds:r}:void 0}export{taskRunWorkflow};

package/dist/src/execution/tasks/parent/agent-identity.d.ts

@@ -0,0 +1,13 @@
+import type { RuntimeAgentHandleAction } from "#execution/agent-handle-dispatch.js";
+/** Resolves the persistent agent identity attached to one delegated task. */
+export declare function describeTaskAgent(input: {
+    readonly action: RuntimeAgentHandleAction;
+    readonly agentId?: string;
+    readonly parentSessionId: string;
+    readonly parentTurnId: string;
+}): {
+    readonly agentId: string;
+    readonly callId: string;
+    readonly mode: "local" | "remote";
+    readonly name: string;
+};

package/dist/src/execution/tasks/parent/agent-identity.js

@@ -0,0 +1 @@
+import{mintStartOperation}from"#execution/dispatch-start-operation.js";function describeTaskAgent(e){let{action:t}=e,n=t.kind===`remote-agent-call`?t.remoteAgentName:t.subagentName;return{agentId:e.agentId??mintStartOperation({callId:t.callId,name:n,nodeId:t.nodeId,parentSessionId:e.parentSessionId,parentTurnId:e.parentTurnId}).identity.id,callId:t.callId,mode:t.kind===`remote-agent-call`?`remote`:`local`,name:n}}export{describeTaskAgent};

package/dist/src/execution/tasks/parent/agent-views.d.ts

@@ -0,0 +1,6 @@
+import type { HarnessSession } from "#harness/types.js";
+import { type AgentView } from "#harness/handles/prompt.js";
+/** Derives model-visible task-agent availability from authoritative task views. */
+export declare function readTaskAgentViews(session: HarnessSession): Promise<readonly AgentView[]>;
+/** Appends the changed task-agent projection before the next model call. */
+export declare function appendTaskAgentAnnouncement(session: HarnessSession): Promise<HarnessSession>;

package/dist/src/execution/tasks/parent/agent-views.js

@@ -0,0 +1 @@
+import{formatAgentStatus,getAgentHandleStore}from"#harness/handles/store.js";import{getSessionTaskIndex}from"#tasks/session-index.js";import{resolveAgentsAnnouncement}from"#harness/handles/prompt.js";import{readTaskViews}from"#execution/tasks/parent/control-shared.js";async function readTaskAgentViews(r){let a=(getAgentHandleStore(r.state)?.handles??[]).filter(e=>e.phase===`addressed`);if(a.length===0)return[];let o=await readTaskViews(getSessionTaskIndex(r.state)),s=new Map;for(let e of o){let t=s.get(e.metadata.agentId)??[];s.set(e.metadata.agentId,[...t,e])}return a.map(t=>{let n=s.get(t.identity.id)??[],r=n.filter(e=>e.status===`working`||e.status===`input_required`);if(r.length>1)throw Error(`Agent "${t.identity.id}" has more than one nonterminal task.`);let i=r[0];if(i!==void 0){let e=i.status===`input_required`?`input_required`:`working`;return{availability:`busy`,id:t.identity.id,name:t.identity.name,taskId:i.taskId,taskStatus:e}}let a=n.at(-1);return{availability:`available`,id:t.identity.id,name:t.identity.name,statusLine:a?.lastOutput===void 0?void 0:formatAgentStatus(a.lastOutput.data)}})}async function appendTaskAgentAnnouncement(e){let n=resolveAgentsAnnouncement({agentViews:await readTaskAgentViews(e),messages:e.history,store:getAgentHandleStore(e.state)});return n===void 0?e:{...e,history:[...e.history,{content:n,role:`user`}]}}export{appendTaskAgentAnnouncement,readTaskAgentViews};

package/dist/src/execution/tasks/parent/continuation-dispatch.d.ts

@@ -0,0 +1,37 @@
+import { type DispatchOutcome, type RuntimeAgentHandleAction, type RuntimeSession } from "#execution/agent-handle-dispatch.js";
+import { settleDelegatedDispatch, type DelegatedTask } from "#execution/tasks/parent/delegate.js";
+import { describeTaskAgent } from "#execution/tasks/parent/agent-identity.js";
+import type { RuntimeSubagentDispatchFailure } from "#runtime/actions/types.js";
+export type PersistedContinuationTask = Awaited<ReturnType<typeof settleDelegatedDispatch>>;
+/** Describes task identity from the stored address when continuing an agent. */
+export declare function describeTaskDispatch(input: {
+    readonly action: RuntimeAgentHandleAction;
+    readonly agentId: string | undefined;
+    readonly parentSessionId: string;
+    readonly parentTurnId: string;
+    readonly session: RuntimeSession;
+}): ReturnType<typeof describeTaskAgent>;
+export declare function checkTaskContinuationAvailability(input: {
+    readonly action: RuntimeAgentHandleAction;
+    readonly agentId: string;
+    readonly parentStepIndex: number;
+    readonly parentTurnId: string;
+    readonly session: RuntimeSession;
+}): Promise<RuntimeSubagentDispatchFailure | undefined>;
+/**
+ * Persists the task's ownership and routing entry in the parent session's
+ * `eve.tasks` index and creates its parked tool-call receipt before dispatch.
+ */
+export declare function persistContinuationTaskInParentSession(input: {
+    readonly action: RuntimeAgentHandleAction;
+    readonly agentId: string;
+    readonly delegated: DelegatedTask;
+    readonly session: RuntimeSession;
+}): Promise<PersistedContinuationTask | undefined>;
+export declare function settleTaskDispatchError(input: {
+    readonly delegated: DelegatedTask;
+    readonly outcome: Extract<DispatchOutcome, {
+        readonly kind: "error";
+    }>;
+    readonly persisted: PersistedContinuationTask | undefined;
+}): Promise<RuntimeSubagentDispatchFailure>;

package/dist/src/execution/tasks/parent/continuation-dispatch.js

@@ -0,0 +1 @@
+import{AGENT_BUSY}from"#harness/agent-handle-errors.js";import{createAgentErrorResult}from"#execution/agent-handle-dispatch.js";import{findActiveTaskForAgent,findTaskAgentAddress}from"#execution/tasks/parent/control-shared.js";import{failDelegatedDispatch,rejectDelegatedDispatch,settleDelegatedDispatch}from"#execution/tasks/parent/delegate.js";import{describeTaskAgent}from"#execution/tasks/parent/agent-identity.js";function describeTaskDispatch(e){let t=describeTaskAgent(e),n=e.agentId===void 0?void 0:findTaskAgentAddress(e.session,e.agentId);return n===void 0?t:{...t,mode:n.address.kind===`agent/remote`?`remote`:`local`}}async function checkTaskContinuationAvailability(r){let i=await findActiveTaskForAgent(r.session,r.agentId,r.parentTurnId,r.parentStepIndex);return i===void 0?void 0:createAgentErrorResult({action:r.action,code:AGENT_BUSY,message:`Agent "${r.agentId}" is busy with task "${i.view.taskId}" (${i.view.status}).`})}async function persistContinuationTaskInParentSession(e){let t=findTaskAgentAddress(e.session,e.agentId);if(t!==void 0)return settleDelegatedDispatch({callId:e.action.callId,session:e.session,subagentName:t.identity.name,task:e.delegated})}async function settleTaskDispatchError(e){return e.persisted!==void 0&&e.outcome.deliveryAmbiguous===!0||await(e.persisted===void 0?rejectDelegatedDispatch:failDelegatedDispatch)({error:e.outcome.result.output,task:e.delegated}),e.persisted===void 0?e.outcome.result:{...e.outcome.result,output:attachTaskId(e.outcome.result.output,e.delegated.taskId)}}function attachTaskId(e,t){return typeof e==`object`&&e&&!Array.isArray(e)?{...e,taskId:t}:{error:e,taskId:t}}export{checkTaskContinuationAvailability,describeTaskDispatch,persistContinuationTaskInParentSession,settleTaskDispatchError};

package/dist/src/execution/tasks/parent/control-shared.d.ts

@@ -0,0 +1,36 @@
+import type { RuntimeSession } from "#execution/agent-handle-dispatch.js";
+import { type AgentHandle } from "#harness/handles/store.js";
+import type { RuntimeActionResult, RuntimeToolCallActionRequest } from "#runtime/actions/types.js";
+import { type SessionTaskIndexEntry } from "#tasks/session-index.js";
+import type { TaskView } from "#tasks/types.js";
+/**
+ * Result and lookup helpers shared by the task-control executors
+ * (`task_peek`/`task_cancel` in the dispatch module,
+ * `task_send` in its own).
+ */
+/** Resolves owned index entries, or the ids this session does not own. */
+export declare function lookupTaskEntries(session: RuntimeSession, taskIds: readonly string[]): {
+    readonly entries: SessionTaskIndexEntry[];
+    readonly kind: "found";
+} | {
+    readonly kind: "unknown";
+    readonly unknown: string[];
+};
+/** Reads the latest view of every entry, defaulting to `working`. */
+export declare function readTaskViews(entries: readonly SessionTaskIndexEntry[]): Promise<TaskView[]>;
+export declare function readTaskView(entry: SessionTaskIndexEntry): Promise<TaskView>;
+/** Finds the persistent address record for one task-owned agent. */
+export declare function findTaskAgentAddress(session: RuntimeSession, agentId: string): Extract<AgentHandle, {
+    phase: "addressed";
+}> | undefined;
+/** Returns the one nonterminal task owning an agent, if any. */
+export declare function findActiveTaskForAgent(session: RuntimeSession, agentId: string, parentTurnId?: string, parentStepIndex?: number): Promise<{
+    readonly entry: SessionTaskIndexEntry;
+    readonly view: TaskView;
+} | undefined>;
+/** One successful task-control result carrying full task views. */
+export declare function createTaskViewsResult(action: RuntimeToolCallActionRequest, views: readonly TaskView[]): RuntimeActionResult;
+/** One task-control error the model can act on. */
+export declare function createTaskControlError(action: RuntimeToolCallActionRequest, message: string): RuntimeActionResult;
+/** The ownership error for ids outside this session's task index. */
+export declare function createUnknownTasksError(action: RuntimeToolCallActionRequest, unknown: readonly string[]): RuntimeActionResult;

package/dist/src/execution/tasks/parent/control-shared.js

@@ -0,0 +1 @@
+import{getAgentHandleStore}from"#harness/handles/store.js";import{readLatestTaskView}from"#execution/tasks/parent/run-parent.js";import{findSessionTaskEntry,getSessionTaskIndex}from"#tasks/session-index.js";import{isTaskWorkflowTargetGone}from"#execution/tasks/workflow-target.js";import{taskViewsToJson}from"#tasks/json.js";function lookupTaskEntries(e,t){let r=[],i=[];for(let a of t){let t=findSessionTaskEntry(e.state,a);t===void 0?i.push(a):r.push(t)}return i.length>0?{kind:`unknown`,unknown:i}:{entries:r,kind:`found`}}async function readTaskViews(e){return Promise.all(e.map(readTaskView))}async function readTaskView(e){try{return await readLatestTaskView({taskRunId:e.taskRunId})??createPendingTaskView(e)}catch(t){if(isTaskWorkflowTargetGone(t)&&e.terminalView!==void 0)return e.terminalView;throw t}}function createPendingTaskView(e){return{metadata:e.metadata,status:`working`,taskId:e.taskId}}function findTaskAgentAddress(t,n){return(getAgentHandleStore(t.state)?.handles??[]).find(e=>e.phase===`addressed`&&e.identity.id===n)}async function findActiveTaskForAgent(e,t,n,i){let a=getSessionTaskIndex(e.state).filter(e=>e.metadata.agentId===t),o=await readTaskViews(a);return a.flatMap((e,t)=>{let r=o[t];return r!==void 0&&(e.createdByTurnId===n&&e.createdByStepIndex===i||r.status===`working`||r.status===`input_required`)?[{entry:e,view:r}]:[]})[0]}function createTaskViewsResult(e,t){return{callId:e.callId,kind:`tool-result`,output:taskViewsToJson(t),toolName:e.toolName}}function createTaskControlError(e,t){return{callId:e.callId,isError:!0,kind:`tool-result`,output:{message:t},toolName:e.toolName}}function createUnknownTasksError(e,t){return createTaskControlError(e,`Unknown task ids: ${t.join(`, `)}. Tasks belong to the session that created them.`)}export{createTaskControlError,createTaskViewsResult,createUnknownTasksError,findActiveTaskForAgent,findTaskAgentAddress,lookupTaskEntries,readTaskView,readTaskViews};

package/dist/src/execution/tasks/parent/delegate.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Delegation policy for the subagent dispatch path: derives task identity,
+ * builds metadata and the parked-tool-call receipt, records the session
+ * index, and defines failure semantics for an unacknowledged dispatch.
+ * Task-run transport (start/command/view) lives in `run-parent.ts`, which
+ * this module composes and which other non-delegation callers share.
+ */
+import type { RuntimeSession } from "#execution/agent-handle-dispatch.js";
+import type { RuntimeSubagentChildResult } from "#runtime/actions/types.js";
+import type { JsonValue } from "#shared/json.js";
+import { type TaskMetadata } from "#tasks/types.js";
+/** A prepared delegated task: identity plus its started durable run. */
+export interface DelegatedTask {
+    readonly taskInboxToken: string;
+    readonly createdByStepIndex?: number;
+    readonly createdByTurnId: string;
+    readonly metadata: TaskMetadata;
+    readonly operationId: string;
+    readonly taskId: string;
+    readonly taskRunId: string;
+}
+/**
+ * Creates the durable task record for one delegated subagent call,
+ * before the child dispatch side effect. The task must exist first so
+ * a fast child always finds a live command hook; a duplicate replay
+ * re-derives the same token and the loser exits on the hook claim.
+ */
+export declare function beginDelegatedTask(input: {
+    readonly agentId: string;
+    readonly callId: string;
+    readonly mode: "local" | "remote";
+    readonly name: string;
+    readonly parentSessionId: string;
+    readonly parentStepIndex?: number;
+    readonly parentTurnId: string;
+    readonly session: RuntimeSession;
+}): Promise<DelegatedTask>;
+/**
+ * Settles a delegated dispatch that acknowledged a child: persists the task
+ * in the session index and returns the receipt that resolves the originating
+ * tool call. Agent identity and routing remain in the persistent address
+ * record; task state owns execution availability.
+ */
+export declare function settleDelegatedDispatch(input: {
+    readonly callId: string;
+    readonly session: RuntimeSession;
+    readonly subagentName: string;
+    readonly task: DelegatedTask;
+}): Promise<{
+    readonly receipt: RuntimeSubagentChildResult;
+    readonly session: RuntimeSession;
+}>;
+/** Releases task events only after the parent session index committed. */
+export declare function acknowledgeDelegatedTasksStep(input: {
+    readonly tasks: readonly {
+        readonly taskInboxToken: string;
+        readonly taskId: string;
+        readonly taskRunId: string;
+    }[];
+}): Promise<void>;
+/** Fails an indexed task whose child dispatch was definitively rejected. */
+export declare function failDelegatedDispatch(input: {
+    readonly error: JsonValue;
+    readonly task: DelegatedTask;
+}): Promise<void>;
+/** Silently terminates a task whose child dispatch failed before parent indexing. */
+export declare function rejectDelegatedDispatch(input: {
+    readonly error: JsonValue;
+    readonly task: DelegatedTask;
+}): Promise<void>;

package/dist/src/execution/tasks/parent/delegate.js

@@ -0,0 +1 @@
+import{sessionCommandHookToken}from"#execution/session-command-token.js";import{deriveAgentOperationId}from"#harness/handles/operation-id.js";import{deriveTaskId,deriveTaskInboxToken}from"#tasks/task-id.js";import{readLatestTaskView,sendTaskCommand,sendTaskCommandToOwner,startTaskRun,waitForTaskCommandOwner}from"#execution/tasks/parent/run-parent.js";import{recordSessionTask}from"#tasks/session-index.js";import{isTerminalTaskStatus}from"#tasks/types.js";async function beginDelegatedTask(n){let r=deriveTaskId({callId:n.callId,parentSessionId:n.parentSessionId,parentTurnId:n.parentTurnId}),i=deriveTaskInboxToken({parentContinuationToken:n.session.continuationToken,taskId:r}),a=deriveAgentOperationId({callId:n.callId,parentSessionId:n.parentSessionId,parentTurnId:n.parentTurnId}),o={agentId:n.agentId,kind:`subagent`,mode:n.mode,name:n.name};await startTaskRun({taskInboxToken:i,initialView:{metadata:o,status:`working`,taskId:r},parentContinuationToken:sessionCommandHookToken(n.session.sessionId)});let s=await waitForTaskCommandOwner({taskInboxToken:i});return{taskInboxToken:i,createdByStepIndex:n.parentStepIndex??0,createdByTurnId:n.parentTurnId,metadata:o,operationId:a,taskId:r,taskRunId:s.runId}}async function settleDelegatedDispatch(e){let t={agentId:e.task.metadata.agentId,status:`working`,taskId:e.task.taskId};return{receipt:{backgroundTask:{status:t.status,taskId:t.taskId},callId:e.callId,kind:`subagent-result`,origin:`child`,outcome:{kind:`parked`,result:{kind:`succeeded`,output:`Delegated as background task ${e.task.taskId} (working).`},usageDelta:{cacheReadTokens:0,cacheWriteTokens:0,inputTokens:0,outputTokens:0}},output:t,subagentName:e.subagentName},session:recordSessionTask(e.session,{taskInboxToken:e.task.taskInboxToken,createdByStepIndex:e.task.createdByStepIndex,createdByTurnId:e.task.createdByTurnId,metadata:e.task.metadata,operationId:e.task.operationId,taskId:e.task.taskId,taskRunId:e.task.taskRunId})}}async function acknowledgeDelegatedTasksStep(e){"use step";for(let t of e.tasks){if(await sendTaskCommandToOwner({command:{kind:`ready`},taskInboxToken:t.taskInboxToken,retryUnreachable:{attempts:20,delayMs:250}})!==void 0)continue;let e=await readLatestTaskView({taskRunId:t.taskRunId});if(!(e!==void 0&&isTerminalTaskStatus(e.status)))throw Error(`Task run "${t.taskId}" did not accept its readiness command.`)}}async function failDelegatedDispatch(e){await sendTaskCommand({command:{data:e.error,kind:`fail`},taskInboxToken:e.task.taskInboxToken,retryUnreachable:{attempts:20,delayMs:250}})}async function rejectDelegatedDispatch(e){await sendTaskCommand({command:{data:e.error,kind:`reject-dispatch`},taskInboxToken:e.task.taskInboxToken,retryUnreachable:{attempts:20,delayMs:250}})}export{acknowledgeDelegatedTasksStep,beginDelegatedTask,failDelegatedDispatch,rejectDelegatedDispatch,settleDelegatedDispatch};

package/dist/src/execution/tasks/parent/dispatch-task-step.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Task-mode sibling of `dispatchRuntimeActionsStep`, selected by the turn
+ * workflow when the agent enables `experimental.tasks`.
+ *
+ * Same plan → dispatch → emit skeleton, but every delegation is wrapped in
+ * the durable task lifecycle: the task record and its inbox token
+ * exist *before* the child dispatch side effect (`beginDelegatedTask`),
+ * continuations pass the availability check and enter the parent session's
+ * task index first, and the task settles against the dispatch outcome.
+ * Children report through their task's inbox token rather than the
+ * parent turn inbox, and every start dispatches a conversation-mode
+ * (persistent) child so the background task stays resumable.
+ *
+ * Task-control calls (`task_peek` / `task_cancel` / `task_send`) execute
+ * inline in this step, which holds the session ownership index and world
+ * access they need.
+ */
+import { type RuntimeActionDispatchInput, type RuntimeActionDispatchResult } from "#execution/dispatch-runtime-actions-shared.js";
+export declare function dispatchTaskStep(input: RuntimeActionDispatchInput): Promise<RuntimeActionDispatchResult>;

package/dist/src/execution/tasks/parent/dispatch-task-step.js

@@ -0,0 +1 @@
+import{createDurableSessionState}from"#execution/durable-session-store.js";import{dispatchToTaskAgentAddress}from"#execution/agent-handle-dispatch.js";import{executeTaskControlAction}from"#execution/tasks/parent/dispatch.js";import{createAgentContinuationBundle}from"#execution/agent-continuation-bundle.js";import{emitSubagentCalled,prepareRuntimeActionDispatch,startSubagent}from"#execution/dispatch-runtime-actions-shared.js";import{beginDelegatedTask,settleDelegatedDispatch}from"#execution/tasks/parent/delegate.js";import{checkTaskContinuationAvailability,describeTaskDispatch,persistContinuationTaskInParentSession,settleTaskDispatchError}from"#execution/tasks/parent/continuation-dispatch.js";async function dispatchTaskStep(r){"use step";let i=await prepareRuntimeActionDispatch({serializedContext:r.serializedContext,sessionState:r.sessionState,taskControls:!0});if(i===void 0)return{results:[],sessionState:r.sessionState,pendingTasks:[]};let{batch:a,bundle:o,session:s}=i,c=r.parentWritable.getWriter(),l=s,u=[],d=[];try{for(let e of i.plan){if(e.kind===`reject`){u.push(e.result);continue}if(e.kind===`task-control`){let t=await executeTaskControlAction({action:e.action,bundle:o,parentStepIndex:a.event.stepIndex,parentTurnId:a.event.turnId,session:l});l=t.session,t.pendingTask!==void 0&&d.push(t.pendingTask),u.push(t.result);continue}if(e.kind===`resume`){let t=await checkTaskContinuationAvailability({action:e.action,agentId:e.agentId,parentStepIndex:a.event.stepIndex,parentTurnId:a.event.turnId,session:l});if(t!==void 0){u.push(t);continue}}let n=await beginDelegatedTask({...describeTaskDispatch({action:e.kind===`resume`?e.action:e.target.action,agentId:e.kind===`resume`?e.agentId:void 0,parentSessionId:s.sessionId,parentTurnId:a.event.turnId,session:l}),parentSessionId:s.sessionId,parentStepIndex:a.event.stepIndex,parentTurnId:a.event.turnId,session:l}),f;e.kind===`resume`&&(f=await persistContinuationTaskInParentSession({action:e.action,agentId:e.agentId,delegated:n,session:l}),l=f?.session??l);let p;switch(e.kind){case`resume`:p=await dispatchToTaskAgentAddress({action:e.action,agentId:e.agentId,bundle:createAgentContinuationBundle({action:e.action,bundle:o,dynamicRemoteAgent:e.dynamicRemoteAgent}),currentSession:l,parentToken:n.taskInboxToken});break;case`start`:p=await startSubagent({auth:i.auth,batchEvent:a.event,bundle:o,callbackBaseUrl:r.callbackBaseUrl,capabilities:i.capabilities,channelMetadata:i.channelMetadata,currentSession:l,fanoutSize:i.fanoutSize,initiatorAuth:i.initiatorAuth,parentContinuationToken:n.taskInboxToken,parentTraceContext:i.parentTraceContext,persistentSessions:!0,serializedContext:i.serializedContext,session:s,taskOwned:!0,target:e.target});break}if(l=p.session,p.kind===`error`){u.push(await settleTaskDispatchError({delegated:n,outcome:p,persisted:f})),f!==void 0&&d.push(n);continue}if(f!==void 0)u.push(f.receipt);else{let e=await settleDelegatedDispatch({callId:p.callId,session:l,subagentName:p.toolName,task:n});l=e.session,u.push(e.receipt)}d.push(n),await emitSubagentCalled({adapter:i.adapter,adapterCtx:i.adapterCtx,batchEvent:a.event,entry:e,outcome:p,sessionId:s.sessionId,writer:c})}}finally{c.releaseLock()}return{results:u,sessionState:l===s?r.sessionState:createDurableSessionState({session:l}),pendingTasks:d}}export{dispatchTaskStep};

package/dist/src/execution/tasks/parent/dispatch.d.ts

@@ -0,0 +1,33 @@
+import type { RuntimeSession } from "#execution/agent-handle-dispatch.js";
+import type { DelegatedTask } from "#execution/tasks/parent/delegate.js";
+import type { RuntimeActionRequest, RuntimeActionResult, RuntimeToolCallActionRequest } from "#runtime/actions/types.js";
+import type { CompiledBundle } from "#runtime/sessions/runtime-context-keys.js";
+import type { SessionTaskIndexEntry } from "#tasks/session-index.js";
+import { type TaskView } from "#tasks/types.js";
+/** True for `task_peek` / `task_cancel` / `task_send` calls. */
+export declare function isTaskControlAction(action: RuntimeActionRequest): action is RuntimeToolCallActionRequest;
+/**
+ * Executes one task-control call inside the dispatch step, which holds
+ * the durable session state (ownership index) and world access the
+ * tools need.
+ *
+ * Returns the (possibly updated) session: `task_send` follow-ups record
+ * new tasks and settle the continued agent handle.
+ */
+export declare function executeTaskControlAction(input: {
+    readonly action: RuntimeToolCallActionRequest;
+    readonly bundle: CompiledBundle;
+    readonly parentStepIndex?: number;
+    readonly parentTurnId: string;
+    readonly session: RuntimeSession;
+}): Promise<{
+    readonly result: RuntimeActionResult;
+    readonly session: RuntimeSession;
+    readonly pendingTask?: DelegatedTask;
+}>;
+/** Commits task cancellation, then propagates it to the addressed executor. */
+export declare function cancelOwnedTask(input: {
+    readonly bundle: CompiledBundle;
+    readonly entry: SessionTaskIndexEntry;
+    readonly session: RuntimeSession;
+}): Promise<TaskView>;

package/dist/src/execution/tasks/parent/dispatch.js

@@ -0,0 +1 @@
+import{createLogger,logError}from"#internal/logging.js";import{cancelRemoteAgentTurn,resolveRemoteAgentForAction}from"#execution/remote-agent-dispatch.js";import{requestWorkflowTurnCancellation}from"#execution/workflow-runtime.js";import{TASK_CANCEL_TOOL_NAME,TASK_CONTROL_TOOL_NAMES,TASK_PEEK_TOOL_NAME,TASK_SEND_TOOL_NAME}from"#runtime/framework-tools/tasks.js";import{sendTaskCommand}from"#execution/tasks/parent/run-parent.js";import{isTerminalTaskStatus}from"#tasks/types.js";import{createTaskControlError,createTaskViewsResult,createUnknownTasksError,findTaskAgentAddress,lookupTaskEntries,readTaskView,readTaskViews}from"#execution/tasks/parent/control-shared.js";import{executeTaskSend}from"#execution/tasks/parent/send.js";const log=createLogger(`execution.tasks.dispatch`);function isTaskControlAction(e){return e.kind===`tool-call`&&TASK_CONTROL_TOOL_NAMES.has(e.toolName)}async function executeTaskControlAction(e){let{action:t,session:n}=e;if(t.toolName===TASK_SEND_TOOL_NAME)return executeTaskSend(e);let r=readTaskIds(t.input);if(r===void 0||r.length===0)return{result:createTaskControlError(t,"Provide a non-empty `taskIds` array."),session:n};let i=lookupTaskEntries(n,r);if(i.kind===`unknown`)return{result:createUnknownTasksError(t,i.unknown),session:n};let o=i.entries;switch(t.toolName){case TASK_PEEK_TOOL_NAME:return{result:createTaskViewsResult(t,await readTaskViews(o)),session:n};case TASK_CANCEL_TOOL_NAME:{let r=[];for(let t of o)r.push(await cancelOwnedTask({bundle:e.bundle,entry:t,session:n}));return{result:createTaskViewsResult(t,r),session:n}}default:return{result:createTaskControlError(t,`Unsupported task control "${t.toolName}".`),session:n}}}async function cancelOwnedTask(e){let{entry:t}=e,n=await sendTaskCommand({command:{kind:`cancel`},taskInboxToken:t.taskInboxToken}),r=await readTaskView(t);for(let e=0;e<10&&!isTerminalTaskStatus(r.status);e+=1)await new Promise(e=>setTimeout(e,250)),r=await readTaskView(t);if(!isTerminalTaskStatus(r.status))throw Error(`Task "${t.taskId}" did not commit cancellation before timeout.`);let i=r;return i.status===`cancelled`&&n===`delivered`&&await propagateTaskCancel({bundle:e.bundle,session:e.session,view:i}),i}async function propagateTaskCancel(e){let a=findTaskAgentAddress(e.session,e.view.metadata.agentId);if(a===void 0)return;let o=a.address.sessionId,s=e.view.executor?.childTurnId;if(!(e.view.executor?.childSessionId!==void 0&&e.view.executor.childSessionId!==o))try{if(a.address.kind===`agent/remote`){let t=resolveRemoteAgentForAction({nodeId:a.identity.nodeId,remoteAgentName:a.identity.name,registry:e.bundle.subagentRegistry.subagentsByNodeId}),i={remote:{...t,url:a.address.url},sessionId:o,taskId:e.view.taskId};s!==void 0&&(i.turnId=s),(await cancelRemoteAgentTurn(i)).status===`no_active_turn`&&await cancelRemoteAgentTurn({remote:{...t,url:a.address.url},sessionId:o,taskId:e.view.taskId});return}let t={sessionId:o,taskId:e.view.taskId};s!==void 0&&(t.turnId=s),(await requestWorkflowTurnCancellation(t)).status===`no_active_turn`&&await requestWorkflowTurnCancellation({sessionId:o,taskId:e.view.taskId})}catch(n){logError(log,`task cancel propagation failed; the child may run to completion`,n,{childSessionId:o,taskId:e.view.taskId})}}function readTaskIds(e){let t=e.taskIds;if(Array.isArray(t))return t.filter(e=>typeof e==`string`&&e.trim()!==``)}export{cancelOwnedTask,executeTaskControlAction,isTaskControlAction};

package/dist/src/execution/tasks/parent/hitl-proxy-steps.d.ts

@@ -0,0 +1,29 @@
+import type { SubagentInputRequestHookPayload } from "#channel/types.js";
+import type { SubagentAuthorizationEventHookPayload } from "#channel/types.js";
+import { type DurableSessionState } from "#execution/durable-session-store.js";
+import { type TaskView } from "#tasks/types.js";
+/** Validates and durably records one task-owned child HITL route batch. */
+export declare function recordTaskInputRequestStep(input: {
+    readonly hookPayload: SubagentInputRequestHookPayload;
+    readonly serializedContext: Record<string, unknown>;
+    readonly sessionState: DurableSessionState;
+    readonly taskId: string;
+}): Promise<{
+    readonly accepted: false;
+    readonly sessionState: DurableSessionState;
+} | {
+    readonly accepted: true;
+    readonly hookPayload: SubagentInputRequestHookPayload;
+    readonly sessionState: DurableSessionState;
+}>;
+/** Validates that one task authorization event came from its owned child address. */
+export declare function acceptTaskAuthorizationEventStep(input: {
+    readonly hookPayload: SubagentAuthorizationEventHookPayload;
+    readonly sessionState: DurableSessionState;
+    readonly taskId: string;
+}): Promise<boolean>;
+/** Caches terminal task views before their workflow runs can expire. */
+export declare function recordTerminalTaskViewsStep(input: {
+    readonly sessionState: DurableSessionState;
+    readonly views: readonly TaskView[];
+}): Promise<DurableSessionState>;

package/dist/src/execution/tasks/parent/hitl-proxy-steps.js

@@ -0,0 +1 @@
+import{createEveTaskInputRoutePath}from"#protocol/routes.js";import{isInputRequest}from"#runtime/input/types.js";import{getAgentHandleStore}from"#harness/handles/store.js";import{removeTaskAgentAddressFromState}from"#harness/handles/transitions.js";import{createRemoteTaskInputCallbackUrl}from"#execution/workflow-callback-url.js";import{readDurableSession}from"#execution/durable-session-store.js";import{createTaskInputRequestId,toProxyInputRequestEntries,upsertProxyInputRequestState}from"#harness/proxy-input-requests.js";import{readLatestTaskView}from"#execution/tasks/parent/run-parent.js";import{cacheTerminalTaskView,findSessionTaskEntry}from"#tasks/session-index.js";import{isTerminalTaskStatus}from"#tasks/types.js";import{createTaskInputCapabilityToken}from"#execution/task-input-capability.js";async function recordTaskInputRequestStep(r){"use step";let a=await readDurableSession(r.sessionState),o=findSessionTaskEntry(a.state,r.taskId),s=(getAgentHandleStore(a.state)?.handles??[]).find(e=>e.phase===`addressed`&&e.identity.id===o?.metadata.agentId);if(o===void 0||s?.phase!==`addressed`||s.address.sessionId!==r.hookPayload.childSessionId)return{accepted:!1,sessionState:r.sessionState};let c=await readLatestTaskView({taskRunId:o.taskRunId}),l=r.hookPayload.event.requests.map(e=>e.requestId),u=c?.inputRequests?.map(e=>typeof e==`object`&&e&&!Array.isArray(e)?Reflect.get(e,`requestId`):void 0)??[];if(c?.status!==`input_required`||!r.hookPayload.event.requests.every(isInputRequest)||c.metadata.mode!==(s.address.kind===`agent/remote`?`remote`:`local`)||c.metadata.agentId!==o.metadata.agentId||c.executor?.childSessionId!==r.hookPayload.childSessionId||new Set(l).size!==l.length||l.length!==u.length||l.some((e,t)=>e!==u[t]))return{accepted:!1,sessionState:r.sessionState};let d=namespaceTaskInputRequests(r.hookPayload,r.taskId),f=toProxyInputRequestEntries(d,r.taskId).map(([e,t],n)=>{let i=r.hookPayload.event.requests[n].requestId;return[e,{...t,childRequestId:i}]});if(s.address.kind===`agent/remote`){let t=createRemoteTaskInputCallbackUrl(s.address.url,createEveTaskInputRoutePath(createTaskInputCapabilityToken(r.hookPayload.childContinuationToken)));f=f.map(([e,n])=>[e,{...n,childResponseUrl:t}])}let p=upsertProxyInputRequestState({entries:f,forChildContinuationToken:r.hookPayload.childContinuationToken,state:a.state});return{accepted:!0,hookPayload:d,sessionState:{...r.sessionState,hasProxyInputRequests:!0,snapshot:{session:{...a,state:p},version:r.sessionState.version}}}}function namespaceTaskInputRequests(e,t){return{...e,event:{...e.event,requests:e.event.requests.map(e=>({...e,requestId:createTaskInputRequestId(t,e.requestId)}))}}}async function acceptTaskAuthorizationEventStep(e){"use step";let t=await readDurableSession(e.sessionState),r=findSessionTaskEntry(t.state,e.taskId);if(r===void 0)return!1;let i=(getAgentHandleStore(t.state)?.handles??[]).find(e=>e.phase===`addressed`&&e.identity.id===r.metadata.agentId);if(i?.phase!==`addressed`||i.address.sessionId!==e.hookPayload.childSessionId)return!1;let a=await readLatestTaskView({taskRunId:r.taskRunId});return a!==void 0&&!isTerminalTaskStatus(a.status)&&a.executor?.childSessionId===e.hookPayload.childSessionId&&a.metadata.agentId===r.metadata.agentId}async function recordTerminalTaskViewsStep(e){"use step";let t=await readDurableSession(e.sessionState),n=t.state;for(let t of e.views)n=cacheTerminalTaskView(n,t),t.executor?.lifecycle===`terminal`&&(n=removeTaskAgentAddressFromState(n,t.metadata.agentId));return n===t.state?e.sessionState:{...e.sessionState,snapshot:{session:{...t,state:n},version:e.sessionState.version}}}export{acceptTaskAuthorizationEventStep,recordTaskInputRequestStep,recordTerminalTaskViewsStep};

package/dist/src/execution/tasks/parent/run-parent.d.ts

@@ -0,0 +1,72 @@
+import type { TaskRunWorkflowInput } from "#execution/tasks/child/workflow.js";
+import { type TaskCommand, type TaskRunInboundPayload, type TaskView } from "#tasks/types.js";
+/**
+ * Node-side controls for durable task runs — the generic transport layer.
+ * This module only speaks `TaskCommand`/`TaskView`; it knows nothing about
+ * subagents, receipts, or the session index. Caller-specific policy (e.g.
+ * subagent delegation in `delegate.ts`) composes these primitives.
+ *
+ * Every export must be called from inside a `"use step"` body; none of
+ * these are steps themselves so dispatch and tool steps can compose them
+ * inside one durable boundary.
+ */
+/** Starts the durable run owning one task's lifecycle. */
+export declare function startTaskRun(input: TaskRunWorkflowInput): Promise<void>;
+/** Resolves the task run that won ownership of one replay-stable command token. */
+export declare function waitForTaskCommandOwner(input: {
+    readonly taskInboxToken: string;
+}): Promise<{
+    readonly runId: string;
+}>;
+/**
+ * Submits one command to a task run.
+ *
+ * `unreachable` means the hook is not resumable — either the run
+ * already finished and disposed it (the task is terminal; read the
+ * final view) or, right after creation, the freshly started run has
+ * not registered it yet. Senders racing that startup window pass
+ * `retryUnreachable`; senders addressing an established task treat
+ * `unreachable` as the terminal signal.
+ */
+export declare function sendTaskCommand(input: {
+    readonly command: TaskCommand;
+    readonly taskInboxToken: string;
+    readonly retryUnreachable?: {
+        readonly attempts: number;
+        readonly delayMs: number;
+    };
+}): Promise<"delivered" | "unreachable">;
+/** Delivers one command and returns the accepting task workflow's run id. */
+export declare function sendTaskCommandToOwner(input: {
+    readonly command: TaskCommand;
+    readonly taskInboxToken: string;
+    readonly retryUnreachable?: {
+        readonly attempts: number;
+        readonly delayMs: number;
+    };
+}): Promise<{
+    readonly runId: string;
+} | undefined>;
+/**
+ * Hands one non-command inbound payload to a task run.
+ *
+ * Used for payloads the run must act on before it may record them —
+ * today only answered input batches, which it forwards to the child
+ * first. `unreachable` means the task already finished and disposed its
+ * hook, so the payload is stale by definition.
+ */
+export declare function sendTaskInboundPayload(input: {
+    readonly taskInboxToken: string;
+    readonly payload: TaskRunInboundPayload;
+}): Promise<"delivered" | "unreachable">;
+/**
+ * Reads the latest view a task run has published, or `undefined`
+ * when the run has not committed its first view yet (the caller
+ * already holds the creation receipt, which is `working`).
+ *
+ * Views are trusted without re-validation: the task run is the
+ * single writer and every write passed the transition function.
+ */
+export declare function readLatestTaskView(input: {
+    readonly taskRunId: string;
+}): Promise<TaskView | undefined>;

package/dist/src/execution/tasks/parent/run-parent.js

@@ -0,0 +1 @@
+import{startWorkflowPreferLatest,taskRunWorkflowReference,waitForCommandHookOwner}from"#execution/workflow-runtime.js";import{getRun,resumeHook}from"#internal/workflow/runtime.js";import{isTaskWorkflowTargetGone}from"#execution/tasks/workflow-target.js";import{TASK_VIEW_STREAM_NAMESPACE}from"#tasks/types.js";const TASK_VIEW_READ_TIMEOUT_MS=1e4;async function startTaskRun(n){await startWorkflowPreferLatest(taskRunWorkflowReference,[n])}async function waitForTaskCommandOwner(e){return await waitForCommandHookOwner(e.taskInboxToken)}async function sendTaskCommand(e){return await sendTaskCommandToOwner(e)===void 0?`unreachable`:`delivered`}async function sendTaskCommandToOwner(e){let t={command:e.command,kind:`task-command`},n=Math.max(1,e.retryUnreachable?.attempts??1);for(let r=0;;r+=1)try{let n=await resumeHook(e.taskInboxToken,t);if(typeof n!=`object`||!n||!(`runId`in n)||typeof n.runId!=`string`)throw Error(`Task inbox hook "${e.taskInboxToken}" returned no owner run id.`);return{runId:n.runId}}catch(t){if(!isTaskWorkflowTargetGone(t))throw t;if(r+1>=n)return;await new Promise(t=>setTimeout(t,e.retryUnreachable?.delayMs??250))}}async function sendTaskInboundPayload(e){try{return await resumeHook(e.taskInboxToken,e.payload),`delivered`}catch(e){if(!isTaskWorkflowTargetGone(e))throw e;return`unreachable`}}async function readLatestTaskView(e){let t=getRun(e.taskRunId).getReadable({namespace:TASK_VIEW_STREAM_NAMESPACE,startIndex:-1}),n=await t.getTailIndex(),i=t.getReader();try{return n<0?void 0:await readWithTimeout(i,`latest task view`)}finally{await i.cancel(`eve task view read complete`).catch(()=>{}),i.releaseLock()}}async function readWithTimeout(e,t){let n;try{let r=await Promise.race([e.read().then(e=>({kind:`read`,read:e})),new Promise(e=>{n=setTimeout(()=>e({kind:`timeout`}),TASK_VIEW_READ_TIMEOUT_MS)})]);if(r.kind===`timeout`)throw Error(`Timed out reading ${t} after ${TASK_VIEW_READ_TIMEOUT_MS}ms.`);return r.read.done?void 0:r.read.value}finally{n!==void 0&&clearTimeout(n)}}export{readLatestTaskView,sendTaskCommand,sendTaskCommandToOwner,sendTaskInboundPayload,startTaskRun,waitForTaskCommandOwner};