@sgtbeatdown/pi-tasks 0.1.14 → 0.1.15

package/docs/protocol-reference.md

@@ -28,7 +28,7 @@ The `agent_task_send` schema is exactly `to`, `task`, and optional `timeoutMs`.
 
 ## history versus live state
 
-- Pi requests task-processing turns through its safe `deliverAs: "followUp"` queue. Pi session messages and tool calls/results preserve historical context. Non-waking receipts, parent ACKs and late-terminal facts are archived as `pi-tasks-event-record` custom entries before transport ACK, without waking the model. Received model-visible task events include the complete structured event in `pi-tasks-event` details, including results—not just a rendered summary.
+- Pi requests task-processing turns through its safe `deliverAs: "followUp"` queue. Pi session messages and tool calls/results preserve historical context. Non-waking receipts, parent ACKs, late-terminal facts and confirmed receiver-authored conversation echoes are archived as `pi-tasks-event-record` custom entries before transport ACK, without model insertion or wake. Received model-visible task events include the complete structured event in `pi-tasks-event` details, including results—not just a rendered summary.
 - Active tasks, outbox intentions, individual ACK checkpoints, deduplication and delivery-blocked evidence are RAM-owned. Each endpoint has lower-only limits of 16,384 records/32MiB encoded state. Admission fails before exceeding those bounds; they are not a process-RSS guarantee.
 - `agent_task_send` confirms relay acceptance, **not execution**. `receiver_recorded` confirms receiver RAM receipt, **not durable persistence**. Pi insertion and wake acceptance are separate evidence, never proof of model execution.
 - Session history is not an operational journal. A new process/lifecycle starts empty with a fresh endpoint/generation; it does not reconstruct tasks, replay envelopes, reuse old ACKs or reopen a worker gate from old history.
@@ -38,9 +38,13 @@ The `agent_task_send` schema is exactly `to`, `task`, and optional `timeoutMs`.
 
 `createConfiguredTaskCore()` owns its transport and `createTaskStore()` RAM state. Startup registers; polling runs every five seconds and at agent settlement. Shutdown fences new work, aborts requests, drains active calls and discards state. Late callbacks cannot mutate a successor lifetime.
 
-Background refresh records protocol facts in RAM even while Pi is busy or has queued messages. A valid completion within the fetched receive page can become canonical before its notification is presented. Model-visible insertion and the separate follow-up wake still wait for idle Pi with no queued messages; visible relay mail remains replayable until the required structured insertion/wake evidence is present. Intake alone does not incorporate an assignment or authorize worker tools. Parent acknowledgment before terminal presentation retains the event but suppresses its redundant wake.
+Background refresh records protocol facts in RAM even while Pi is busy or has queued messages. A valid completion within the fetched receive page can become canonical before its notification is presented. Model-visible insertion and the separate follow-up wake still wait for idle Pi with no queued messages; visible relay mail remains replayable until the required structured insertion/wake evidence is present. Intake alone does not incorporate an assignment or authorize worker tools. Parent acknowledgment before terminal presentation retains the event but suppresses its redundant wake. Origin-authored conversations do not echo to the origin. Receiver-authored conversation copies remain canonical replicas, but local outbound intent identity makes their presentation archive-only; payload author claims are not provenance. Missing or unmatched intent identity leaves peer conversations actionable. This correlation is RAM-only and is never recovered from session history.
 
