@sgtbeatdown/pi-tasks 0.1.11 → 0.1.12

package/package.json

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

package/src/extension.ts

@@ -5,7 +5,7 @@ import { Type } from "typebox";
 
 import { abortableSleep } from "./abortable-sleep";
 import { deliverTaskInbox, incorporatedTaskEvents } from "./task-inbox";
-import { TaskDeliveryEvidenceState, TaskDeliveryStage, TaskOutboxDeliveryError, TaskProtocolError } from "./task-protocol";
+import { TaskDeliveryEvidenceState, TaskDeliveryStage, TaskOutboxDeliveryError, TaskProtocolError, isBlockedOutboxDeliveryCode } from "./task-protocol";
 import { createConfiguredTaskCore } from "./configured-task-core";
 import type { OwnedTaskCore } from "./configured-task-core";
 import type { SubmitIntentInput, SubmitIntentOutcome, TaskCore } from "./task-core";
@@ -143,7 +143,7 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 				if (isCurrent()) await activeCore.recordInsertion(input, insertionSignal);
 			},
 		};
-		await deliverTaskInbox({
+		const inboxOutboxError = await deliverTaskInbox({
 			sendMessage(message, options) { if (isCurrent()) pi.sendMessage(message, options); },
 			appendEntry(customType, data) { if (isCurrent()) pi.appendEntry(customType, data); },
 		}, guardedCore, {
@@ -151,7 +151,7 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 			hasPendingMessages: (): boolean => !isCurrent() || context.hasPendingMessages(),
 			sessionManager: context.sessionManager,
 		}, signal);
-		return outboxError;
+		return outboxError ?? inboxOutboxError;
 	});
 	const startBackgroundRefresh = (context: ExtensionContext, epoch: number): void => {
 		inboxContext = context;
@@ -502,7 +502,7 @@ function outboxFailureStatus(error: unknown): string {
 		if (error.code === "RELAY_PROFILE_REQUIRED") return "tasks: compatible memory-owned relay required";
 		if (error.code === "RELAY_AUTH_REQUIRED") return "tasks: Wolfpack authentication required";
 	}
-	return error instanceof TaskOutboxDeliveryError && error.code === TARGET_NOT_REGISTERED_CODE ? "tasks: outbox degraded" : "tasks: relay unavailable";
+	return error instanceof TaskOutboxDeliveryError && isBlockedOutboxDeliveryCode(error.code) ? "tasks: outbox degraded" : "tasks: relay unavailable";
 }
 
 function isRelayLoss(error: unknown): error is TaskProtocolError {

package/src/task-core.ts

@@ -1,6 +1,5 @@
 import {
 	MAX_RELAY_PAYLOAD_BYTES,
-	INVALID_RELAY_METADATA,
 	ORIGIN_CANCELLATION_OPERATION,
 	PARENT_ACKNOWLEDGMENT_OPERATION,
 	TASK_PROTOCOL_VERSION,
@@ -10,6 +9,7 @@ import {
 	TaskEnvelopeKind,
 	TaskOutboxDeliveryError,
 	TaskProtocolError,
+	isBlockedOutboxDeliveryCode,
 } from "./task-protocol";
 import type {
 	RelayDelivery,
@@ -25,7 +25,6 @@ import type { TaskStore } from "./task-store";
 
 const RECEIVE_PAGE_SIZE = 100;
 const DELIVERY_EVIDENCE_OPERATION = "delivery_evidence";
-const TERMINAL_DELIVERY_CODES = new Set(["TARGET_NOT_REGISTERED", INVALID_RELAY_METADATA, "DELIVERY_UNCONFIRMED", "ENVELOPE_EXPIRED", "ENVELOPE_CONFLICT", "CROSS_RELAY_ENDPOINT"]);
 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 CANONICAL_EVENTS = new Set([
@@ -401,7 +400,7 @@ async function flush(options: TaskCoreOptions, signal: AbortSignal | undefined,
 			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 && TERMINAL_DELIVERY_CODES.has(error.code) && !error.retryable) {
+			if (error instanceof TaskProtocolError && isBlockedOutboxDeliveryCode(error.code) && !error.retryable) {
 				options.store.transaction(() => {
 					options.store.quarantineOutbox(record.envelope.envelopeId, {
 						errorCode: error.code,

package/src/task-inbox.ts

@@ -1,5 +1,5 @@
 import type { TaskCore } from "./task-core";
-import { TaskDeliveryEvidenceState, TaskDeliveryStage, TaskEnvelopeKind, TaskProtocolError } from "./task-protocol";
+import { TaskDeliveryEvidenceState, TaskDeliveryStage, TaskEnvelopeKind, TaskOutboxDeliveryError, TaskProtocolError, isBlockedOutboxDeliveryCode } from "./task-protocol";
 import type { RelayDelivery, TaskEvent } from "./task-protocol";
 
 const TASK_EVENT_CUSTOM_TYPE = "pi-tasks-event";
@@ -33,9 +33,10 @@ 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<void> {
-	if (context.hasPendingMessages()) return;
+export async function deliverTaskInbox(pi: InboxPi, core: TaskCore, context: InboxContext, signal?: AbortSignal): Promise<TaskOutboxDeliveryError | undefined> {
+	if (context.hasPendingMessages()) return undefined;
 	const deliveries = await core.receive(signal);
+	let outboxError: TaskOutboxDeliveryError | undefined;
 	for (const delivery of deliveries) {
 		if (delivery.envelope.kind === TaskEnvelopeKind.intent) {
 			await core.acknowledgeRelayDelivery(delivery.cursor, signal);
@@ -44,7 +45,7 @@ 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;
+		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)) {
@@ -53,11 +54,12 @@ export async function deliverTaskInbox(pi: InboxPi, core: TaskCore, context: Inb
 			pi.appendEntry(TASK_RECORD_CUSTOM_TYPE, { ...eventDetails, event });
 		}
 		if (event.type === "task.created") {
-			await recordDeliveryEvidence(core, eventDetails, { stage: TaskDeliveryStage.receiverRecorded, state: TaskDeliveryEvidenceState.confirmed }, signal);
+			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;
+			if (!context.isIdle()) return outboxError;
 			pi.sendMessage({
 				customType: TASK_EVENT_CUSTOM_TYPE,
 				content: renderTaskEvent(event),
@@ -66,16 +68,19 @@ export async function deliverTaskInbox(pi: InboxPi, core: TaskCore, context: Inb
 			}, { 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;
+				const evidenceError = await recordDeliveryEvidence(core, eventDetails, { stage: TaskDeliveryStage.piInsertion, state: TaskDeliveryEvidenceState.blocked, retryable: true }, signal);
+				outboxError ??= evidenceError;
+				return outboxError;
 			}
 		}
 		if (isModelVisible(event.type)) {
-			await core.recordInsertion(eventDetails, signal);
+			const insertionError = await settleDeliveryEvidence(() => core.recordInsertion(eventDetails, signal));
+			outboxError ??= insertionError;
 			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);
+				if (!context.isIdle()) return outboxError;
+				const wakeRequestError = await recordDeliveryEvidence(core, eventDetails, { stage: TaskDeliveryStage.wakeRequested, state: TaskDeliveryEvidenceState.confirmed }, signal);
+				outboxError ??= wakeRequestError;
 				pi.sendMessage({
 					customType: TASK_WAKE_CUSTOM_TYPE,
 					content: "Process the pending Pi task event.",
@@ -83,17 +88,29 @@ export async function deliverTaskInbox(pi: InboxPi, core: TaskCore, context: Inb
 					details: eventDetails,
 				}, { triggerTurn: true, deliverAs: "followUp" });
 				wakeAccepted = taskMessageKeys(context.sessionManager.getEntries(), TASK_WAKE_CUSTOM_TYPE).has(eventKey);
-				if (!wakeAccepted) return;
+				if (!wakeAccepted) return outboxError;
 			}
-			await recordDeliveryEvidence(core, eventDetails, { stage: TaskDeliveryStage.wakeAccepted, state: TaskDeliveryEvidenceState.confirmed }, signal);
+			const wakeAcceptanceError = await recordDeliveryEvidence(core, eventDetails, { stage: TaskDeliveryStage.wakeAccepted, state: TaskDeliveryEvidenceState.confirmed }, signal);
+			outboxError ??= wakeAcceptanceError;
 		}
 		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<void> {
-	await 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): Promise<TaskOutboxDeliveryError | undefined> {
+	return settleDeliveryEvidence(() => core.submitIntent({ taskId: event.taskId, type: "task.delivery_receipt", payload: { eventId: event.eventId, ...evidence } }, signal));
+}
+
+async function settleDeliveryEvidence(operation: () => Promise<void>): Promise<TaskOutboxDeliveryError | undefined> {
+	try {
+		await operation();
+		return undefined;
+	} catch (error) {
+		if (error instanceof TaskOutboxDeliveryError && !error.retryable && isBlockedOutboxDeliveryCode(error.code)) return error;
+		throw error;
+	}
 }
 
 function inboxEvent(delivery: RelayDelivery): TaskEvent {

package/src/task-protocol.ts

@@ -5,6 +5,19 @@ export const ORIGIN_CANCELLATION_OPERATION = "origin_cancellation";
 export const PARENT_ACKNOWLEDGMENT_OPERATION = "parent_acknowledgment";
 export const TERMINAL_INTENT_OPERATION = "terminal_intent";
 
+const BLOCKED_OUTBOX_DELIVERY_CODES: ReadonlySet<string> = new Set([
+	"TARGET_NOT_REGISTERED",
+	INVALID_RELAY_METADATA,
+	"DELIVERY_UNCONFIRMED",
+	"ENVELOPE_EXPIRED",
+	"ENVELOPE_CONFLICT",
+	"CROSS_RELAY_ENDPOINT",
+]);
+
+export function isBlockedOutboxDeliveryCode(code: string): boolean {
+	return BLOCKED_OUTBOX_DELIVERY_CODES.has(code);
+}
+
 export const TaskDeliveryStage = {
 	receiverRecorded: "receiver_recorded",
 	piInsertion: "pi_insertion",

package/src/volatile-task-session.ts

@@ -223,7 +223,12 @@ class Transport {
         if (controller.signal.aborted) throw abortError();
         const response = await this.fetcher(this.url, { method: "POST", headers: { "content-type": "application/json" }, body: encoded, redirect: "error", signal: controller.signal });
         if (controller.signal.aborted) { void response.body?.cancel().catch(() => undefined); throw abortError(); }
-        if (response.status === 401) { void response.body?.cancel().catch(() => undefined); throw failure("RELAY_AUTH_REQUIRED", false); }
+        const rateLimited = response.status === 429;
+        if (response.status === 401 || rateLimited) {
+          // Admission failures need no relay profile. Best-effort cleanup must not mask their status.
+          void response.body?.cancel().catch(() => undefined);
+          throw failure(rateLimited ? "RELAY_CAPACITY" : "RELAY_AUTH_REQUIRED", rateLimited);
+        }
         const reader = response.body?.getReader();
         if (!reader) throw failure("INVALID_RESPONSE", true);
         const cancel = () => { void reader.cancel().catch(() => undefined); };