@sgtbeatdown/pi-tasks 0.1.4 → 0.1.6

package/README.md

@@ -26,16 +26,27 @@ Wolfpack's relay owns durable mailbox delivery and peer forwarding; Pi owns task
 
 ### v2 delegation workflow
 
-1. create or select a role session. For a disposable worker, omit an initial model prompt: `wolfpack agent spawn <project> --name <task-role> --json`. Put all worker instructions in `agent_task_send.task` so the new Pi process can become idle before assignment.
+Configure Pi role models with `WOLFPACK_IMPLEMENTER_MODEL` and `WOLFPACK_REVIEWER_MODEL`; they default to `openai-codex/gpt-5.6-terra` and `openai-codex/gpt-5.6-sol`, respectively. Explicit user or project choices override those defaults.
+
+```bash
+IMPLEMENTER_MODEL="${WOLFPACK_IMPLEMENTER_MODEL:-openai-codex/gpt-5.6-terra}"
+REVIEWER_MODEL="${WOLFPACK_REVIEWER_MODEL:-openai-codex/gpt-5.6-sol}"
+```
+
+1. create or select a role session. For a disposable worker, omit an initial assignment prompt and pass the resolved role model: `wolfpack agent spawn <project> --name <task-role> --model "$IMPLEMENTER_MODEL" --json` (or `"$REVIEWER_MODEL"` for review). Put all worker instructions in `agent_task_send.task` so the new Pi process can become idle before assignment.
 2. verify structured session readiness, wait for extension registration, and read `taskEndpoint` from `wolfpack session status <session> --json`.
 3. call `agent_task_send` with that endpoint and the complete task instructions. Keep working; use `agent_task_status` or `agent_task_inbox` for structured evidence, and call `agent_task_wait` only when the user explicitly asks to block.
 4. use `agent_task_message` for durable questions, answers, and information. The receiver calls `agent_task_done` as its final action; no completion prose follows.
 5. independently verify the result, call `agent_task_ack({ taskId })` once for that terminal task, then explicitly retain or close only the role sessions the parent spawned.
 
+Coordinator-capable agents may delegate further when justified, and the spawning coordinator owns each child's lifecycle. After terminal completion and acknowledgment, deliberately retain the child or run `wolfpack kill <stable-session-id> --json`, then verify that exact ID is absent from `wolfpack list --json`. Never use `wolfpack session send`, `/exit`, or `/quit` for cleanup; terminal input is not Wolfpack teardown.
+
 ### v2 worker-only execution gate
 
 Set `PI_TASK_WORKER=1` only when launching a task-only worker. The exact value enables a fail-closed model `tool_call` gate; an absent value or any other value leaves ordinary interactive Pi behavior unchanged. Before assignment, only `agent_task_inbox`, `agent_task_status`, and `agent_task_wait` are allowed. Other current and future model tools are blocked with the stable reason `PI_TASK_WORKER_ASSIGNMENT_REQUIRED`. Explicit user `!`/`!!` shell commands are outside Pi's model `tool_call` event and are not intercepted.
 
+`PI_TASK_WORKER=1` sessions are leaf roles. Workers cannot call `agent_task_send`; workers cannot call `agent_task_cancel`; workers cannot call `agent_task_ack`. These coordinator-tool attempts are blocked with the stable reason `PI_TASK_WORKER_COORDINATION_FORBIDDEN`, not the pre-assignment reason. `agent_task_message` is limited to the eligible incorporated assignment named by its input `taskId`. Generic role-orchestration guidance applies only to non-worker coordinators.
+
 The gate opens only when the current Pi session contains a structured `pi-tasks-event` entry for `task.created` and the same event belongs to a locally persisted active task targeted to the current endpoint. Rendered prompt text, terminal output, unknown events, foreign tasks, and stale terminal tasks do not authorize execution. On restart, durable session evidence reopens the gate only while the matching local task remains eligible.
 
 Preflighting `agent_task_done` marks that task as closing before sibling calls are preflighted. Ordinary tools remain blocked for a closing, pending-terminal, accepted-terminal, or `delivery_blocked` task; an idempotent `agent_task_done` retry for that same assigned task remains allowed. Another independently active assignment can still authorize work.
@@ -138,7 +149,7 @@ On start or resume it rebuilds incorporated IDs from the full durable session en
 
 ## parent workflow
 