-This separation does not change polling or the 100-envelope receive-page bound: a full prefix of held visible mail can still prevent intake of a newer intent beyond that page. General backlog scanning is not provided.
+The normal 5s polling cadence and relay byte limits are unchanged. A single-flight background refresh shares one work scope through lease connection, ACK repair, timeout fan-out, receive and all inbox receipts: at most 56 scoped sends plus 8 rotating old-work sends, 48 ACK attempts and one initial receive page of up to 50 items, with a 2s overall deadline. Failed attempts consume the shared counts; the same send/ACK identity is not attempted twice in that scope. Separate 250ms retry/ACK-repair slices stop admitting another attempt, not an already admitted request: each admitted request gets the remaining background window. These are scheduling bounds, not throughput guarantees. Foreground send/message/done retain the configured transport request deadline (default 12s) and caller cancellation instead of inheriting the background cutoff. Any speculative old-work retry after a foreground send uses a finite 2s background window, starting only when that share is reached.
+
+Each refresh deliberately fetches only one initial page, even when `hasMore` is true or the ACK frontier advances. Extra-page saturation draining (#27) is deferred, not fixed or optimized; byte limits can make this page shorter than 50 items, and shared send/ACK counts can defer work within it. The normal refresh reserves initial protocol intake ahead of requested-ACK repair; page intake also precedes its own repair pass. Speculative old-work sends wait until all current-page intake and available presentation/evidence/ACK work completes or deliberately yields. Inbox delivery holds that gate across receive and nested fanout/receipt flushes, releasing it in finalization even on empty, held/busy or failed passes when budget remains. Direct core receive suppresses speculation during page materialization and retains its bounded after-intake retry opportunity; an inbox-owned gate remains closed until presentation yields. After required canonical fan-out acceptance, both new and replayed raw intents stage authorized ACK requests in the existing checkpoint rather than retrying inline. The shared after-intake repair pass uses the same ACK budget, admission slice and overall background deadline; remaining raw ACK work reports local deferral on budget/slice/cooldown exhaustion. Failed or pending required fan-out still stops intake at that delivery. Retryable/slow repair still reports failure and retains uncertain requested IDs, but cannot prevent that initial real receive. A failed repair yields before presentation. Ignored-abort ACK responses cannot later advance local authority. Held visible mail, missing insertion/wake evidence, backpressure or exhaustion yields without reading ahead. A full held prefix can still prevent intake of a newer intent beyond that page; general backlog scanning is not provided.
+
+Scoped operations attempt their own immutable IDs and cannot report acceptance for omitted or partial fan-out. Concurrent same-ID sends join existing delivery rather than retransmitting. Pending retry IDs rotate incrementally in RAM on attempts/actual skips, including failures and cooldown skips, without copying payloads or rotating an unattempted suffix past the retry deadline. A foreground packet's capacity refusal does not suppress smaller old packets to the same target; same-cycle target suppression starts only when speculative retry itself encounters capacity. Known capacity defers that envelope/ACK for at least 5s (or the validated longer `retryAfterMs`), without a retry timer. `TASK_DELIVERY_DEFERRED` is a retryable local budget/cooldown outcome, not relay acceptance or permanent quarantine. Raw intent replays retain their canonical fan-out reservation and are not ACKed while required sends remain pending; quarantined required sends report their blocked outcome instead of false acceptance. The exported `TaskStore` contract requires indexed lookup, fair rotation and cooldown capabilities, supplied by `createTaskStore()`; there is no legacy snapshot/fixed-prefix fallback. `TaskCore.receive()` retains its array return and the documented transport seam is unchanged.
 
 The default extension automatically replaces a lifetime only after a structured `RELAY_RESET` or `RELAY_REBIND_REQUIRED`. It fences and discards the unusable RAM state, records each active task in session history as locally failed with `RELAY_STATE_LOST` and an explicitly unknown remote outcome, then binds a fresh empty endpoint. The loss record does not wake the model by itself. Transient availability, authentication, capacity, abort, profile and malformed-response failures never trigger replacement. Historical tasks are not adopted into the successor lifetime.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sgtbeatdown/pi-tasks",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "Memory-only endpoint-owned Pi agent delegation through Wolfpack relay v2.",
   "module": "src/index.ts",
   "exports": {

package/src/extension.ts

@@ -4,6 +4,7 @@ import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 
 import { abortableSleep } from "./abortable-sleep";
+import { createTaskWorkScope } from "./task-work-scope";
 import { deliverTaskInbox, incorporatedTaskEvents } from "./task-inbox";
 import { TaskDeliveryEvidenceState, TaskDeliveryStage, TaskOutboxDeliveryError, TaskProtocolError, isBlockedOutboxDeliveryCode } from "./task-protocol";
 import { createConfiguredTaskCore } from "./configured-task-core";
@@ -113,18 +114,21 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 		const epoch = lifecycleEpoch;
 		const isCurrent = (): boolean => inboxContext === context && lifecycleEpoch === epoch;
 		if (!context) return undefined;
+		const work = createTaskWorkScope(signal);
+		work.retryAllowed = false; // Reserve initial intake ahead of speculative backlog work and ACK repair.
+		signal = work.signal;
 		const activeCore = await configuredCore(signal);
 		if (!isCurrent()) return undefined;
 		let outboxError: unknown;
 		try {
-			await activeCore.flushOutbox(signal);
+			await activeCore.connect(signal, work);
 		} catch (error) {
 			if (isRelayLoss(error)) return error;
 			outboxError = error;
 		}
 		if (!isCurrent()) return undefined;
 		try {
-			await activeCore.evaluateTimeouts(signal);
+			await activeCore.evaluateTimeouts(signal, work);
 		} catch (error) {
 			if (isRelayLoss(error)) return error;
 			outboxError ??= error;
@@ -132,20 +136,26 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 		if (!isCurrent()) return undefined;
 		const guardedCore: TaskCore = {
 			...activeCore,
-			async receive(receiveSignal) {
+			async receive(receiveSignal, receiveWork) {
 				if (!isCurrent()) return [];
-				const deliveries = await activeCore.receive(receiveSignal);
+				const deliveries = await activeCore.receive(receiveSignal, receiveWork);
 				return isCurrent() ? deliveries : [];
 			},
-			async acknowledgeRelayDelivery(cursor, acknowledgementSignal) {
-				if (isCurrent()) await activeCore.acknowledgeRelayDelivery(cursor, acknowledgementSignal);
+			async acknowledgeRelayDelivery(cursor, acknowledgementSignal, acknowledgementWork) {
+				if (isCurrent()) await activeCore.acknowledgeRelayDelivery(cursor, acknowledgementSignal, acknowledgementWork);
 			},
-			async recordInsertion(input, insertionSignal) {
-				if (isCurrent()) await activeCore.recordInsertion(input, insertionSignal);
+			async recordInsertion(input, insertionSignal, insertionWork) {
+				if (isCurrent()) await activeCore.recordInsertion(input, insertionSignal, insertionWork);
 			},
-			recordWakeRequest(input) {
+			async submitIntent(input, intentSignal, intentWork) {
+				if (isCurrent()) await activeCore.submitIntent(input, intentSignal, intentWork);
+			},
+			async flushOutbox(flushSignal, flushWork) {
+				if (isCurrent()) await activeCore.flushOutbox(flushSignal, flushWork);
+			},
+			recordWakeRequest(input, wakeWork) {
 				if (!isCurrent()) throw new TaskProtocolError("RELAY_CLOSED", "task lifecycle was replaced", { retryable: false });
-				const request = activeCore.recordWakeRequest(input);
+				const request = activeCore.recordWakeRequest(input, wakeWork);
 				return { flush: async (flushSignal?: AbortSignal): Promise<void> => {
 					if (!isCurrent()) throw new TaskProtocolError("RELAY_CLOSED", "task lifecycle was replaced", { retryable: false });
 					await request.flush(flushSignal);
@@ -159,7 +169,7 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 			isIdle: (): boolean => isCurrent() && context.isIdle(),
 			hasPendingMessages: (): boolean => !isCurrent() || context.hasPendingMessages(),
 			sessionManager: context.sessionManager,
-		}, signal);
+		}, signal, work);
 		return outboxError ?? inboxOutboxError;
 	});
 	const startBackgroundRefresh = (context: ExtensionContext, epoch: number): void => {
@@ -220,18 +230,11 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 		let activeCore: (TaskCore & Partial<Pick<OwnedTaskCore, "close">>) | undefined;
 		try {
 			activeCore = await configuredCore();
-			let connectionError: unknown;
-			try {
-				await activeCore.connect();
-			} catch (error) {
-				connectionError = error;
-			}
 			if (!isCurrent()) return;
-			if (isRelayLoss(connectionError) && await recoverRelayLoss(context, epoch, activeCore)) return;
 			const outboxError = await refreshInbox();
 			if (!isCurrent()) return;
 			if (isRelayLoss(outboxError) && await recoverRelayLoss(context, epoch, activeCore)) return;
-			const lifecycleError = outboxError ?? connectionError;
+			const lifecycleError = outboxError;
 			const status = lifecycleError === undefined ? undefined : outboxFailureStatus(lifecycleError);
 			context.ui.setStatus("pi-tasks", status === undefined ? undefined : context.ui.theme.fg("warning", status));
 			if (lifecycleError === undefined) announceFreshBinding(context);

package/src/task-core.ts

@@ -21,10 +21,13 @@ import type {
 	TaskRelay,
 	TaskSnapshot,
 } from "./task-protocol";
-import type { TaskStore } from "./task-store";
+import type { TaskStore, OutboxRecord } from "./task-store";
+import { TASK_WORK_LIMITS, capacityRetryAt, createTaskWorkScope, deferredTaskDelivery } from "./task-work-scope";
+import type { TaskWorkScope } from "./task-work-scope";
 
-const RECEIVE_PAGE_SIZE = 100;
+const RECEIVE_PAGE_SIZE = TASK_WORK_LIMITS.pageItems;
 const DELIVERY_EVIDENCE_OPERATION = "delivery_evidence";
+const RECEIVED_INTENT_OPERATION = "received_intent";
 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"]);
 const CONVERSATIONAL_EVENTS = new Set(["task.information", "task.question", "task.answer"]);
@@ -68,19 +71,21 @@ export interface WakeRequest {
 
 export interface TaskCore {
 	readonly endpoint: TaskEndpoint;
-	connect(signal?: AbortSignal): Promise<void>;
-	createTask(input: CreateTaskInput, signal?: AbortSignal): Promise<{ readonly taskId: string }>;
+	connect(signal?: AbortSignal, work?: TaskWorkScope): Promise<void>;
+	createTask(input: CreateTaskInput, signal?: AbortSignal, work?: TaskWorkScope): Promise<{ readonly taskId: string }>;
 	getTask(taskId: string): TaskSnapshot | undefined;
 	listTasks(): readonly TaskSnapshot[];
-	flushOutbox(signal?: AbortSignal): Promise<void>;
-	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>;
-	recordWakeRequest(input: { readonly taskId: string; readonly eventId: string }): WakeRequest;
-	evaluateTimeouts(signal?: AbortSignal): Promise<void>;
-	acknowledgeParent(taskId: string, signal?: AbortSignal): Promise<void>;
+	/** Correlate a receiver conversation with a locally recorded outbound intent, never session history or payload author claims. */
+	isSelfAuthoredConversation(event: TaskEvent): boolean;
+	flushOutbox(signal?: AbortSignal, work?: TaskWorkScope): Promise<void>;
+	receive(signal?: AbortSignal, work?: TaskWorkScope): Promise<readonly RelayDelivery[]>;
+	acknowledgeRelayDelivery(cursor: string, signal?: AbortSignal, work?: TaskWorkScope): Promise<void>;
+	submitIntent(input: SubmitIntentInput, signal?: AbortSignal, work?: TaskWorkScope): Promise<void>;
+	submitIntentWithOutcome?(input: SubmitIntentInput, signal?: AbortSignal, work?: TaskWorkScope): Promise<SubmitIntentOutcome>;
+	recordInsertion(input: { readonly taskId: string; readonly eventId: string }, signal?: AbortSignal, work?: TaskWorkScope): Promise<void>;
+	recordWakeRequest(input: { readonly taskId: string; readonly eventId: string }, work?: TaskWorkScope): WakeRequest;
+	evaluateTimeouts(signal?: AbortSignal, work?: TaskWorkScope): Promise<void>;
+	acknowledgeParent(taskId: string, signal?: AbortSignal, work?: TaskWorkScope): Promise<void>;
 }
 
 type ReceivedEnvelope =
@@ -91,20 +96,34 @@ type ReceivedEnvelope =
 export function createTaskCore(options: TaskCoreOptions): TaskCore {
 	const clock = options.clock ?? { now: (): number => Date.now() };
 	const ids = options.ids ?? (() => crypto.randomUUID());
-	const acknowledgeRelayDelivery = async (cursor: string, signal?: AbortSignal): Promise<void> => {
+	const flush = createOutboxFlusher(options);
+	const acknowledgeWithSignal = async (cursor: string, signal: AbortSignal, work: TaskWorkScope): Promise<void> => {
 		if (!decimal(cursor)) throw new TaskProtocolError("INVALID_CURSOR", "relay cursor must be a non-negative integer");
 		const envelopeId = options.store.pendingRelayEnvelopeId(options.endpoint, cursor);
 		if (envelopeId === undefined) throw new TaskProtocolError("INVALID_CURSOR", "relay delivery is not pending in this endpoint scope");
+		const retryAt = options.store.relayAcknowledgementRetryAt(options.endpoint, cursor);
+		if (retryAt > Date.now() || !work.claimAcknowledgement(cursor)) throw deferredTaskDelivery({ cursor, retryAfterMs: Math.max(0, retryAt - Date.now()) });
 		options.store.transaction(() => options.store.requestRelayAcknowledgement(options.endpoint, cursor));
-		await options.relay.acknowledgeDelivery({ endpoint: options.endpoint, cursor, envelopeId }, signal);
-		options.store.transaction(() => options.store.acknowledgeRelayCursor(options.endpoint, cursor));
+		try {
+			await waitForRelayOperation(options.relay.acknowledgeDelivery({ endpoint: options.endpoint, cursor, envelopeId }, signal), signal);
+			throwIfAborted(signal);
+			options.store.transaction(() => options.store.acknowledgeRelayCursor(options.endpoint, cursor));
+		} catch (error) {
+			if (signal.aborted) throw error;
+			const retryAt = capacityRetryAt(error);
+			if (retryAt !== undefined) options.store.transaction(() => options.store.requestRelayAcknowledgement(options.endpoint, cursor, retryAt));
+			throw error;
+		}
 	};
-	const retryRequestedAcknowledgements = async (signal?: AbortSignal): Promise<void> => {
-		for (const cursor of options.store.requestedRelayAcknowledgements(options.endpoint)) {
-			if (options.store.pendingRelayEnvelopeId(options.endpoint, cursor) !== undefined) await acknowledgeRelayDelivery(cursor, signal);
+	const acknowledgeRelayDelivery = (cursor: string, signal?: AbortSignal, work = createTaskWorkScope(signal)): Promise<void> => acknowledgeWithSignal(cursor, work.signal, work);
+	const retryRequestedAcknowledgements = async (work: TaskWorkScope): Promise<void> => {
+		for (const cursor of options.store.requestedRelayAcknowledgements(options.endpoint, TASK_WORK_LIMITS.acknowledgements, Date.now())) {
+			if (!work.canAcknowledge() || !work.canRepairAcknowledgement()) break;
+			if (!work.attemptedAcknowledgements.has(cursor) && options.store.pendingRelayEnvelopeId(options.endpoint, cursor) !== undefined) await acknowledgeWithSignal(cursor, work.backgroundSignal(), work);
 		}
 	};
-	const submitIntentWithOutcome = async (input: SubmitIntentInput, signal?: AbortSignal): Promise<SubmitIntentOutcome> => {
+	const submitIntentWithOutcome = async (input: SubmitIntentInput, signal?: AbortSignal, work = createTaskWorkScope(signal, "foreground")): Promise<SubmitIntentOutcome> => {
+		signal = work.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 outcome: SubmitIntentOutcome | undefined;
@@ -120,10 +139,10 @@ export function createTaskCore(options: TaskCoreOptions): TaskCore {
 			outcome = persisted.outcome;
 		});
 		if (evidence !== undefined) {
-			await flushDeliveryEvidence(options, signal, input.taskId, persistedEnvelopeIds, evidence);
+			await flushDeliveryEvidence(options, signal, input.taskId, persistedEnvelopeIds, evidence, work, flush);
 		} else {
 			try {
-				await flush(options, signal, new Set(persistedEnvelopeIds));
+				await flush(signal, new Set(persistedEnvelopeIds), work);
 			} catch (error) {
 				if (originCancellation) throwIfCancellationDeliveryBlocked(options, input.taskId, persistedEnvelopeIds);
 				throw error;
@@ -137,15 +156,19 @@ export function createTaskCore(options: TaskCoreOptions): TaskCore {
 
 	return {
 		endpoint: options.endpoint,
-		async connect(signal) {
+		async connect(signal, work = createTaskWorkScope(signal)) {
+			signal = work.signal;
 			const connection = await options.relay.connect({ endpoint: options.endpoint, protocolVersion: TASK_PROTOCOL_VERSION, receiveCursor: options.store.getReceiveCursor() }, signal);
 			if (!sameEndpoint(connection.endpoint, options.endpoint)) throw new TaskProtocolError("INVALID_CONNECTION", "relay connected a different endpoint");
 			throwIfAborted(signal);
-			await retryRequestedAcknowledgements(signal);
+			// A reserved refresh repairs only after the initial page has been intaken.
+			if (work.retryAllowed) await retryRequestedAcknowledgements(work);
 		},
-		async createTask(input, signal) {
+		async createTask(input, signal, work = createTaskWorkScope(signal, "foreground")) {
+			signal = work.signal;
 			if (input.task.length === 0 || !Number.isInteger(input.timeoutMs) || input.timeoutMs < 1) throw new TaskProtocolError("INVALID_TASK", "task and a positive timeout are required");
 			const target = await options.relay.resolve({ relay: input.target.relay, reference: input.target.id }, signal);
+			throwIfAborted(signal);
 			if (!isEndpoint(target)) throw new TaskProtocolError("INVALID_TARGET", "relay resolved an invalid task endpoint");
 			const now = clock.now();
 			const taskId = ids();
@@ -161,7 +184,7 @@ export function createTaskCore(options: TaskCoreOptions): TaskCore {
 				options.store.putOutbox(assignment);
 			});
 			try {
-				await flush(options, signal, new Set([assignment.envelopeId]));
+				await flush(signal, new Set([assignment.envelopeId]), work);
 			} catch (error) {
 				throw operationError(error, taskId);
 			}
@@ -169,44 +192,72 @@ export function createTaskCore(options: TaskCoreOptions): TaskCore {
 		},
 		getTask(taskId) { return options.store.getTask(taskId); },
 		listTasks() { return options.store.listTasks(); },
-		async flushOutbox(signal) { await flush(options, signal); },
-		async receive(signal) {
-			await retryRequestedAcknowledgements(signal);
-			await flush(options, signal, IGNORE_OUTBOX_FAILURES);
-			const cursor = options.store.getReceiveCursor();
-			const page = await options.relay.receive({ endpoint: options.endpoint, cursor, limit: RECEIVE_PAGE_SIZE }, signal);
-			if (!isInboxPage(page)) throw new TaskProtocolError("INVALID_INBOX", "relay returned an invalid inbox page");
-			let previous = BigInt(cursor);
-			for (const delivery of page.deliveries) {
-				if (!isDelivery(delivery) || !sameEndpoint(delivery.envelope.target, options.endpoint) || BigInt(delivery.cursor) <= previous) throw new TaskProtocolError("INVALID_DELIVERY", "relay returned an invalid or unordered delivery");
-				previous = BigInt(delivery.cursor);
-			}
-			if (BigInt(page.nextCursor) < previous) throw new TaskProtocolError("INVALID_INBOX", "relay page cursor precedes its deliveries");
-			// Track the entire observed prefix before an intent can ACK a later
-			// delivery. Keep only pending IDs plus a high-water mark, durably.
-			options.store.transaction(() => options.store.trackRelayDeliveries(options.endpoint, page.deliveries.map(delivery => ({ cursor: delivery.cursor, envelopeId: delivery.envelope.envelopeId }))));
-			const visibleDeliveries: RelayDelivery[] = [];
-			for (const delivery of page.deliveries) {
-				if (options.store.pendingRelayEnvelopeId(options.endpoint, delivery.cursor) === undefined) continue;
-				const received = validateReceivedEnvelope(options, delivery.envelope);
-				let persistedEnvelopeIds: readonly string[] = [];
-				options.store.transaction(() => {
-					if (!options.store.persistInbox(delivery.envelope, delivery.cursor)) return;
-					persistedEnvelopeIds = persistReceivedEnvelope(options, clock.now, ids, received);
-				});
-				if (persistedEnvelopeIds.length > 0) await flush(options, signal, new Set(persistedEnvelopeIds));
-				if (received.kind === "intent") {
-					await this.acknowledgeRelayDelivery(delivery.cursor, signal);
-					continue;
+		isSelfAuthoredConversation(event) {
+			if (!CONVERSATIONAL_EVENTS.has(event.type) || typeof event.payload.intentId !== "string") return false;
+			const task = options.store.getTask(event.taskId);
+			if (!task || !sameEndpoint(options.endpoint, task.target) || sameEndpoint(options.endpoint, task.origin)
+				|| !sameEndpoint(event.source, task.origin) || !sameEndpoint(event.target, task.target)) return false;
+			const localEnvelope = options.store.getIntentEnvelope(event.payload.intentId);
+			if (!localEnvelope || localEnvelope.kind !== TaskEnvelopeKind.intent || localEnvelope.taskId !== task.taskId
+				|| !sameEndpoint(localEnvelope.source, options.endpoint) || !sameEndpoint(localEnvelope.target, task.origin)) return false;
+			const intent = parsePayload(localEnvelope);
+			return isTaskIntent(intent) && intent.taskId === event.taskId && intent.type === event.type && intent.intentId === event.payload.intentId;
+		},
+		async flushOutbox(signal, work = createTaskWorkScope(signal)) { await flush(work.signal, undefined, work); },
+		async receive(signal, work = createTaskWorkScope(signal)) {
+			signal = work.signal;
+			const retryAllowed = work.retryAllowed;
+			work.retryAllowed = false; // Nested fanout must finish this page before unrelated retries.
+			try {
+				const cursor = options.store.getReceiveCursor();
+				const page = await options.relay.receive({ endpoint: options.endpoint, cursor, limit: RECEIVE_PAGE_SIZE }, signal);
+				throwIfAborted(signal);
+				if (!isInboxPage(page) || page.deliveries.length > RECEIVE_PAGE_SIZE) throw new TaskProtocolError("INVALID_INBOX", "relay returned an invalid inbox page");
+				let previous = BigInt(cursor);
+				for (const delivery of page.deliveries) {
+					if (!isDelivery(delivery) || !sameEndpoint(delivery.envelope.target, options.endpoint) || BigInt(delivery.cursor) <= previous) throw new TaskProtocolError("INVALID_DELIVERY", "relay returned an invalid or unordered delivery");
+					previous = BigInt(delivery.cursor);
+				}
+				if (page.nextCursor !== (page.deliveries.at(-1)?.cursor ?? cursor) || (!page.deliveries.length && page.hasMore)) throw new TaskProtocolError("INVALID_INBOX", "relay page cursor does not describe its deliveries");
+				// Track the entire observed prefix before an intent can ACK a later
+				// delivery. Keep only pending IDs plus a high-water mark, durably.
+				options.store.transaction(() => options.store.trackRelayDeliveries(options.endpoint, page.deliveries.map(delivery => ({ cursor: delivery.cursor, envelopeId: delivery.envelope.envelopeId }))));
+				const visibleDeliveries: RelayDelivery[] = [];
+				for (const delivery of page.deliveries) {
+					if (options.store.pendingRelayEnvelopeId(options.endpoint, delivery.cursor) === undefined) continue;
+					const received = validateReceivedEnvelope(options, delivery.envelope);
+					let persistedEnvelopeIds: readonly string[] = [];
+					options.store.transaction(() => {
+						if (!options.store.persistInbox(delivery.envelope, delivery.cursor) && received.kind !== "intent") return;
+						persistedEnvelopeIds = persistReceivedEnvelope(options, clock.now, ids, received, delivery.envelope.envelopeId);
+					});
+					if (persistedEnvelopeIds.length > 0) await flush(signal, new Set(persistedEnvelopeIds), work);
+					if (received.kind === "intent") {
+						// Accepted fanout authorizes ACK, but raw repair must not gate later
+						// facts in this fetched page. The checkpoint owns the staged request.
+						options.store.transaction(() => options.store.requestRelayAcknowledgement(options.endpoint, delivery.cursor,
+							options.store.relayAcknowledgementRetryAt(options.endpoint, delivery.cursor)));
+						continue;
+					}
+					visibleDeliveries.push(delivery);
 				}
-				visibleDeliveries.push(delivery);
+				// Repair failure remains visible, but cannot gate this page's protocol intake.
+				await retryRequestedAcknowledgements(work);
+				const pendingRaw = page.deliveries.find(delivery => delivery.envelope.kind === "intent" && options.store.pendingRelayEnvelopeId(options.endpoint, delivery.cursor) !== undefined);
+				if (pendingRaw) throw deferredTaskDelivery({ cursor: pendingRaw.cursor,
+					retryAfterMs: Math.max(0, options.store.relayAcknowledgementRetryAt(options.endpoint, pendingRaw.cursor) - Date.now()) });
+				return visibleDeliveries;
+			} finally {
+				work.retryAllowed = retryAllowed;
+				// Inbox delivery owns the later retry share; direct receive retains its own.
+				if (retryAllowed && !work.signal.aborted) await flush(work.signal, IGNORE_OUTBOX_FAILURES, work);
 			}
-			return visibleDeliveries;
 		},
 		acknowledgeRelayDelivery,
-		async submitIntent(input, signal) { await submitIntentWithOutcome(input, signal); },
+		async submitIntent(input, signal, work) { await submitIntentWithOutcome(input, signal, work); },
 		submitIntentWithOutcome,
-		async recordInsertion(input, signal) {
+		async recordInsertion(input, signal, work = createTaskWorkScope(signal)) {
+			signal = work.signal;
 			const task = requiredTask(options.store, input.taskId);
 			const evidence: DeliveryEvidence = { eventId: input.eventId, stage: TaskDeliveryStage.piInserted, state: TaskDeliveryEvidenceState.confirmed };
 			let persistedEnvelopeIds: readonly string[] = [];
@@ -218,9 +269,9 @@ export function createTaskCore(options: TaskCoreOptions): TaskCore {
 					payload: { eventId: input.eventId, stage: evidence.stage, state: evidence.state },
 				}, deliveryEvidenceOperation(evidence)).envelopeIds;
 			});
-			await flushDeliveryEvidence(options, signal, input.taskId, persistedEnvelopeIds, evidence);
+			await flushDeliveryEvidence(options, signal, input.taskId, persistedEnvelopeIds, evidence, work, flush);
 		},
-		recordWakeRequest(input) {
+		recordWakeRequest(input, work) {
 			const task = requiredTask(options.store, input.taskId);
 			const evidence: DeliveryEvidence = { eventId: input.eventId, stage: TaskDeliveryStage.wakeRequested, state: TaskDeliveryEvidenceState.confirmed };
 			let persistedEnvelopeIds: readonly string[] = [];
@@ -232,10 +283,12 @@ export function createTaskCore(options: TaskCoreOptions): TaskCore {
 				}, deliveryEvidenceOperation(evidence)).envelopeIds;
 			});
 			return { flush: async (signal?: AbortSignal): Promise<void> => {
-				await flushDeliveryEvidence(options, signal, input.taskId, persistedEnvelopeIds, evidence);
+				const activeWork = work ?? createTaskWorkScope(signal);
+				await flushDeliveryEvidence(options, activeWork.signal, input.taskId, persistedEnvelopeIds, evidence, activeWork, flush);
 			} };
 		},
-		async evaluateTimeouts(signal) {
+		async evaluateTimeouts(signal, work = createTaskWorkScope(signal)) {
+			signal = work.signal;
 			const persistedEnvelopeIds: string[] = [];
 			for (const candidate of options.store.listTasks()) {
 				if (!sameEndpoint(candidate.origin, options.endpoint) || TERMINAL_STATUSES.has(candidate.status) || candidate.expiresAt > clock.now()) continue;
@@ -245,9 +298,10 @@ export function createTaskCore(options: TaskCoreOptions): TaskCore {
 					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));
+			if (persistedEnvelopeIds.length > 0) await flush(signal, new Set(persistedEnvelopeIds), work);
 		},
-		async acknowledgeParent(taskId, signal) {
+		async acknowledgeParent(taskId, signal, work = createTaskWorkScope(signal)) {
+			signal = work.signal;
 			let persistedEnvelopeIds: readonly string[] = [];
 			options.store.transaction(() => {
 				const task = requiredTask(options.store, taskId);
@@ -255,7 +309,7 @@ export function createTaskCore(options: TaskCoreOptions): TaskCore {
 				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).envelopeIds;
 			});
-			await flush(options, signal, new Set(persistedEnvelopeIds));
+			await flush(signal, new Set(persistedEnvelopeIds), work);
 		},
 	};
 }
@@ -305,13 +359,13 @@ function validateCanonicalEvent(options: TaskCoreOptions, envelope: RelayEnvelop
 	return { kind: "canonical_event", task, event: payload };
 }
 
-function persistReceivedEnvelope(options: TaskCoreOptions, now: () => number, ids: () => string, received: ReceivedEnvelope): readonly string[] {
+function persistReceivedEnvelope(options: TaskCoreOptions, now: () => number, ids: () => string, received: ReceivedEnvelope, envelopeId: string): readonly string[] {
 	if (received.kind === "assignment") {
 		options.store.putTask(received.task);
 		options.store.appendEvent(received.event);
 		return [];
 	}
-	if (received.kind === "intent") return canonicalize(options, now, ids, received.task, received.intent, received.intent.type).envelopeIds;
+	if (received.kind === "intent") return canonicalize(options, now, ids, received.task, received.intent, received.intent.type, `${RECEIVED_INTENT_OPERATION}:${envelopeId}`).envelopeIds;
 	if (options.store.appendEvent(received.event) && TERMINAL_EVENTS.has(received.event.type)) options.store.setStatus(received.task.taskId, statusFor(received.event.type));
 	return [];
 }
@@ -391,7 +445,7 @@ function canonicalize(options: TaskCoreOptions, now: () => number, ids: () => st
 	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);
-	const canonical = event(task, ids(), type, sequence, options.endpoint, task.target, now(), { intentId: intent.intentId, ...intent.payload });
+	const canonical = event(task, ids(), type, sequence, options.endpoint, task.target, now(), { ...intent.payload, intentId: intent.intentId });
 	const suppressSelfTargetConversationEcho = !echoCanonicalEventToOrigin && sameEndpoint(task.origin, task.target);
 	const targetEnvelope = suppressSelfTargetConversationEcho ? undefined : envelope(ids(), options.endpoint, task.target, task.taskId, TaskEnvelopeKind.canonicalEvent, canonical, canonical.occurredAt);
 	const originEnvelope = !echoCanonicalEventToOrigin || sameEndpoint(task.origin, task.target) ? undefined : envelope(ids(), options.endpoint, task.origin, task.taskId, TaskEnvelopeKind.canonicalEvent, canonical, canonical.occurredAt);
@@ -407,9 +461,9 @@ function canonicalize(options: TaskCoreOptions, now: () => number, ids: () => st
 	return { envelopeIds: persistedEnvelopeIds, eventType: type, reused: false };
 }
 
-async function flushDeliveryEvidence(options: TaskCoreOptions, signal: AbortSignal | undefined, taskId: string, envelopeIds: readonly string[], evidence: DeliveryEvidence): Promise<void> {
+async function flushDeliveryEvidence(options: TaskCoreOptions, signal: AbortSignal | undefined, taskId: string, envelopeIds: readonly string[], evidence: DeliveryEvidence, work: TaskWorkScope, flush: OutboxFlusher): Promise<void> {
 	try {
-		if (envelopeIds.length > 0) await flush(options, signal, new Set(envelopeIds));
+		if (envelopeIds.length > 0) await flush(signal, new Set(envelopeIds), work);
 	} catch (error) {
 		throwIfDeliveryEvidenceBlocked(options.store, taskId, envelopeIds, evidence);
 		throw error;
@@ -417,29 +471,84 @@ async function flushDeliveryEvidence(options: TaskCoreOptions, signal: AbortSign
 	throwIfDeliveryEvidenceBlocked(options.store, taskId, envelopeIds, evidence);
 }
 
-async function flush(options: TaskCoreOptions, signal: AbortSignal | undefined, reportedEnvelopeIds?: ReadonlySet<string>): Promise<void> {
-	const failures: Array<{ readonly envelopeId: string; readonly error: unknown }> = [];
-	for (const record of options.store.outbox("pending")) {
-		try {
-			await options.relay.send(record.envelope, signal);
-			options.store.transaction(() => { options.store.markOutboxAccepted(record.envelope.envelopeId); });
-		} catch (error) {
-			if (signal?.aborted || (error instanceof TaskProtocolError && error.code === "ABORTED")) throw error;
-			if (error instanceof TaskProtocolError && isBlockedOutboxDeliveryCode(error.code) && !error.retryable) {
-				options.store.transaction(() => {
-					options.store.quarantineOutbox(record.envelope.envelopeId, {
-						errorCode: error.code,
-						reason: error.message,
-						details: error.details ?? {},
-						quarantinedAt: Date.now(),
-					});
+type OutboxFlusher = (signal: AbortSignal | undefined, reportedEnvelopeIds: ReadonlySet<string> | undefined, work: TaskWorkScope) => Promise<void>;
+
+function createOutboxFlusher(options: TaskCoreOptions): OutboxFlusher {
+	const inFlight = new Map<string, Promise<void>>();
+	const send = async (record: OutboxRecord, retry: boolean, work: TaskWorkScope): Promise<void> => {
+		const id = record.envelope.envelopeId;
+		const joined = inFlight.get(id);
+		if (joined) { await waitForRelayOperation(joined, work.signal); return; }
+		const retryAt = options.store.outboxRetryAt(id);
+		if (retryAt > Date.now() || !work.claimSend(id, retry)) throw deferredTaskDelivery({ envelopeId: id, retryAfterMs: Math.max(0, retryAt - Date.now()) });
+		const signal = retry ? work.backgroundSignal() : work.signal;
+		const delivery = (async (): Promise<void> => {
+			try {
+				await waitForRelayOperation(options.relay.send(record.envelope, signal), signal);
+				throwIfAborted(signal);
+				options.store.transaction(() => options.store.markOutboxAccepted(id));
+			} catch (error) {
+				if (signal.aborted) throw error;
+				const retryAt = capacityRetryAt(error);
+				if (retryAt !== undefined) {
+					options.store.postponeOutbox(id, retryAt);
+					// A large foreground refusal does not prove smaller old mail cannot fit.
+					if (retry) work.blockedRetryTargets.add(JSON.stringify(record.envelope.target));
+				}
+				if (error instanceof TaskProtocolError && isBlockedOutboxDeliveryCode(error.code) && !error.retryable) options.store.transaction(() => {
+					options.store.quarantineOutbox(id, { errorCode: error.code, reason: error.message, details: error.details ?? {}, quarantinedAt: Date.now() });
 				});
+				throw error;
+			}
+		})();
+		inFlight.set(id, delivery);
+		try { await delivery; } finally { if (inFlight.get(id) === delivery) inFlight.delete(id); }
+	};
+	return async (signal, reportedEnvelopeIds, work) => {
+		throwIfAborted(signal);
+		let failure: unknown;
+		if (reportedEnvelopeIds) for (const id of reportedEnvelopeIds) {
+			const record = options.store.getOutboxRecord(id);
+			if (record?.state === "accepted") continue;
+			if (!record) {
+				const quarantined = options.store.quarantinedOutbox().find(item => item.envelope.envelopeId === id);
+				failure ??= quarantined ? new TaskProtocolError(quarantined.errorCode, quarantined.reason, { retryable: false, details: quarantined.details }) : deferredTaskDelivery({ envelopeId: id });
+				continue;
+			}
+			try { await send(record, false, work); } catch (error) {
+				if (work.signal.aborted) throw error;
+				failure ??= error;
+				if (error instanceof TaskProtocolError && error.code === "TASK_DELIVERY_DEFERRED") break;
 			}
-			failures.push({ envelopeId: record.envelope.envelopeId, error });
 		}
-	}
-	const reportedFailure = failures.find((failure) => reportedEnvelopeIds === undefined || reportedEnvelopeIds.has(failure.envelopeId));
-	if (reportedFailure) throw outboxDeliveryError(reportedFailure.error);
+		if (work.retryAllowed && !work.retryStarted) {
+			work.retryStarted = true;
+			let attempts = 0;
+			for (let inspected = 0; inspected < TASK_WORK_LIMITS.retryInspections && attempts < TASK_WORK_LIMITS.retries; inspected++) {
+				if (!options.store.hasPendingOutbox() || !work.canRetry()) break;
+				// Advance one attempted/actually skipped ID, never an unattempted batch suffix.
+				const record = options.store.selectPendingOutbox(1, Date.now(), 1)[0];
+				if (!record) continue;
+				const id = record.envelope.envelopeId;
+				if (reportedEnvelopeIds?.has(id) || work.attemptedSends.has(id) || inFlight.has(id) || work.blockedRetryTargets.has(JSON.stringify(record.envelope.target))) continue;
+				attempts++;
+				try { await send(record, true, work); } catch (error) {
+					if (work.signal.aborted) throw error;
+					if (reportedEnvelopeIds === undefined) failure ??= error;
+				}
+			}
+		}
+		if (failure === undefined && reportedEnvelopeIds === undefined && options.store.hasPendingOutbox()) failure = deferredTaskDelivery();
+		if (failure !== undefined) throw outboxDeliveryError(failure);
+	};
+}
+
+async function waitForRelayOperation(delivery: Promise<unknown>, signal: AbortSignal): Promise<void> {
+	throwIfAborted(signal);
+	let abort!: () => void;
+	const cancelled = new Promise<never>((_, reject) => { abort = () => reject(new TaskProtocolError("ABORTED", "task operation aborted", { details: { mayHaveBeenDelivered: true } })); signal.addEventListener("abort", abort, { once: true }); });
+	try { await Promise.race([delivery, cancelled]); throwIfAborted(signal); }
+	finally { signal.removeEventListener("abort", abort); }
 }
 
 function outboxDeliveryError(error: unknown): TaskOutboxDeliveryError {

package/src/task-inbox.ts

@@ -1,4 +1,6 @@
 import type { TaskCore } from "./task-core";
+import { createTaskWorkScope } from "./task-work-scope";
+import type { TaskWorkScope } from "./task-work-scope";
 import { TaskDeliveryEvidenceState, TaskDeliveryStage, TaskEnvelopeKind, TaskOutboxDeliveryError, TaskProtocolError, isBlockedOutboxDeliveryCode } from "./task-protocol";
 import type { RelayDelivery, TaskEvent } from "./task-protocol";
 
@@ -34,78 +36,90 @@ type DeliveryEvidencePayload =
 	| { 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<TaskOutboxDeliveryError | undefined> {
-	const deliveries = await core.receive(signal);
+export async function deliverTaskInbox(pi: InboxPi, core: TaskCore, context: InboxContext, signal?: AbortSignal, work = createTaskWorkScope(signal)): Promise<TaskOutboxDeliveryError | undefined> {
+	signal = work.signal;
+	work.retryAllowed = false; // Reserve intake, presentation and evidence/ACK ahead of old work.
 	let outboxError: TaskOutboxDeliveryError | undefined;
-	for (const delivery of deliveries) {
-		if (delivery.envelope.kind === TaskEnvelopeKind.intent) {
-			await core.acknowledgeRelayDelivery(delivery.cursor, signal);
-			pi.appendEntry(TASK_CURSOR_CUSTOM_TYPE, { cursor: delivery.cursor });
-			continue;
-		}
-		const event = inboxEvent(delivery);
-		if (!isKnownEvent(event.type)) throw new TaskProtocolError("UNKNOWN_EVENT", `unknown task inbox event type: ${event.type}`);
-		if (context.hasPendingMessages()) return outboxError;
-		const eventDetails = { taskId: event.taskId, eventId: event.eventId };
-		const eventKey = key(event.taskId, event.eventId);
-		if (!isModelVisible(event.type) && !recordedEventKeys(context.sessionManager.getEntries()).has(eventKey)) {
-			// Archive receipts/parent ACK/late-terminal facts without waking the model.
-			// This is evidence only: no task state or delivery queue is reconstructed.
-			pi.appendEntry(TASK_RECORD_CUSTOM_TYPE, { ...eventDetails, event });
-		}
-		if (event.type === "task.created") {
-			const evidenceError = await recordDeliveryEvidence(core, eventDetails, { stage: TaskDeliveryStage.receiverRecorded, state: TaskDeliveryEvidenceState.confirmed }, signal);
-			outboxError ??= evidenceError;
-		}
-		let incorporated = incorporatedEvents(context.sessionManager.getEntries()).has(eventKey);
-		if (!incorporated && isModelVisible(event.type)) {
-			if (!context.isIdle()) return outboxError;
-			pi.sendMessage({
-				customType: TASK_EVENT_CUSTOM_TYPE,
-				content: renderTaskEvent(event),
-				display: true,
-				details: { ...eventDetails, event },
-			}, { triggerTurn: false });
-			incorporated = incorporatedEvents(context.sessionManager.getEntries()).has(eventKey);
-			if (!incorporated) {
-				const evidenceError = await recordDeliveryEvidence(core, eventDetails, { stage: TaskDeliveryStage.piInsertion, state: TaskDeliveryEvidenceState.blocked, retryable: true }, signal);
+	try {
+		const deliveries = await core.receive(signal, work);
+		for (const delivery of deliveries) {
+			if (delivery.envelope.kind === TaskEnvelopeKind.intent) {
+				await core.acknowledgeRelayDelivery(delivery.cursor, signal, work);
+				pi.appendEntry(TASK_CURSOR_CUSTOM_TYPE, { cursor: delivery.cursor });
+				continue;
+			}
+			const event = inboxEvent(delivery);
+			if (!isKnownEvent(event.type)) throw new TaskProtocolError("UNKNOWN_EVENT", `unknown task inbox event type: ${event.type}`);
+			if (context.hasPendingMessages()) break;
+			const eventDetails = { taskId: event.taskId, eventId: event.eventId };
+			const eventKey = key(event.taskId, event.eventId);
+			const modelVisible = isModelVisible(event.type) && !core.isSelfAuthoredConversation(event);
+			if (!modelVisible && !recordedEventKeys(context.sessionManager.getEntries()).has(eventKey)) {
+				// Archive control facts and confirmed self-authored conversations without model insertion or wake.
+				// This is evidence only: no task state or delivery queue is reconstructed.
+				pi.appendEntry(TASK_RECORD_CUSTOM_TYPE, { ...eventDetails, event });
+			}
+			if (event.type === "task.created") {
+				const evidenceError = await recordDeliveryEvidence(core, eventDetails, { stage: TaskDeliveryStage.receiverRecorded, state: TaskDeliveryEvidenceState.confirmed }, signal, work);
 				outboxError ??= evidenceError;
-				return outboxError;
 			}
-		}
-		if (isModelVisible(event.type)) {
-			const insertionError = await settleDeliveryEvidence(() => core.recordInsertion(eventDetails, signal));
-			outboxError ??= insertionError;
-			let wakeAccepted = taskMessageKeys(context.sessionManager.getEntries(), TASK_WAKE_CUSTOM_TYPE).has(eventKey);
-			const wakeSuppressed = !wakeAccepted && hasAcknowledgedLocalOriginTerminal(core, event);
-			if (!wakeAccepted && !wakeSuppressed) {
-				if (!context.isIdle()) return outboxError;
-				// This synchronous local write closes the ACK/wake race; do not await relay I/O before Pi emits the wake.
-				const wakeRequest = core.recordWakeRequest(eventDetails);
+			let incorporated = incorporatedEvents(context.sessionManager.getEntries()).has(eventKey);
+			if (!incorporated && modelVisible) {
+				if (!context.isIdle()) break;
 				pi.sendMessage({
-					customType: TASK_WAKE_CUSTOM_TYPE,
-					content: "Process the pending Pi task event.",
-					display: false,
-					details: eventDetails,
-				}, { triggerTurn: true, deliverAs: "followUp" });
-				wakeAccepted = taskMessageKeys(context.sessionManager.getEntries(), TASK_WAKE_CUSTOM_TYPE).has(eventKey);
-				if (!wakeAccepted) return outboxError;
-				const wakeRequestError = await settleDeliveryEvidence(() => wakeRequest.flush(signal));
-				outboxError ??= wakeRequestError;
+					customType: TASK_EVENT_CUSTOM_TYPE,
+					content: renderTaskEvent(event),
+					display: true,
+					details: { ...eventDetails, event },
+				}, { triggerTurn: false });
+				incorporated = incorporatedEvents(context.sessionManager.getEntries()).has(eventKey);
+				if (!incorporated) {
+					const evidenceError = await recordDeliveryEvidence(core, eventDetails, { stage: TaskDeliveryStage.piInsertion, state: TaskDeliveryEvidenceState.blocked, retryable: true }, signal, work);
+					outboxError ??= evidenceError;
+					break;
+				}
 			}
-			if (wakeAccepted) {
-				const wakeAcceptanceError = await recordDeliveryEvidence(core, eventDetails, { stage: TaskDeliveryStage.wakeAccepted, state: TaskDeliveryEvidenceState.confirmed }, signal);
-				outboxError ??= wakeAcceptanceError;
+			if (modelVisible) {
+				const insertionError = await settleDeliveryEvidence(() => core.recordInsertion(eventDetails, signal, work));
+				outboxError ??= insertionError;
+				let wakeAccepted = taskMessageKeys(context.sessionManager.getEntries(), TASK_WAKE_CUSTOM_TYPE).has(eventKey);
+				const wakeSuppressed = !wakeAccepted && hasAcknowledgedLocalOriginTerminal(core, event);
+				if (!wakeAccepted && !wakeSuppressed) {
+					if (!context.isIdle()) break;
+					// This synchronous local write closes the ACK/wake race; do not await relay I/O before Pi emits the wake.
+					const wakeRequest = core.recordWakeRequest(eventDetails, work);
+					pi.sendMessage({
+						customType: TASK_WAKE_CUSTOM_TYPE,
+						content: "Process the pending Pi task event.",
+						display: false,
+						details: eventDetails,
+					}, { triggerTurn: true, deliverAs: "followUp" });
+					wakeAccepted = taskMessageKeys(context.sessionManager.getEntries(), TASK_WAKE_CUSTOM_TYPE).has(eventKey);
+					if (!wakeAccepted) break;
+					const wakeRequestError = await settleDeliveryEvidence(() => wakeRequest.flush(signal));
+					outboxError ??= wakeRequestError;
+				}
+				if (wakeAccepted) {
+					const wakeAcceptanceError = await recordDeliveryEvidence(core, eventDetails, { stage: TaskDeliveryStage.wakeAccepted, state: TaskDeliveryEvidenceState.confirmed }, signal, work);
+					outboxError ??= wakeAcceptanceError;
+				}
 			}
+			await core.acknowledgeRelayDelivery(delivery.cursor, signal, work);
+			pi.appendEntry(TASK_CURSOR_CUSTOM_TYPE, { cursor: delivery.cursor });
+		}
+	} finally {
+		// Completed, held or failed presentation yields the remaining bounded share to old work.
+		work.retryAllowed = true;
+		if (!work.signal.aborted) try { await core.flushOutbox(work.signal, work); } catch (error) {
+			if (!(error instanceof TaskOutboxDeliveryError)) throw error;
+			outboxError ??= error;
 		}
-		await core.acknowledgeRelayDelivery(delivery.cursor, signal);
-		pi.appendEntry(TASK_CURSOR_CUSTOM_TYPE, { cursor: delivery.cursor });
 	}
 	return outboxError;
 }
 
-async function recordDeliveryEvidence(core: TaskCore, event: TaskEventDetails, evidence: DeliveryEvidencePayload, signal?: AbortSignal): Promise<TaskOutboxDeliveryError | undefined> {
-	return settleDeliveryEvidence(() => core.submitIntent({ taskId: event.taskId, type: "task.delivery_receipt", payload: { eventId: event.eventId, ...evidence } }, signal));
+async function recordDeliveryEvidence(core: TaskCore, event: TaskEventDetails, evidence: DeliveryEvidencePayload, signal: AbortSignal, work: TaskWorkScope): Promise<TaskOutboxDeliveryError | undefined> {
+	return settleDeliveryEvidence(() => core.submitIntent({ taskId: event.taskId, type: "task.delivery_receipt", payload: { eventId: event.eventId, ...evidence } }, signal, work));
 }
 
 async function settleDeliveryEvidence(operation: () => Promise<void>): Promise<TaskOutboxDeliveryError | undefined> {

package/src/task-store.ts

@@ -1,3 +1,4 @@
+import { TASK_WORK_LIMITS } from "./task-work-scope";
 import { TERMINAL_INTENT_OPERATION, TaskProtocolError } from "./task-protocol";
 import type { RelayTransportBinding, RelayEnvelope, TaskEndpoint, TaskEvent, TaskRecord, TaskSnapshot, TerminalDeliveryState, TerminalTaskIntentType } from "./task-protocol";
 
@@ -25,6 +26,12 @@ export interface TaskStore {
   appendEvent(event: TaskEvent): boolean;
   putOutbox(envelope: RelayEnvelope): void;
   outbox(state: OutboxRecord["state"]): readonly OutboxRecord[];
+  /** Indexed lookup, fair rotation and cooldown are required store capabilities. */
+  getOutboxRecord(envelopeId: string): OutboxRecord | undefined;
+  hasPendingOutbox(): boolean;
+  selectPendingOutbox(limit: number, now: number, maxInspections?: number): readonly OutboxRecord[];
+  outboxRetryAt(envelopeId: string): number;
+  postponeOutbox(envelopeId: string, until: number): void;
   markOutboxAccepted(envelopeId: string): void;
   quarantineOutbox(envelopeId: string, input: OutboxQuarantineInput): void;
   quarantinedOutbox(): readonly OutboxQuarantineRecord[];
@@ -33,10 +40,13 @@ export interface TaskStore {
   setReceiveCursor(cursor: string): void;
   trackRelayDeliveries(endpoint: TaskEndpoint, deliveries: readonly { readonly cursor: string; readonly envelopeId: string }[]): void;
   pendingRelayEnvelopeId(endpoint: TaskEndpoint, cursor: string): string | undefined;
-  requestRelayAcknowledgement(endpoint: TaskEndpoint, cursor: string): void;
-  requestedRelayAcknowledgements(endpoint: TaskEndpoint): readonly string[];
+  requestRelayAcknowledgement(endpoint: TaskEndpoint, cursor: string, retryAt?: number): void;
+  requestedRelayAcknowledgements(endpoint: TaskEndpoint, limit?: number, now?: number): readonly string[];
+  relayAcknowledgementRetryAt(endpoint: TaskEndpoint, cursor: string): number;
   acknowledgeRelayCursor(endpoint: TaskEndpoint, cursor: string): void;
   putIntent(intentId: string, taskId: string, envelopeId: string): void;
+  /** Locally submitted intent only; retained through acceptance or quarantine in this RAM lifetime. */
+  getIntentEnvelope(intentId: string): RelayEnvelope | undefined;
   putInsertionReceipt(taskId: string, eventId: string): boolean;
   reserveTaskOperation(input: TaskOperationRecord): { readonly created: boolean; readonly record: TaskOperationRecord };
   getEndpointGeneration(): string | undefined;
@@ -52,7 +62,7 @@ export interface TaskStore {
 const LIMITS = { entries: 16_384, bytes: 32 * 1024 * 1024 };
 type Cell = { readonly text: string; readonly bytes: number; readonly order: number };
 type Undo = { readonly table: Map<string, Cell>; readonly key: string; readonly prior: Cell | undefined };
-interface Checkpoint { frontier: string; highWater: string; pending: Record<string, string>; requested: Record<string, true>; }
+interface Checkpoint { frontier: string; highWater: string; pending: Record<string, string>; requested: Record<string, number>; }
 
 /** One endpoint lifetime. No SQLite, files, migrations, startup reads or replay. */
 export function createTaskStore(options: TaskStoreOptions = {}): TaskStore {
@@ -61,6 +71,14 @@ export function createTaskStore(options: TaskStoreOptions = {}): TaskStore {
   if (!Number.isInteger(maxEntries) || maxEntries < 1 || maxEntries > LIMITS.entries || !Number.isInteger(maxBytes) || maxBytes < 1 || maxBytes > LIMITS.bytes) throw new TypeError("invalid task memory limit");
   const tables = new Map<string, Map<string, Cell>>();
   const frames: Map<string, Undo>[] = [];
+  // ID-only retry rotation, bounded by the existing pending outbox; no payload copy.
+  const pendingOutbox = new Map<string, number>();
+  const syncPendingOutbox = (id: string) => {
+    const row = tables.get("outbox")?.get(id);
+    if (row && (JSON.parse(row.text) as OutboxRecord).state === "pending") {
+      if (!pendingOutbox.has(id)) pendingOutbox.set(id, 0);
+    } else pendingOutbox.delete(id);
+  };
   let bytes = 0, entries = 0, sequence = 0, closed = false;
   const remember = (name: string, key: string, target: Map<string, Cell>, prior: Cell | undefined) => {
     const frame = frames.at(-1), identity = JSON.stringify([name, key]);
@@ -116,7 +134,11 @@ export function createTaskStore(options: TaskStoreOptions = {}): TaskStore {
         const result = operation();
         if (result instanceof Promise) throw new TypeError("task transactions must be synchronous");
         const parent = frames.at(-2);
-        if (parent) for (const [key, item] of frame) if (!parent.has(key)) parent.set(key, item);
+        if (parent) {
+          for (const [key, item] of frame) if (!parent.has(key)) parent.set(key, item);
+        } else {
+          for (const item of frame.values()) if (item.table === tables.get("outbox")) syncPendingOutbox(item.key);
+        }
         return result;
       } catch (error) {
         for (const item of [...frame.values()].reverse()) { if (item.prior) item.table.set(item.key, item.prior); else item.table.delete(item.key); }
@@ -133,9 +155,28 @@ export function createTaskStore(options: TaskStoreOptions = {}): TaskStore {
     },
     setStatus(id, status) { const task = get<Omit<TaskRecord, "events">>("tasks", id); if (task) put("tasks", id, { ...task, status }); },
     appendEvent(event) { requireTask(event.taskId); return put("events", event.eventId, event, true); },
-    putOutbox(envelope) { put("outbox", envelope.envelopeId, { envelope, state: "pending" }, true); },
+    putOutbox(envelope) { put("outbox", envelope.envelopeId, { envelope, state: "pending" }, true); if (!frames.length) syncPendingOutbox(envelope.envelopeId); },
     outbox(status) { return rows<OutboxRecord>("outbox").filter(item => item.state === status); },
-    markOutboxAccepted(id) { const prior = get<OutboxRecord>("outbox", id); if (prior) put("outbox", id, { ...prior, state: "accepted" }); },
+    getOutboxRecord(id) { return get<OutboxRecord>("outbox", id); },
+    hasPendingOutbox() { check(); return pendingOutbox.size > 0; },
+    selectPendingOutbox(limit, now, maxInspections = TASK_WORK_LIMITS.retryInspections) {
+      check();
+      const selected: OutboxRecord[] = [];
+      // Also bound inspection when the queue is cooling down. Rotate even skipped IDs.
+      const inspections = Math.min(pendingOutbox.size, TASK_WORK_LIMITS.retryInspections, maxInspections);
+      for (let i = 0; i < inspections && selected.length < limit; i++) {
+        const [id, retryAt] = pendingOutbox.entries().next().value!;
+        pendingOutbox.delete(id); pendingOutbox.set(id, retryAt);
+        if (retryAt <= now) {
+          const record = get<OutboxRecord>("outbox", id);
+          if (record?.state === "pending") selected.push(record);
+        }
+      }
+      return selected;
+    },
+    outboxRetryAt(id) { check(); return pendingOutbox.get(id) ?? 0; },
+    postponeOutbox(id, until) { check(); if (pendingOutbox.has(id)) pendingOutbox.set(id, until); },
+    markOutboxAccepted(id) { const prior = get<OutboxRecord>("outbox", id); if (prior) put("outbox", id, { ...prior, state: "accepted" }); if (!frames.length) syncPendingOutbox(id); },
     quarantineOutbox(id, input) {
       store.transaction(() => { const prior = get<OutboxRecord>("outbox", id); if (!prior) return;
         put("quarantine", id, { ...input, envelope: prior.envelope, priorState: prior.state }, true); remove("outbox", id);
@@ -156,12 +197,16 @@ export function createTaskStore(options: TaskStoreOptions = {}): TaskStore {
       writeCheckpoint(endpoint, value);
     },
     pendingRelayEnvelopeId(endpoint, cursor) { return checkpoint(endpoint).pending[cursor]; },
-    requestRelayAcknowledgement(endpoint, cursor) {
+    requestRelayAcknowledgement(endpoint, cursor, retryAt = 0) {
       const value = checkpoint(endpoint);
       if (value.pending[cursor] === undefined) throw new TaskProtocolError("INVALID_CURSOR", "relay delivery is not pending in this endpoint scope");
-      value.requested[cursor] = true; writeCheckpoint(endpoint, value);
+      value.requested[cursor] = retryAt; writeCheckpoint(endpoint, value);
     },
-    requestedRelayAcknowledgements(endpoint) { return Object.keys(checkpoint(endpoint).requested); },
+    requestedRelayAcknowledgements(endpoint, limit = Number.MAX_SAFE_INTEGER, now = Date.now()) {
+      const value = checkpoint(endpoint);
+      return Object.keys(value.requested).filter(cursor => value.requested[cursor]! <= now).slice(0, limit);
+    },
+    relayAcknowledgementRetryAt(endpoint, cursor) { return checkpoint(endpoint).requested[cursor] ?? 0; },
     acknowledgeRelayCursor(endpoint, cursor) {
       store.transaction(() => {
         const value = checkpoint(endpoint); if (value.pending[cursor] === undefined) return;
@@ -173,6 +218,12 @@ export function createTaskStore(options: TaskStoreOptions = {}): TaskStore {
       });
     },
     putIntent(intentId, taskId, envelopeId) { put("intents", intentId, { taskId, envelopeId }, true); },
+    getIntentEnvelope(intentId) {
+      const intent = get<{ taskId: string; envelopeId: string }>("intents", intentId);
+      if (!intent) return undefined;
+      const envelope = (get<OutboxRecord>("outbox", intent.envelopeId) ?? get<OutboxQuarantineRecord>("quarantine", intent.envelopeId))?.envelope;
+      return envelope?.taskId === intent.taskId ? envelope : undefined;
+    },
     putInsertionReceipt(taskId, eventId) { requireTask(taskId); return put("insertions", pair(taskId, eventId), true, true); },
     reserveTaskOperation(input) { requireTask(input.taskId); const key = pair(input.taskId, input.operation); const created = put("operations", key, input, true); return { created, record: get<TaskOperationRecord>("operations", key)! }; },
     getEndpointGeneration() { return state<string>("generation"); },
@@ -181,7 +232,7 @@ export function createTaskStore(options: TaskStoreOptions = {}): TaskStore {
     setEndpointBinding(value) { put("state", "endpoint", value); },
     getRelayTransportBinding() { return state<RelayTransportBinding>("transport"); },
     setRelayTransportBinding(value) { put("state", "transport", value); },
-    clear() { check(); if (frames.length) throw new Error("cannot clear task state during a transaction"); tables.clear(); bytes = entries = sequence = 0; },
+    clear() { check(); if (frames.length) throw new Error("cannot clear task state during a transaction"); tables.clear(); pendingOutbox.clear(); bytes = entries = sequence = 0; },
     close() { if (closed) return; store.clear(); closed = true; },
   };
   return store;

package/src/task-work-scope.ts

@@ -0,0 +1,63 @@
+import { TaskProtocolError } from "./task-protocol";
+
+export const TASK_WORK_LIMITS = { scopedSends: 56, retries: 8, acknowledgements: 48, pageItems: 50,
+  deadlineMs: 2_000, retrySliceMs: 250, ackRepairSliceMs: 250, capacityCooldownMs: 5_000, retryInspections: 64 } as const;
+
+/** Shared counts for nested receipts/fanout; background I/O also has one finite window. */
+export interface TaskWorkScope {
+  readonly signal: AbortSignal;
+  readonly attemptedSends: Set<string>;
+  readonly attemptedAcknowledgements: Set<string>;
+  readonly blockedRetryTargets: Set<string>;
+  retryStarted: boolean;
+  retryAllowed: boolean;
+  claimSend(envelopeId: string, retry: boolean): boolean;
+  claimAcknowledgement(cursor: string): boolean;
+  canAcknowledge(): boolean;
+  canRetry(): boolean;
+  canRepairAcknowledgement(): boolean;
+  backgroundSignal(): AbortSignal;
+}
+
+export function createTaskWorkScope(signal?: AbortSignal, mode: "background" | "foreground" = "background"): TaskWorkScope {
+  const caller = signal ?? new AbortController().signal;
+  let background: AbortSignal | undefined;
+  const backgroundSignal = () => background ??= AbortSignal.any([caller, AbortSignal.timeout(TASK_WORK_LIMITS.deadlineMs)]);
+  // Foreground requests retain the transport/caller timeout. Their speculative
+  // retries start a bounded background window only after required sends finish.
+  const active = mode === "background" ? backgroundSignal() : caller;
+  const attemptedSends = new Set<string>(), attemptedAcknowledgements = new Set<string>(), blockedRetryTargets = new Set<string>();
+  let scopedSends = 0, retrySends = 0, acknowledgements = 0;
+  let retryUntil: number | undefined, repairUntil: number | undefined;
+  return {
+    signal: active, attemptedSends, attemptedAcknowledgements, blockedRetryTargets, retryStarted: false, retryAllowed: true,
+    backgroundSignal,
+    claimSend(id, retry) {
+      if ((retry ? backgroundSignal() : active).aborted || attemptedSends.has(id) || (retry ? retrySends >= TASK_WORK_LIMITS.retries : scopedSends >= TASK_WORK_LIMITS.scopedSends)) return false;
+      attemptedSends.add(id);
+      if (retry) retrySends++; else scopedSends++;
+      return true;
+    },
+    claimAcknowledgement(cursor) {
+      if (active.aborted || attemptedAcknowledgements.has(cursor) || acknowledgements >= TASK_WORK_LIMITS.acknowledgements) return false;
+      attemptedAcknowledgements.add(cursor); acknowledgements++;
+      return true;
+    },
+    canAcknowledge() { return !active.aborted && acknowledgements < TASK_WORK_LIMITS.acknowledgements; },
+    // Slices stop admission, not completion: an admitted request gets the
+    // remaining background window, including cancellation and late fences.
+    canRetry() { return !backgroundSignal().aborted && performance.now() < (retryUntil ??= performance.now() + TASK_WORK_LIMITS.retrySliceMs); },
+    canRepairAcknowledgement() { return !backgroundSignal().aborted && performance.now() < (repairUntil ??= performance.now() + TASK_WORK_LIMITS.ackRepairSliceMs); },
+  };
+}
+
+export function deferredTaskDelivery(details?: Record<string, unknown>): TaskProtocolError {
+  return new TaskProtocolError("TASK_DELIVERY_DEFERRED", "task delivery deferred by the local work budget or retry cooldown", { retryable: true, details });
+}
+
+/** Known admission backpressure gets at least one normal polling interval, without another timer. */
+export function capacityRetryAt(error: unknown): number | undefined {
+  if (!(error instanceof TaskProtocolError) || error.code !== "RELAY_CAPACITY" || !error.retryable) return undefined;
+  const hint = error.details?.retryAfterMs;
+  return Date.now() + Math.max(TASK_WORK_LIMITS.capacityCooldownMs, typeof hint === "number" && Number.isFinite(hint) && hint >= 0 ? hint : 0);
+}