-1. create or select a Wolfpack Pi session with the canonical session-control workflow and retain its stable broker ID. Spawn a disposable worker without an initial model prompt using `wolfpack agent spawn <project> --name <task-role> --json` so it reaches idle before assignment; put worker instructions in `agent_task_send.task`.
+1. create or select a Wolfpack Pi session with the canonical session-control workflow and retain its stable broker ID. Spawn a disposable worker without an initial assignment prompt using `wolfpack agent spawn <project> --name <task-role> --model "$IMPLEMENTER_MODEL" --json` (or `"$REVIEWER_MODEL"` for review) so it reaches idle before assignment; put worker instructions in `agent_task_send.task`.
 2. before remote dispatch, complete Wolfpack's [Live-peer readiness checklist](https://github.com/almogdepaz/wolfpack/blob/main/docs/task-gateway.md#live-peer-readiness-checklist) and retain operator-recorded package/reload evidence; only then check the target's local requirements and send compact instructions with curated context and selected refs when they save receiver investigation.
 3. keep working; use `agent_task_status` or `agent_task_inbox` for structured follow-up, and `agent_task_message` for questions, answers, and decisions.
 4. verify cited files, diffs, tests, and paths-only artifact metadata independently before reporting success.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sgtbeatdown/pi-tasks",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Durable Pi agent delegation through the Wolfpack task gateway.",
   "module": "src/index.ts",
   "exports": {

package/skills/wolfpack-pi-task-delegation/SKILL.md

@@ -7,27 +7,51 @@ description: Use when opening, selecting, delegating to, checking, or cleaning u
 
 use `wolfpack-tailnet-control` for session control. this skill covers endpoint-owned v2 task lifecycle, structured handoffs, and parent verification. The package default is the v2 extension described by Wolfpack's [relay v2 control-api contract](https://github.com/almogdepaz/wolfpack/blob/main/docs/control-api-schema.md#pi-tasks-relay-v2-boundary).
 
+## choose one assignment mode
+
+choose exactly one mode for the initial assignment:
+
+- **full-startup mode:** spawn with the complete `--plan`, `--prompt-file`, or concise `--prompt`. do not call `agent_task_send` for that same work.
+- **endpoint mode:** spawn without a startup plan or prompt, obtain the structured `taskEndpoint`, then put the complete assignment in one `agent_task_send.task`.
+
+never combine a plan-driven spawn with a narrower endpoint task. prefer one cohesive implementation handoff per approved PR or phase; split only at a real approval, design, isolation, or blocker boundary—not per issue, commit, finding, or verification checkpoint. the remaining v2 workflow below describes endpoint mode.
+
+## role model selection
+
+Pi role models are explicit and configurable at spawn time:
+
+```bash
+IMPLEMENTER_MODEL="${WOLFPACK_IMPLEMENTER_MODEL:-openai-codex/gpt-5.6-terra}"
+REVIEWER_MODEL="${WOLFPACK_REVIEWER_MODEL:-openai-codex/gpt-5.6-sol}"
+```
+
+Pass `--model "$IMPLEMENTER_MODEL"` when spawning the editing implementer and `--model "$REVIEWER_MODEL"` when spawning the read-only reviewer. an explicit user or project model choice overrides the environment/default. never infer role or model from the session name, and never omit the resolved model because the current parent default may differ.
+
 ## v2 requirements and addressing
 
 - load this package's default extension in every participating Pi process and set `WOLFPACK_SESSION_NAME`. Set `WOLFPACK_PORT` only when the local Wolfpack control port differs from `18790`.
 - address `agent_task_send` targets only as `to: { relay, id }`. For the default Wolfpack adapter, the relay is `wolfpack-pi-tasks-v2` and the ID is opaque.
-- create a disposable worker without an initial model prompt: `wolfpack agent spawn <project> --name <task-role> --json`. Do not start a disposable worker with a blocking “wait for assignments” prompt. Put the complete instructions in `agent_task_send.task`.
+- create a disposable worker without an initial assignment prompt: `wolfpack agent spawn <project> --name <task-role> --model "$IMPLEMENTER_MODEL" --json` (or `"$REVIEWER_MODEL"` for review). Do not start a disposable worker with a blocking “wait for assignments” prompt. Put the complete instructions in `agent_task_send.task`.
 - after the target extension registers, run structured session control (`wolfpack session status <session> --json`) and read its `taskEndpoint`. Do not derive endpoint IDs from session names, broker IDs, terminal labels, output, or prose.
 - pass the returned endpoint without translation:
 
 ```json
 {
   "to": { "relay": "wolfpack-pi-tasks-v2", "id": "target-opaque-endpoint-id" },
-  "task": "implement the narrow change and run focused tests",
-  "timeoutMs": 1800000
+  "task": "implement the approved phase and run focused tests",
+  "timeoutMs": 3600000
 }
 ```
 
-The default `agent_task_send` schema is exactly `to`, `task`, and optional `timeoutMs`. v1-only fields such as context, role, metadata, preflight, idempotency keys, and completion prompts are not silently accepted or translated.
+The default `agent_task_send` schema is exactly `to`, `task`, and optional `timeoutMs`. v1-only fields such as context, role, metadata, preflight, idempotency keys, and completion prompts are not silently accepted or translated. use at least `3600000` milliseconds for coding assignments; timeout is a failure deadline, not a progress-poll interval.
 
 ## phase roles and handoffs
 
-For a multi-step project phase, retain one persistent implementer and one persistent read-only reviewer. Reuse a healthy role session for corrections and follow-up review; a completed task finishes one assignment, not the underlying session. Do not rotate a healthy role session for routine corrections. Rotate only for phase completion, material context degradation, harness failure, or required specialist independence. Keep at most one active assignment per role unless the user explicitly approves parallel work.
+For a multi-step project phase, retain one persistent implementer and one persistent read-only reviewer. Give the implementer the whole approved phase, including required commit ordering and focused verification, rather than opening one task per issue or checkpoint. Reuse a healthy role session for corrections and follow-up review; a completed task finishes one assignment, not the underlying session. Do not rotate a healthy role session for routine corrections. Rotate only for phase completion, material context degradation, harness failure, or required specialist independence. Keep at most one active assignment per role unless the user explicitly approves parallel work.
+
+A coordinator-capable agent may delegate further when the quality or throughput gain justifies it. The spawning coordinator owns each child's complete lifecycle: record the stable session ID, acknowledge its terminal task once, then deliberately retain the child or close it with `wolfpack kill <stable-session-id> --json` and verify that exact ID is absent from `wolfpack list --json`.
+
+`PI_TASK_WORKER=1` sessions are leaf roles. Workers cannot call `agent_task_send`; workers cannot call `agent_task_cancel`; workers cannot call `agent_task_ack`. These coordinator-tool attempts are blocked with the stable reason `PI_TASK_WORKER_COORDINATION_FORBIDDEN`, not the pre-assignment reason. They may use `agent_task_message` only for the eligible incorporated assignment named by its input `taskId`. Generic role-orchestration guidance applies only to non-worker coordinators. Task workers must not create, rotate, or close Wolfpack sessions through shell or session-control tools.
 
 After every verified and acknowledged terminal task, explicitly retain a parent-spawned session only when concrete follow-up is likely; otherwise close it through canonical Wolfpack session control. Workers never close their own sessions. terminal `send` is only for explicit human steering; it is not task state, completion evidence, or a substitute for `agent_task_message`.
 
@@ -38,17 +62,17 @@ After every verified and acknowledged terminal task, explicitly retain a parent-
 | assignment completion | worker | `agent_task_done` | unchanged |
 | task acknowledgment | parent | `agent_task_ack` | unchanged |
 | role session retention | parent | `none` | retained for reuse |
-| role session teardown | parent | `wolfpack kill <session-or-id> --json` | exact stable session id terminated |
-| teardown verification | parent | `wolfpack list --json` | exact stable session id absent |
-| Pi exit | none | `/quit` | not Wolfpack teardown |
+| role session teardown | spawning coordinator | `wolfpack kill <stable-session-id> --json` | exact stable session id terminated |
+| teardown verification | spawning coordinator | `wolfpack list --json` | exact stable session id absent |
+| Pi exit | none | `/exit` or `/quit` | not Wolfpack teardown |
 
-Assignment completion ends the assigned task, not the reusable role session. When no further reuse is likely, the parent—not the worker—must pass the exact stable session ID to `wolfpack kill <session-or-id> --json`, then inspect `wolfpack list --json` and verify that ID is absent. `/quit` exits Pi; it is not Wolfpack teardown. Workers never close themselves.
+Assignment completion ends the assigned task, not the reusable role session. When no further reuse is likely, the coordinator that spawned the role—not the worker itself—must pass the exact stable session ID to `wolfpack kill <stable-session-id> --json`, then inspect `wolfpack list --json` and verify that ID is absent. Never use `wolfpack session send`, `/exit`, or `/quit` for cleanup: they are terminal interaction, not Wolfpack teardown. Do not guess lifecycle commands. Workers never close themselves.
 
 ## v2 workflow
 
 1. create or select the role session, verify its structured project and terminal readiness, then obtain its registered `taskEndpoint`.
 2. call `agent_task_send` with the opaque endpoint and concise instructions in `task`. The tool returns after relay acceptance only, not Pi insertion or model execution. If submission reports a retryable delivery error after local persistence, use the structured task ID from the error and inspect it rather than creating an unrelated replacement.
-3. keep working. Use `agent_task_status` or `agent_task_inbox` for structured evidence. Call `agent_task_wait` only when the user explicitly asks to block.
+3. keep working. Use `agent_task_status` or `agent_task_inbox` only at meaningful checkpoints or when progress evidence is needed; do not turn status checks into lifecycle chatter. Call `agent_task_wait` only when the user explicitly asks to block.
 4. use `agent_task_message` for durable `question`, `answer`, or `information` flow. Do not use rendered text, terminal output, or logs as lifecycle evidence.
 5. assignees call `agent_task_done` as their final action with the assigned task ID, terminal status, concise summary, and optional structured result, error, and artifact declarations. Report source modifications in `result.changedFiles`; artifacts are receiver-project-relative regular files for a parent to inspect, not changed-file lists: `{ "result": { "changedFiles": ["src/extension.ts"] }, "artifacts": [{ "path": "verification/task-2.md" }] }`. No prose completion afterward.
 6. the parent independently verifies files, diff, tests, and artifacts. Then call `agent_task_ack({ taskId })` for that one terminal task and explicitly retain or close the spawned role session.

package/src/extension.ts

@@ -5,9 +5,9 @@ import { Type } from "typebox";
 
 import { abortableSleep } from "./abortable-sleep";
 import { deliverTaskInbox, incorporatedTaskEvents } from "./task-inbox";
-import { TaskOutboxDeliveryError, TaskProtocolError } from "./task-protocol";
+import { TaskDeliveryEvidenceState, TaskDeliveryStage, TaskOutboxDeliveryError, TaskProtocolError } from "./task-protocol";
 import { createWolfpackTaskCore } from "./wolfpack-task-relay";
-import type { TaskCore } from "./task-core";
+import type { SubmitIntentInput, SubmitIntentOutcome, TaskCore } from "./task-core";
 import type { TaskEndpoint, TaskSnapshot } from "./task-protocol";
 
 const DEFAULT_TASK_TIMEOUT_MS = 30 * 60 * 1_000;
@@ -18,7 +18,9 @@ const TARGET_NOT_REGISTERED_CODE = "TARGET_NOT_REGISTERED";
 const WAIT_POLL_MS = 250;
 const SUMMARY_MAX_CHARS = 1_200;
 const PRE_ASSIGNMENT_TOOLS = new Set(["agent_task_inbox", "agent_task_status", "agent_task_wait"]);
+const COORDINATOR_ONLY_TASK_TOOLS = new Set(["agent_task_send", "agent_task_cancel", "agent_task_ack"]);
 export const WORKER_GATE_DENIAL_CODE = "PI_TASK_WORKER_ASSIGNMENT_REQUIRED";
+export const WORKER_COORDINATION_FORBIDDEN_CODE = "PI_TASK_WORKER_COORDINATION_FORBIDDEN";
 
 const EndpointParams = Type.Object({
 	relay: Type.String({ minLength: 1, description: "relay identifier" }),
@@ -62,7 +64,6 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 	let inboxContext: ExtensionContext | undefined;
 	let backgroundTimer: ReturnType<typeof setInterval> | undefined;
 	let lifecycleEpoch = 0;
-	const pendingInsertions = new Set<string>();
 	const closingTaskIds = new Set<string>();
 	const workerGateEnabled = process.env.PI_TASK_WORKER === "1";
 	const configuredCore: ConfiguredCoreFactory = core === undefined ? createConfiguredCoreLoader(createCore) : async (): Promise<TaskCore> => core;
@@ -102,9 +103,10 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 			sendMessage(message, options) { if (isCurrent()) pi.sendMessage(message, options); },
 			appendEntry(customType, data) { if (isCurrent()) pi.appendEntry(customType, data); },
 		}, guardedCore, {
+			isIdle: (): boolean => isCurrent() && context.isIdle(),
 			hasPendingMessages: (): boolean => !isCurrent() || context.hasPendingMessages(),
 			sessionManager: context.sessionManager,
-		}, pendingInsertions, signal);
+		}, signal);
 		return outboxError;
 	});
 	const refreshLifecycle = async (context: ExtensionContext, epoch: number): Promise<void> => {
@@ -130,11 +132,12 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 
 	pi.on("tool_call", async (event, context) => {
 		if (!workerGateEnabled || PRE_ASSIGNMENT_TOOLS.has(event.toolName)) return undefined;
+		if (COORDINATOR_ONLY_TASK_TOOLS.has(event.toolName)) return { block: true, reason: WORKER_COORDINATION_FORBIDDEN_CODE };
 		try {
 			const activeCore = await configuredCore(context.signal);
 			const assignments = assignedWorkerTasks(activeCore, context.sessionManager.getEntries());
+			const taskId = inputTaskId(event.input);
 			if (event.toolName === "agent_task_done") {
-				const taskId = isRecord(event.input) && typeof event.input.taskId === "string" ? event.input.taskId : undefined;
 				const assigned = taskId === undefined ? undefined : assignments.find((task) => task.taskId === taskId);
 				if (assigned === undefined || (!eligibleWorkerTask(assigned, closingTaskIds) && assigned.terminalDelivery.state === "not_submitted" && !closingTaskIds.has(assigned.taskId))) {
 					return { block: true, reason: WORKER_GATE_DENIAL_CODE };
@@ -142,6 +145,10 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 				closingTaskIds.add(assigned.taskId);
 				return undefined;
 			}
+			if (event.toolName === "agent_task_message") {
+				const assigned = taskId === undefined ? undefined : assignments.find((task) => task.taskId === taskId);
+				return assigned !== undefined && eligibleWorkerTask(assigned, closingTaskIds) ? undefined : { block: true, reason: WORKER_GATE_DENIAL_CODE };
+			}
 			if (assignments.some((task) => eligibleWorkerTask(task, closingTaskIds))) return undefined;
 		} catch {
 			// Authorization evidence unavailable or malformed: fail closed with the stable public reason.
@@ -150,7 +157,6 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 	});
 
 	pi.on("session_start", async (_event, context) => {
-		pendingInsertions.clear();
 		closingTaskIds.clear();
 		const epoch = ++lifecycleEpoch;
 		inboxContext = context;
@@ -166,8 +172,12 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 		inboxContext = context;
 		await refreshLifecycle(context, epoch);
 	});
+	pi.on("agent_settled", async (_event, context) => {
+		const epoch = lifecycleEpoch;
+		inboxContext = context;
+		await refreshLifecycle(context, epoch);
+	});
 	pi.on("session_shutdown", () => {
-		pendingInsertions.clear();
 		closingTaskIds.clear();
 		lifecycleEpoch += 1;
 		if (backgroundTimer) clearInterval(backgroundTimer);
@@ -187,10 +197,13 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 	});
 	pi.registerTool({
 		name: "agent_task_status", label: "Task Status", description: "Read local endpoint-owned task state; status is unavailable while its origin is offline.", parameters: TaskIdParams,
-		async execute(_id, params, signal) {
+		async execute(_id, params, signal, _onUpdate, context) {
 			try {
-				const task = (await configuredCore(signal)).getTask(params.taskId);
-				return task ? toolResult(task, `## task status\n- task: \`${task.taskId}\`\n- status: ${task.status}`) : taskError(new Error("unknown local task"));
+				const activeCore = await configuredCore(signal);
+				const task = activeCore.getTask(params.taskId);
+				if (!task) return taskError(new Error("unknown local task"));
+				const deliveryEvidence = taskDeliveryEvidence(task);
+				return toolResult({ ...task, deliveryEvidence }, `## task status\n- task: \`${task.taskId}\`\n- status: ${task.status}${receiverAssignment(activeCore, task, context)}${deliveryEvidenceText(deliveryEvidence)}`);
 			} catch (error) { return taskError(error); }
 		}, renderResult(result, _options, theme) { return new Text(theme.fg("accent", text(result))); },
 	});
@@ -213,11 +226,12 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 	});
 	pi.registerTool({
 		name: "agent_task_inbox", label: "Task Inbox", description: "Read local task records after processing relay deliveries without acknowledging task lifecycle.", parameters: Type.Object({}),
-		async execute(_id, _params, signal) {
+		async execute(_id, _params, signal, _onUpdate, context) {
 			try {
 				await refreshInbox(signal);
-				const tasks = (await configuredCore(signal)).listTasks();
-				return toolResult({ tasks }, `## task inbox\n${tasks.map((task) => `- \`${task.taskId}\`: ${task.status}`).join("\n") || "- empty"}`);
+				const activeCore = await configuredCore(signal);
+				const tasks = activeCore.listTasks();
+				return toolResult({ tasks }, `## task inbox\n${tasks.map((task) => `- \`${task.taskId}\`: ${task.status}${receiverAssignment(activeCore, task, context)}`).join("\n") || "- empty"}`);
 			} catch (error) { return taskError(error); }
 		},
 		renderResult(result, _options, theme) { return new Text(theme.fg("accent", text(result))); },
@@ -229,7 +243,17 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 	});
 	pi.registerTool({
 		name: "agent_task_cancel", label: "Cancel Agent Task", description: "Persist cancellation before relay submission.", parameters: TaskIdParams,
-		async execute(_id, params, signal) { try { await (await configuredCore(signal)).submitIntent({ taskId: params.taskId, type: "task.cancelled", payload: {} }, signal); return toolResult({ taskId: params.taskId }, `## task cancellation requested\n- task: \`${params.taskId}\``); } catch (error) { return taskError(error); } },
+		async execute(_id, params, signal) {
+			try {
+				const activeCore = await configuredCore(signal);
+				try {
+					await activeCore.submitIntent({ taskId: params.taskId, type: "task.cancelled", payload: {} }, signal);
+					return toolResult({ taskId: params.taskId }, `## task cancellation requested\n- task: \`${params.taskId}\``);
+				} catch (error) {
+					return blockedCancellationResult(activeCore, params.taskId, error) ?? taskError(error);
+				}
+			} catch (error) { return taskError(error); }
+		},
 		renderResult(result, _options, theme) { return new Text(theme.fg("accent", text(result))); },
 	});
 	pi.registerTool({
@@ -241,8 +265,32 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 		name: "agent_task_done", label: "Complete Agent Task", description: "Persist a terminal task intent before relay submission.", parameters: DoneParams,
 		async execute(_id, params, signal) {
 			try {
-				await (await configuredCore(signal)).submitIntent({ taskId: params.taskId, type: `task.${params.status}`, payload: { summary: params.summary, ...(params.result === undefined ? {} : { result: params.result }), ...(params.error === undefined ? {} : { error: params.error }), ...(params.artifacts === undefined ? {} : { artifacts: params.artifacts }) } }, signal);
-				return { ...toolResult({ taskId: params.taskId }, `## task ${params.status}\n- task: \`${params.taskId}\`\n- ${params.summary}`), terminate: true };
+				const activeCore = await configuredCore(signal);
+				let submission: SubmitIntentOutcome | undefined;
+				try {
+					const input: SubmitIntentInput = { taskId: params.taskId, type: `task.${params.status}`, payload: { summary: params.summary, ...(params.result === undefined ? {} : { result: params.result }), ...(params.error === undefined ? {} : { error: params.error }), ...(params.artifacts === undefined ? {} : { artifacts: params.artifacts }) } };
+					if (activeCore.submitIntentWithOutcome) submission = await activeCore.submitIntentWithOutcome(input, signal);
+					else await activeCore.submitIntent(input, signal);
+				} catch (error) {
+					return blockedDoneResult(activeCore, params.taskId, params.status, error) ?? taskError(error);
+				}
+				const task = activeCore.getTask(params.taskId);
+				if (!task) return taskError(new Error("unknown local task"));
+				if (submission?.authority === "origin" && submission.canonicalEvent.type === "task.late_terminal") {
+					return {
+						...toolResult({ taskId: params.taskId, requestedStatus: params.status, observedCanonicalStatus: task.status, canonicalEvent: submission.canonicalEvent }, `## canonical late terminal recorded\n- task: \`${params.taskId}\`\n- requested status: ${params.status}\n- canonical status remains: ${task.status}\n- ${params.summary}`),
+						terminate: true,
+					};
+				}
+				if (submission?.authority === "origin" && task.status === params.status) {
+					return {
+						...toolResult({ taskId: params.taskId, requestedStatus: params.status, observedCanonicalStatus: task.status, canonicalCompletion: { state: "confirmed", status: task.status } }, `## task ${task.status}\n- task: \`${params.taskId}\`\n- canonical status: ${task.status}\n- ${params.summary}`),
+						terminate: true,
+					};
+				}
+				const deliveryOutcome = task.terminalDelivery.state === "accepted" ? "accepted" : "recorded";
+				const result = toolResult({ taskId: params.taskId, requestedStatus: params.status, observedCanonicalStatus: task.status, terminalDelivery: task.terminalDelivery }, `## terminal intent ${deliveryOutcome}\n- task: \`${params.taskId}\`\n- requested status: ${params.status}\n- observed canonical status: ${task.status}\n- ${params.summary}`);
+				return task.terminalDelivery.state === "accepted" || terminal(task.status) ? { ...result, terminate: true } : result;
 			} catch (error) { return taskError(error); }
 		}, renderResult(result, _options, theme) { return new Text(theme.fg("accent", text(result))); },
 	});
@@ -264,6 +312,37 @@ export default function piTasks(pi: ExtensionAPI): void {
 	registerAgentTaskTools(pi);
 }
 
+interface TaskDeliveryEvidence {
+	readonly receiverPersistence: "not_confirmed" | "confirmed";
+	readonly piInsertion: "not_confirmed" | "blocked" | "confirmed";
+	readonly wakeAcceptance: "not_confirmed" | "pending" | "confirmed";
+	readonly modelExecution: "not_evidenced";
+}
+
+function taskDeliveryEvidence(task: TaskSnapshot): TaskDeliveryEvidence {
+	let receiverPersistence: TaskDeliveryEvidence["receiverPersistence"] = "not_confirmed";
+	let piInsertion: TaskDeliveryEvidence["piInsertion"] = "not_confirmed";
+	let wakeAcceptance: TaskDeliveryEvidence["wakeAcceptance"] = "not_confirmed";
+	const assignmentEventId = task.events.find((event) => event.type === "task.created")?.eventId;
+	for (const event of task.events) {
+		if (event.type !== "task.delivery_receipt" || event.payload.eventId !== assignmentEventId) continue;
+		if (event.payload.stage === TaskDeliveryStage.receiverPersisted) receiverPersistence = "confirmed";
+		if (event.payload.stage === TaskDeliveryStage.piInsertion && event.payload.state === TaskDeliveryEvidenceState.blocked) piInsertion = "blocked";
+		if (event.payload.stage === TaskDeliveryStage.piInserted || event.payload.stage === undefined) {
+			receiverPersistence = "confirmed";
+			piInsertion = "confirmed";
+		}
+		if (event.payload.stage === TaskDeliveryStage.wakeRequested) wakeAcceptance = "pending";
+		if (event.payload.stage === TaskDeliveryStage.wakeAccepted) wakeAcceptance = "confirmed";
+	}
+	return { receiverPersistence, piInsertion, wakeAcceptance, modelExecution: "not_evidenced" };
+}
+
+function deliveryEvidenceText(evidence: TaskDeliveryEvidence): string {
+	const insertion = evidence.piInsertion === "blocked" ? "blocked; retryable" : evidence.piInsertion;
+	return `\n- receiver persistence: ${evidence.receiverPersistence}\n- Pi insertion: ${insertion}\n- wake acceptance: ${evidence.wakeAcceptance}\n- model execution: ${evidence.modelExecution}`;
+}
+
 function toolResult(details: unknown, markdown: string): AgentToolResult<unknown> {
 	return { content: [{ type: "text", text: markdown }], details };
 }
@@ -276,6 +355,44 @@ function taskError(error: unknown): AgentToolResult<unknown> {
 	return toolResult({ error: { code: "TASK_ERROR", message, retryable: true } }, `## task error\n- ${message}`);
 }
 
+function blockedCancellationResult(core: TaskCore, taskId: string, error: unknown): AgentToolResult<unknown> | undefined {
+	if (!(error instanceof TaskOutboxDeliveryError) || error.details?.taskId !== taskId) return undefined;
+	const task = core.getTask(taskId);
+	const warning = task === undefined ? undefined : blockedDeliveryWarning(error, task.target);
+	if (task?.status !== "cancelled" || !sameEndpoint(task.origin, core.endpoint) || warning === undefined) return undefined;
+	return toolResult({ taskId, status: "cancelled", warnings: [warning] }, `## task cancelled\n- task: \`${taskId}\`\n- canonical status: cancelled\n- target delivery: blocked; receiver incorporation not confirmed`);
+}
+
+function blockedDoneResult(core: TaskCore, taskId: string, requestedStatus: string, error: unknown): AgentToolResult<unknown> | undefined {
+	if (!(error instanceof TaskOutboxDeliveryError)) return undefined;
+	const task = core.getTask(taskId);
+	if (task === undefined) return undefined;
+	if (!sameEndpoint(task.origin, core.endpoint) && task.terminalDelivery.state === "delivery_blocked" && task.terminalDelivery.intentType === `task.${requestedStatus}`) {
+		return toolResult({
+			taskId,
+			status: task.status,
+			terminalDelivery: task.terminalDelivery,
+			error: { code: error.code, message: error.message, retryable: error.retryable },
+		}, `## terminal intent delivery blocked\n- task: \`${taskId}\`\n- canonical status: ${task.status}\n- canonical completion not confirmed; retry remains allowed`);
+	}
+	const warning = blockedDeliveryWarning(error, task.target);
+	if (!sameEndpoint(task.origin, core.endpoint) || task.status !== requestedStatus || warning === undefined) return undefined;
+	return {
+		...toolResult({ taskId, status: task.status, warnings: [warning] }, `## task ${task.status}\n- task: \`${taskId}\`\n- canonical status: ${task.status}\n- target delivery: blocked; receiver incorporation not confirmed`),
+		terminate: true,
+	};
+}
+
+function blockedDeliveryWarning(error: TaskOutboxDeliveryError, target: TaskEndpoint): Readonly<Record<string, unknown>> | undefined {
+	if (error.code !== TARGET_NOT_REGISTERED_CODE || error.retryable) return undefined;
+	const details = { ...error.details };
+	delete details.taskId;
+	delete details.envelopeId;
+	delete details.target;
+	delete details.blockedAt;
+	return { code: error.code, message: error.message, retryable: false, delivery: "blocked", target, details };
+}
+
 function outboxFailureStatus(error: unknown): "tasks: relay unavailable" | "tasks: outbox degraded" {
 	return error instanceof TaskOutboxDeliveryError && error.code === TARGET_NOT_REGISTERED_CODE ? "tasks: outbox degraded" : "tasks: relay unavailable";
 }
@@ -284,6 +401,13 @@ function terminal(status: string): boolean {
 	return ["completed", "failed", "cancelled", "timed_out"].includes(status);
 }
 
+function receiverAssignment(core: TaskCore, task: TaskSnapshot, context: Pick<ExtensionContext, "sessionManager">): string {
+	if (task.status !== "active" || sameEndpoint(task.origin, core.endpoint) || !sameEndpoint(task.target, core.endpoint)) return "";
+	const created = task.events.find((event) => event.type === "task.created");
+	if (!created || !incorporatedTaskEvents(context.sessionManager.getEntries()).some((evidence) => evidence.taskId === task.taskId && evidence.eventId === created.eventId)) return "";
+	return `\n\n## task assignment\n${task.task}`;
+}
+
 function assignedWorkerTasks(core: TaskCore, entries: readonly unknown[]): readonly TaskSnapshot[] {
 	const assignments = new Map<string, TaskSnapshot>();
 	for (const evidence of incorporatedTaskEvents(entries)) {
@@ -304,6 +428,10 @@ function sameEndpoint(left: TaskEndpoint, right: TaskEndpoint): boolean {
 	return left.relay === right.relay && left.id === right.id;
 }
 
+function inputTaskId(input: unknown): string | undefined {
+	return isRecord(input) && typeof input.taskId === "string" ? input.taskId : undefined;
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }

package/src/index.ts

@@ -31,5 +31,5 @@ export type {
 	TaskRecord,
 	TaskRelay,
 } from "./task-protocol";
-export type { TaskCore, TaskCoreOptions } from "./task-core";
+export type { SubmitIntentOutcome, TaskCore, TaskCoreOptions } from "./task-core";
 export type { TaskStore, TaskStoreOptions } from "./task-store";

package/src/task-core.ts

@@ -1,8 +1,11 @@
 import {
 	MAX_RELAY_PAYLOAD_BYTES,
+	ORIGIN_CANCELLATION_OPERATION,
 	PARENT_ACKNOWLEDGMENT_OPERATION,
 	TASK_PROTOCOL_VERSION,
 	TERMINAL_INTENT_OPERATION,
+	TaskDeliveryEvidenceState,
+	TaskDeliveryStage,
 	TaskEnvelopeKind,
 	TaskOutboxDeliveryError,
 	TaskProtocolError,
@@ -20,6 +23,7 @@ import type {
 import type { TaskStore } from "./task-store";
 
 const RECEIVE_PAGE_SIZE = 100;
+const DELIVERY_EVIDENCE_OPERATION = "delivery_evidence";
 const TARGET_NOT_REGISTERED_CODE = "TARGET_NOT_REGISTERED";
 const TERMINAL_STATUSES = new Set<TaskRecord["status"]>(["completed", "failed", "cancelled", "timed_out"]);
 const TERMINAL_EVENTS = new Set(["task.completed", "task.failed", "task.cancelled", "task.timed_out"]);
@@ -52,6 +56,10 @@ export interface SubmitIntentInput {
 	readonly payload: Record<string, unknown>;
 }
 
+export type SubmitIntentOutcome =
+	| { readonly authority: "origin"; readonly canonicalEvent: { readonly type: string; readonly reused: boolean } }
+	| { readonly authority: "receiver" };
+
 export interface TaskCore {
 	readonly endpoint: TaskEndpoint;
 	connect(signal?: AbortSignal): Promise<void>;
@@ -62,6 +70,7 @@ export interface TaskCore {
 	receive(signal?: AbortSignal): Promise<readonly RelayDelivery[]>;
 	acknowledgeRelayDelivery(cursor: string, signal?: AbortSignal): Promise<void>;
 	submitIntent(input: SubmitIntentInput, signal?: AbortSignal): Promise<void>;
+	submitIntentWithOutcome?(input: SubmitIntentInput, signal?: AbortSignal): Promise<SubmitIntentOutcome>;
 	recordInsertion(input: { readonly taskId: string; readonly eventId: string }, signal?: AbortSignal): Promise<void>;
 	evaluateTimeouts(signal?: AbortSignal): Promise<void>;
 	acknowledgeParent(taskId: string, signal?: AbortSignal): Promise<void>;
@@ -75,6 +84,36 @@ type ReceivedEnvelope =
 export function createTaskCore(options: TaskCoreOptions): TaskCore {
 	const clock = options.clock ?? { now: (): number => Date.now() };
 	const ids = options.ids ?? (() => crypto.randomUUID());
+	const submitIntentWithOutcome = async (input: SubmitIntentInput, signal?: AbortSignal): Promise<SubmitIntentOutcome> => {
+		if (!RECEIVER_INTENT_TYPES.has(input.type) || !isRecord(input.payload)) throw new TaskProtocolError("INVALID_INTENT", "intent type or payload is invalid");
+		let persistedEnvelopeIds: readonly string[] = [];
+		let outcome: SubmitIntentOutcome | undefined;
+		let receiverTerminal = false;
+		let originCancellation = false;
+		const evidence = deliveryEvidence(input);
+		options.store.transaction(() => {
+			const task = requiredTask(options.store, input.taskId);
+			receiverTerminal = !sameEndpoint(options.endpoint, task.origin) && TERMINAL_EVENTS.has(input.type);
+			originCancellation = sameEndpoint(options.endpoint, task.origin) && input.type === "task.cancelled";
+			const persisted = persistIntent(options, clock.now, ids, task, input, evidence === undefined ? undefined : deliveryEvidenceOperation(evidence));
+			persistedEnvelopeIds = persisted.envelopeIds;
+			outcome = persisted.outcome;
+		});
+		if (evidence !== undefined) {
+			await flushDeliveryEvidence(options, signal, input.taskId, persistedEnvelopeIds, evidence);
+		} else {
+			try {
+				await flush(options, signal, new Set(persistedEnvelopeIds));
+			} catch (error) {
+				if (originCancellation) throwIfCancellationDeliveryBlocked(options, input.taskId, persistedEnvelopeIds);
+				throw error;
+			}
+			if (originCancellation) throwIfCancellationDeliveryBlocked(options, input.taskId, persistedEnvelopeIds);
+		}
+		if (receiverTerminal) throwIfTerminalDeliveryBlocked(options.store, input.taskId);
+		if (outcome === undefined) throw new TaskProtocolError("INVALID_INTENT", "task intent outcome was not persisted");
+		return outcome;
+	};
 
 	return {
 		endpoint: options.endpoint,
@@ -137,27 +176,21 @@ export function createTaskCore(options: TaskCoreOptions): TaskCore {
 			await options.relay.acknowledgeDelivery({ endpoint: options.endpoint, cursor }, signal);
 			options.store.transaction(() => { options.store.setReceiveCursor(cursor); });
 		},
-		async submitIntent(input, signal) {
-			if (!RECEIVER_INTENT_TYPES.has(input.type) || !isRecord(input.payload)) throw new TaskProtocolError("INVALID_INTENT", "intent type or payload is invalid");
-			let persistedEnvelopeIds: readonly string[] = [];
-			let receiverTerminal = false;
-			options.store.transaction(() => {
-				const task = requiredTask(options.store, input.taskId);
-				receiverTerminal = !sameEndpoint(options.endpoint, task.origin) && TERMINAL_EVENTS.has(input.type);
-				persistedEnvelopeIds = persistIntent(options, clock.now, ids, task, input);
-			});
-			await flush(options, signal, new Set(persistedEnvelopeIds));
-			if (receiverTerminal) throwIfTerminalDeliveryBlocked(options.store, input.taskId);
-		},
+		async submitIntent(input, signal) { await submitIntentWithOutcome(input, signal); },
+		submitIntentWithOutcome,
 		async recordInsertion(input, signal) {
 			const task = requiredTask(options.store, input.taskId);
+			const evidence: DeliveryEvidence = { eventId: input.eventId, stage: TaskDeliveryStage.piInserted, state: TaskDeliveryEvidenceState.confirmed };
 			let persistedEnvelopeIds: readonly string[] = [];
 			options.store.transaction(() => {
-				if (options.store.putInsertionReceipt(input.taskId, input.eventId)) {
-					persistedEnvelopeIds = persistIntent(options, clock.now, ids, task, { taskId: input.taskId, type: "task.delivery_receipt", payload: { eventId: input.eventId } });
-				}
+				options.store.putInsertionReceipt(input.taskId, input.eventId);
+				persistedEnvelopeIds = persistIntent(options, clock.now, ids, task, {
+					taskId: input.taskId,
+					type: "task.delivery_receipt",
+					payload: { eventId: input.eventId, stage: evidence.stage, state: evidence.state },
+				}, deliveryEvidenceOperation(evidence)).envelopeIds;
 			});
-			if (persistedEnvelopeIds.length > 0) await flush(options, signal, new Set(persistedEnvelopeIds));
+			await flushDeliveryEvidence(options, signal, input.taskId, persistedEnvelopeIds, evidence);
 		},
 		async evaluateTimeouts(signal) {
 			const persistedEnvelopeIds: string[] = [];
@@ -166,7 +199,7 @@ export function createTaskCore(options: TaskCoreOptions): TaskCore {
 				options.store.transaction(() => {
 					const task = options.store.getTask(candidate.taskId);
 					if (!task || !sameEndpoint(task.origin, options.endpoint) || TERMINAL_STATUSES.has(task.status) || task.expiresAt > clock.now()) return;
-					persistedEnvelopeIds.push(...canonicalize(options, clock.now, ids, task, { intentId: ids(), taskId: task.taskId, type: "task.cancelled", payload: {} }, "task.timed_out"));
+					persistedEnvelopeIds.push(...canonicalize(options, clock.now, ids, task, { intentId: ids(), taskId: task.taskId, type: "task.cancelled", payload: {} }, "task.timed_out").envelopeIds);
 				});
 			}
 			if (persistedEnvelopeIds.length > 0) await flush(options, signal, new Set(persistedEnvelopeIds));
@@ -177,7 +210,7 @@ export function createTaskCore(options: TaskCoreOptions): TaskCore {
 				const task = requiredTask(options.store, taskId);
 				if (!sameEndpoint(task.origin, options.endpoint)) throw new TaskProtocolError("NOT_ORIGIN", "only origin may acknowledge a task");
 				if (!TERMINAL_STATUSES.has(task.status)) throw new TaskProtocolError("TASK_NOT_TERMINAL", "only a terminal task may be acknowledged", { retryable: false });
-				persistedEnvelopeIds = canonicalize(options, clock.now, ids, task, { intentId: ids(), taskId, type: "task.information", payload: {} }, "task.parent_acknowledged", PARENT_ACKNOWLEDGMENT_OPERATION);
+				persistedEnvelopeIds = canonicalize(options, clock.now, ids, task, { intentId: ids(), taskId, type: "task.information", payload: {} }, "task.parent_acknowledged", PARENT_ACKNOWLEDGMENT_OPERATION).envelopeIds;
 			});
 			await flush(options, signal, new Set(persistedEnvelopeIds));
 		},
@@ -235,41 +268,80 @@ function persistReceivedEnvelope(options: TaskCoreOptions, now: () => number, id
 		options.store.appendEvent(received.event);
 		return [];
 	}
-	if (received.kind === "intent") return canonicalize(options, now, ids, received.task, received.intent, received.intent.type);
+	if (received.kind === "intent") return canonicalize(options, now, ids, received.task, received.intent, received.intent.type).envelopeIds;
 	if (options.store.appendEvent(received.event) && TERMINAL_EVENTS.has(received.event.type)) options.store.setStatus(received.task.taskId, statusFor(received.event.type));
 	return [];
 }
 
-function persistIntent(options: TaskCoreOptions, now: () => number, ids: () => string, task: TaskRecord, input: SubmitIntentInput): readonly string[] {
+interface PersistedIntent {
+	readonly envelopeIds: readonly string[];
+	readonly outcome: SubmitIntentOutcome;
+}
+
+function persistIntent(options: TaskCoreOptions, now: () => number, ids: () => string, task: TaskRecord, input: SubmitIntentInput, reservedOperation?: string): PersistedIntent {
 	if (sameEndpoint(options.endpoint, task.origin)) {
-		return canonicalize(options, now, ids, task, { intentId: ids(), taskId: input.taskId, type: input.type, payload: input.payload }, input.type);
+		const operation = input.type === "task.cancelled" ? ORIGIN_CANCELLATION_OPERATION : reservedOperation;
+		const canonical = canonicalize(options, now, ids, task, { intentId: ids(), taskId: input.taskId, type: input.type, payload: input.payload }, input.type, operation);
+		return { envelopeIds: canonical.envelopeIds, outcome: { authority: "origin", canonicalEvent: { type: canonical.eventType, reused: canonical.reused } } };
 	}
 	const envelopeId = ids();
 	const intent: TaskIntent = { intentId: ids(), taskId: input.taskId, type: input.type, payload: input.payload };
-	if (TERMINAL_EVENTS.has(input.type)) {
+	const operation = TERMINAL_EVENTS.has(input.type) ? TERMINAL_INTENT_OPERATION : reservedOperation;
+	if (operation !== undefined) {
 		const reservation = options.store.reserveTaskOperation({
 			taskId: input.taskId,
-			operation: TERMINAL_INTENT_OPERATION,
+			operation,
 			logicalId: intent.intentId,
 			logicalType: intent.type,
 			envelopeIds: [envelopeId],
 		});
 		if (!reservation.created) {
-			if (reservation.record.logicalType !== intent.type) {
+			if (operation === TERMINAL_INTENT_OPERATION && reservation.record.logicalType !== intent.type) {
 				throw new TaskProtocolError("TERMINAL_INTENT_CONFLICT", "terminal task intent conflicts with the existing terminal action", {
 					retryable: false,
 					details: { taskId: input.taskId, existingType: reservation.record.logicalType, requestedType: intent.type },
 				});
 			}
-			return reservation.record.envelopeIds;
+			return { envelopeIds: reservation.record.envelopeIds, outcome: { authority: "receiver" } };
 		}
 	}
 	options.store.putIntent(intent.intentId, input.taskId, envelopeId);
 	options.store.putOutbox(envelope(envelopeId, options.endpoint, task.origin, input.taskId, TaskEnvelopeKind.intent, intent));
-	return [envelopeId];
+	return { envelopeIds: [envelopeId], outcome: { authority: "receiver" } };
+}
+
+interface DeliveryEvidence {
+	readonly eventId: string;
+	readonly stage: TaskDeliveryStage;
+	readonly state: TaskDeliveryEvidenceState;
+	readonly retryable?: true;
 }
 
-function canonicalize(options: TaskCoreOptions, now: () => number, ids: () => string, task: TaskRecord, intent: TaskIntent, requestedType: string, operation?: string): readonly string[] {
+function deliveryEvidence(input: SubmitIntentInput): DeliveryEvidence | undefined {
+	if (input.type !== "task.delivery_receipt" || typeof input.payload.eventId !== "string") return undefined;
+	const stage = input.payload.stage;
+	const state = input.payload.state;
+	if (stage === TaskDeliveryStage.piInsertion && state === TaskDeliveryEvidenceState.blocked && input.payload.retryable === true) {
+		return { eventId: input.payload.eventId, stage, state, retryable: true };
+	}
+	if ((stage === TaskDeliveryStage.receiverPersisted || stage === TaskDeliveryStage.piInserted || stage === TaskDeliveryStage.wakeRequested || stage === TaskDeliveryStage.wakeAccepted)
+		&& state === TaskDeliveryEvidenceState.confirmed) {
+		return { eventId: input.payload.eventId, stage, state };
+	}
+	return undefined;
+}
+
+function deliveryEvidenceOperation(input: DeliveryEvidence): string {
+	return `${DELIVERY_EVIDENCE_OPERATION}:${input.eventId}:${input.stage}:${input.state}`;
+}
+
+interface Canonicalization {
+	readonly envelopeIds: readonly string[];
+	readonly eventType: string;
+	readonly reused: boolean;
+}
+
+function canonicalize(options: TaskCoreOptions, now: () => number, ids: () => string, task: TaskRecord, intent: TaskIntent, requestedType: string, operation?: string): Canonicalization {
 	const terminal = TERMINAL_EVENTS.has(requestedType);
 	const type = terminal && TERMINAL_STATUSES.has(task.status) ? "task.late_terminal" : requestedType;
 	const sequence = String(task.events.length + 1);
@@ -279,13 +351,23 @@ function canonicalize(options: TaskCoreOptions, now: () => number, ids: () => st
 	const persistedEnvelopeIds = originEnvelope === undefined ? [targetEnvelope.envelopeId] : [targetEnvelope.envelopeId, originEnvelope.envelopeId];
 	if (operation !== undefined) {
 		const reservation = options.store.reserveTaskOperation({ taskId: task.taskId, operation, logicalId: canonical.eventId, logicalType: canonical.type, envelopeIds: persistedEnvelopeIds });
-		if (!reservation.created) return reservation.record.envelopeIds;
+		if (!reservation.created) return { envelopeIds: reservation.record.envelopeIds, eventType: reservation.record.logicalType, reused: true };
 	}
 	options.store.appendEvent(canonical);
 	if (TERMINAL_EVENTS.has(type)) options.store.setStatus(task.taskId, statusFor(type));
 	options.store.putOutbox(targetEnvelope);
 	if (originEnvelope !== undefined) options.store.putOutbox(originEnvelope);
-	return persistedEnvelopeIds;
+	return { envelopeIds: persistedEnvelopeIds, eventType: type, reused: false };
+}
+
+async function flushDeliveryEvidence(options: TaskCoreOptions, signal: AbortSignal | undefined, taskId: string, envelopeIds: readonly string[], evidence: DeliveryEvidence): Promise<void> {
+	try {
+		if (envelopeIds.length > 0) await flush(options, signal, new Set(envelopeIds));
+	} catch (error) {
+		throwIfDeliveryEvidenceBlocked(options.store, taskId, envelopeIds, evidence);
+		throw error;
+	}
+	throwIfDeliveryEvidenceBlocked(options.store, taskId, envelopeIds, evidence);
 }
 
 async function flush(options: TaskCoreOptions, signal: AbortSignal | undefined, reportedEnvelopeIds?: ReadonlySet<string>): Promise<void> {
@@ -339,6 +421,34 @@ function parsePayload(envelope: RelayEnvelope): unknown {
 	try { return JSON.parse(envelope.payload) as unknown; } catch { throw new TaskProtocolError("INVALID_PAYLOAD", "relay envelope payload is not valid task protocol JSON"); }
 }
 
+function throwIfCancellationDeliveryBlocked(options: TaskCoreOptions, taskId: string, envelopeIds: readonly string[]): void {
+	const task = requiredTask(options.store, taskId);
+	const blocked = options.store.quarantinedOutbox().find((record) => envelopeIds.includes(record.envelope.envelopeId) && sameEndpoint(record.envelope.target, task.target));
+	if (blocked === undefined) return;
+	throw new TaskOutboxDeliveryError(blocked.errorCode, blocked.reason, {
+		retryable: false,
+		details: { ...blocked.details, taskId, envelopeId: blocked.envelope.envelopeId, target: task.target, blockedAt: blocked.quarantinedAt },
+	});
+}
+
+function throwIfDeliveryEvidenceBlocked(store: TaskStore, taskId: string, envelopeIds: readonly string[], evidence: DeliveryEvidence): void {
+	const blocked = store.quarantinedOutbox().find((record) => envelopeIds.includes(record.envelope.envelopeId));
+	if (blocked === undefined) return;
+	throw new TaskOutboxDeliveryError(blocked.errorCode, "task delivery evidence is blocked", {
+		retryable: false,
+		details: {
+			...blocked.details,
+			taskId,
+			eventId: evidence.eventId,
+			stage: evidence.stage,
+			state: evidence.state,
+			envelopeId: blocked.envelope.envelopeId,
+			target: blocked.envelope.target,
+			blockedAt: blocked.quarantinedAt,
+		},
+	});
+}
+
 function throwIfTerminalDeliveryBlocked(store: TaskStore, taskId: string): void {
 	const delivery = requiredTask(store, taskId).terminalDelivery;
 	if (delivery.state !== "delivery_blocked") return;

package/src/task-inbox.ts

@@ -1,17 +1,22 @@
 import type { TaskCore } from "./task-core";
-import { TaskEnvelopeKind, TaskProtocolError } from "./task-protocol";
+import { TaskDeliveryEvidenceState, TaskDeliveryStage, TaskEnvelopeKind, TaskProtocolError } from "./task-protocol";
 import type { RelayDelivery, TaskEvent } from "./task-protocol";
 
 const TASK_EVENT_CUSTOM_TYPE = "pi-tasks-event";
+const TASK_WAKE_CUSTOM_TYPE = "pi-tasks-wake";
 const TASK_CURSOR_CUSTOM_TYPE = "pi-tasks-relay-cursor";
 
 interface InboxContext {
+	readonly isIdle: () => boolean;
 	readonly hasPendingMessages: () => boolean;
 	readonly sessionManager: { readonly getEntries: () => readonly unknown[] };
 }
 
 interface InboxPi {
-	sendMessage(message: { readonly customType: string; readonly content: string; readonly display: boolean; readonly details: TaskEventDetails }, options: { readonly triggerTurn: true; readonly deliverAs: "followUp" }): void;
+	sendMessage(
+		message: { readonly customType: string; readonly content: string; readonly display: boolean; readonly details: TaskEventDetails },
+		options: { readonly triggerTurn: false } | { readonly triggerTurn: true; readonly deliverAs: "followUp" },
+	): void;
 	appendEntry(customType: string, data: { readonly cursor: string }): void;
 }
 
@@ -20,8 +25,12 @@ export interface TaskEventDetails {
 	readonly eventId: string;
 }
 
-/** Inserts durable Pi evidence before allowing the relay mailbox cursor to advance. */
-export async function deliverTaskInbox(pi: InboxPi, core: TaskCore, context: InboxContext, pendingInsertions: Set<string>, signal?: AbortSignal): Promise<void> {
+type DeliveryEvidencePayload =
+	| { readonly stage: typeof TaskDeliveryStage.receiverPersisted | typeof TaskDeliveryStage.wakeRequested | typeof TaskDeliveryStage.wakeAccepted; readonly state: typeof TaskDeliveryEvidenceState.confirmed }
+	| { readonly stage: typeof TaskDeliveryStage.piInsertion; readonly state: typeof TaskDeliveryEvidenceState.blocked; readonly retryable: true };
+
+/** Persists model-visible Pi evidence before advancing the relay cursor, then starts one separate turn. */
+export async function deliverTaskInbox(pi: InboxPi, core: TaskCore, context: InboxContext, signal?: AbortSignal): Promise<void> {
 	if (context.hasPendingMessages()) return;
 	const deliveries = await core.receive(signal);
 	for (const delivery of deliveries) {
@@ -33,28 +42,52 @@ export async function deliverTaskInbox(pi: InboxPi, core: TaskCore, context: Inb
 		const event = inboxEvent(delivery);
 		if (!isKnownEvent(event.type)) throw new TaskProtocolError("UNKNOWN_EVENT", `unknown task inbox event type: ${event.type}`);
 		if (context.hasPendingMessages()) return;
+		const eventDetails = { taskId: event.taskId, eventId: event.eventId };
 		const eventKey = key(event.taskId, event.eventId);
-		const incorporated = incorporatedEvents(context.sessionManager.getEntries()).has(eventKey);
-		if (incorporated) pendingInsertions.delete(eventKey);
+		if (event.type === "task.created") {
+			await recordDeliveryEvidence(core, eventDetails, { stage: TaskDeliveryStage.receiverPersisted, state: TaskDeliveryEvidenceState.confirmed }, signal);
+		}
+		let incorporated = incorporatedEvents(context.sessionManager.getEntries()).has(eventKey);
 		if (!incorporated && isModelVisible(event.type)) {
-			if (!pendingInsertions.has(eventKey)) {
+			if (!context.isIdle()) return;
+			pi.sendMessage({
+				customType: TASK_EVENT_CUSTOM_TYPE,
+				content: renderTaskEvent(event),
+				display: true,
+				details: eventDetails,
+			}, { triggerTurn: false });
+			incorporated = incorporatedEvents(context.sessionManager.getEntries()).has(eventKey);
+			if (!incorporated) {
+				await recordDeliveryEvidence(core, eventDetails, { stage: TaskDeliveryStage.piInsertion, state: TaskDeliveryEvidenceState.blocked, retryable: true }, signal);
+				return;
+			}
+		}
+		if (isModelVisible(event.type)) {
+			await core.recordInsertion(eventDetails, signal);
+			let wakeAccepted = taskMessageKeys(context.sessionManager.getEntries(), TASK_WAKE_CUSTOM_TYPE).has(eventKey);
+			if (!wakeAccepted) {
+				if (!context.isIdle()) return;
+				await recordDeliveryEvidence(core, eventDetails, { stage: TaskDeliveryStage.wakeRequested, state: TaskDeliveryEvidenceState.confirmed }, signal);
 				pi.sendMessage({
-					customType: TASK_EVENT_CUSTOM_TYPE,
-					content: renderTaskEvent(event),
-					display: true,
-					details: { taskId: event.taskId, eventId: event.eventId },
+					customType: TASK_WAKE_CUSTOM_TYPE,
+					content: "Process the pending Pi task event.",
+					display: false,
+					details: eventDetails,
 				}, { triggerTurn: true, deliverAs: "followUp" });
-				pendingInsertions.add(eventKey);
+				wakeAccepted = taskMessageKeys(context.sessionManager.getEntries(), TASK_WAKE_CUSTOM_TYPE).has(eventKey);
+				if (!wakeAccepted) return;
 			}
-			if (!incorporatedEvents(context.sessionManager.getEntries()).has(eventKey)) return;
-			pendingInsertions.delete(eventKey);
+			await recordDeliveryEvidence(core, eventDetails, { stage: TaskDeliveryStage.wakeAccepted, state: TaskDeliveryEvidenceState.confirmed }, signal);
 		}
-		if (isModelVisible(event.type)) await core.recordInsertion({ taskId: event.taskId, eventId: event.eventId }, signal);
 		await core.acknowledgeRelayDelivery(delivery.cursor, signal);
 		pi.appendEntry(TASK_CURSOR_CUSTOM_TYPE, { cursor: delivery.cursor });
 	}
 }
 
+async function recordDeliveryEvidence(core: TaskCore, event: TaskEventDetails, evidence: DeliveryEvidencePayload, signal?: AbortSignal): Promise<void> {
+	await core.submitIntent({ taskId: event.taskId, type: "task.delivery_receipt", payload: { eventId: event.eventId, ...evidence } }, signal);
+}
+
 function inboxEvent(delivery: RelayDelivery): TaskEvent {
 	try {
 		const payload = JSON.parse(delivery.envelope.payload) as unknown;
@@ -81,16 +114,24 @@ function renderTaskEvent(event: TaskEvent): string {
 }
 
 export function incorporatedTaskEvents(entries: readonly unknown[]): readonly TaskEventDetails[] {
+	return taskMessageDetails(entries, TASK_EVENT_CUSTOM_TYPE);
+}
+
+function taskMessageDetails(entries: readonly unknown[], customType: string): readonly TaskEventDetails[] {
 	const events: TaskEventDetails[] = [];
 	for (const entry of entries) {
-		if (!isRecord(entry) || entry.type !== "custom_message" || entry.customType !== TASK_EVENT_CUSTOM_TYPE || !isRecord(entry.details) || typeof entry.details.taskId !== "string" || typeof entry.details.eventId !== "string") continue;
+		if (!isRecord(entry) || entry.type !== "custom_message" || entry.customType !== customType || !isRecord(entry.details) || typeof entry.details.taskId !== "string" || typeof entry.details.eventId !== "string") continue;
 		events.push({ taskId: entry.details.taskId, eventId: entry.details.eventId });
 	}
 	return events;
 }
 
+function taskMessageKeys(entries: readonly unknown[], customType: string): Set<string> {
+	return new Set(taskMessageDetails(entries, customType).map((event) => key(event.taskId, event.eventId)));
+}
+
 function incorporatedEvents(entries: readonly unknown[]): Set<string> {
-	return new Set(incorporatedTaskEvents(entries).map((event) => key(event.taskId, event.eventId)));
+	return taskMessageKeys(entries, TASK_EVENT_CUSTOM_TYPE);
 }
 
 function isTaskEvent(value: unknown): value is TaskEvent {

package/src/task-protocol.ts

@@ -1,8 +1,22 @@
 export const TASK_PROTOCOL_VERSION = "pi-tasks/v2" as const;
 export const MAX_RELAY_PAYLOAD_BYTES = 48 * 1024;
+export const ORIGIN_CANCELLATION_OPERATION = "origin_cancellation";
 export const PARENT_ACKNOWLEDGMENT_OPERATION = "parent_acknowledgment";
 export const TERMINAL_INTENT_OPERATION = "terminal_intent";
 
+export const TaskDeliveryStage = {
+	receiverPersisted: "receiver_persisted",
+	piInsertion: "pi_insertion",
+	piInserted: "pi_inserted",
+	wakeRequested: "wake_requested",
+	wakeAccepted: "wake_accepted",
+} as const;
+
+export const TaskDeliveryEvidenceState = {
+	confirmed: "confirmed",
+	blocked: "blocked",
+} as const;
+
 export interface TaskEndpoint {
 	readonly relay: string;
 	readonly id: string;
@@ -104,6 +118,9 @@ export interface TaskRecord {
 
 export type TerminalTaskIntentType = "task.completed" | "task.failed" | "task.cancelled";
 
+export type TaskDeliveryStage = (typeof TaskDeliveryStage)[keyof typeof TaskDeliveryStage];
+export type TaskDeliveryEvidenceState = (typeof TaskDeliveryEvidenceState)[keyof typeof TaskDeliveryEvidenceState];
+
 export interface TaskIntent {
 	readonly intentId: string;
 	readonly taskId: string;