@sgtbeatdown/pi-tasks 0.1.9 → 0.1.11

package/src/extension.ts

@@ -6,7 +6,8 @@ import { Type } from "typebox";
 import { abortableSleep } from "./abortable-sleep";
 import { deliverTaskInbox, incorporatedTaskEvents } from "./task-inbox";
 import { TaskDeliveryEvidenceState, TaskDeliveryStage, TaskOutboxDeliveryError, TaskProtocolError } from "./task-protocol";
-import { createWolfpackTaskCore } from "./wolfpack-task-relay";
+import { createConfiguredTaskCore } from "./configured-task-core";
+import type { OwnedTaskCore } from "./configured-task-core";
 import type { SubmitIntentInput, SubmitIntentOutcome, TaskCore } from "./task-core";
 import type { TaskEndpoint, TaskSnapshot } from "./task-protocol";
 
@@ -15,6 +16,9 @@ const MIN_TASK_TIMEOUT_MS = 1_000;
 const MAX_TASK_TIMEOUT_MS = 86_400_000;
 const BACKGROUND_POLL_MS = 5_000;
 const TARGET_NOT_REGISTERED_CODE = "TARGET_NOT_REGISTERED";
+const RELAY_STATE_LOST_CODE = "RELAY_STATE_LOST";
+const RELAY_LOSS_CUSTOM_TYPE = "pi-tasks-relay-loss";
+const RELAY_LOSS_CODES = new Set(["RELAY_RESET", "RELAY_REBIND_REQUIRED"]);
 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"]);
@@ -41,51 +45,91 @@ const DoneParams = Type.Object({
 	artifacts: Type.Optional(Type.Array(Type.Object({ path: Type.String({ minLength: 1, description: "artifact paths are receiver-project-relative regular files" }), mimeType: Type.Optional(Type.String()), description: Type.Optional(Type.String()) }))),
 });
 
-export type ConfiguredCoreFactory = (signal?: AbortSignal) => Promise<TaskCore>;
+export type ConfiguredCoreFactory = (signal?: AbortSignal, rebind?: boolean) => Promise<TaskCore & Partial<Pick<OwnedTaskCore, "close">>>;
+export interface ConfiguredCoreLoader extends ConfiguredCoreFactory {
+	close(): Promise<void>;
+	start(): Promise<void>;
+}
+const defaultCoreFactory: ConfiguredCoreFactory = (signal, rebind) => createConfiguredTaskCore({ rebind }, signal);
 
-/** Reuses a successful configured core while allowing the next lifecycle operation to retry a failed setup. */
-export function createConfiguredCoreLoader(factory: ConfiguredCoreFactory): ConfiguredCoreFactory {
-	let corePromise: Promise<TaskCore> | undefined;
-	return async (signal?: AbortSignal): Promise<TaskCore> => {
+/** One lifecycle owns setup and its core. Late setup cannot resurrect a closed lifecycle. */
+export function createConfiguredCoreLoader(factory: ConfiguredCoreFactory): ConfiguredCoreLoader {
+	let corePromise: ReturnType<ConfiguredCoreFactory> | undefined;
+	let controller = new AbortController();
+	let epoch = 0, closed = false;
+	let closing: Promise<void> = Promise.resolve();
+	const load: ConfiguredCoreLoader = async (signal, rebind) => {
+		if (closed) throw new TaskProtocolError("RELAY_CLOSED", "task lifecycle is closed", { retryable: false });
 		if (corePromise) return corePromise;
-		const candidate = Promise.resolve().then(() => factory(signal));
+		const current = epoch;
+		const lifetimeSignal = controller.signal;
+		const combined = signal ? AbortSignal.any([signal, lifetimeSignal]) : lifetimeSignal;
+		const candidate = Promise.resolve().then(async () => {
+			if (combined.aborted) throw new TaskProtocolError("ABORTED", "task setup was cancelled");
+			const value = await factory(combined, rebind);
+			if (current !== epoch || closed || combined.aborted) {
+				await value.close?.();
+				throw new TaskProtocolError("RELAY_CLOSED", "task lifecycle was replaced", { retryable: false });
+			}
+			return value;
+		});
 		corePromise = candidate;
-		try {
-			return await candidate;
-		} catch (error) {
-			if (corePromise === candidate) corePromise = undefined;
-			throw error;
-		}
+		try { return await candidate; }
+		catch (error) { if (corePromise === candidate) corePromise = undefined; throw error; }
+	};
+	load.start = async () => {
+		const current = epoch;
+		await closing;
+		if (current !== epoch) throw new TaskProtocolError("RELAY_CLOSED", "task lifecycle was stopped during startup", { retryable: false });
+		if (closed) { closed = false; controller = new AbortController(); }
+	};
+	load.close = () => {
+		closed = true; epoch++; controller.abort();
+		const prior = corePromise; corePromise = undefined;
+		const dispose = async () => {
+			let value: Awaited<ReturnType<ConfiguredCoreFactory>> | undefined;
+			try { value = await prior; } catch { /* Setup failure already owns cleanup. */ }
+			await value?.close?.();
+		};
+		closing = Promise.all([closing, dispose()]).then(() => undefined);
+		return closing;
 	};
+	return load;
 }
 
-/** Registers v2 endpoint-owned tools using a configured durable Wolfpack relay by default. */
-export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefined = undefined, createCore: ConfiguredCoreFactory = (signal) => createWolfpackTaskCore({}, signal)): void {
+/** Registers endpoint-owned tools using the memory-owned Wolfpack transport by default. */
+export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefined = undefined, createCore: ConfiguredCoreFactory = defaultCoreFactory): void {
 	let inboxContext: ExtensionContext | undefined;
 	let backgroundTimer: ReturnType<typeof setInterval> | undefined;
 	let lifecycleEpoch = 0;
 	const closingTaskIds = new Set<string>();
 	const workerGateEnabled = process.env.PI_TASK_WORKER === "1";
-	const configuredCore: ConfiguredCoreFactory = core === undefined ? createConfiguredCoreLoader(createCore) : async (): Promise<TaskCore> => core;
+	const ownedLoader = core === undefined ? createConfiguredCoreLoader(createCore) : undefined;
+	const configuredCore: ConfiguredCoreFactory = ownedLoader ?? (async (): Promise<TaskCore> => core!);
+	let relayLossRecovery: Promise<void> | undefined;
+	let pendingRelayLossCount: number | undefined;
 	const refreshInbox = createSingleFlightInboxRefresh(async (signal) => {
 		const context = inboxContext;
+		const epoch = lifecycleEpoch;
+		const isCurrent = (): boolean => inboxContext === context && lifecycleEpoch === epoch;
 		if (!context) return undefined;
 		const activeCore = await configuredCore(signal);
-		if (inboxContext !== context) return undefined;
+		if (!isCurrent()) return undefined;
 		let outboxError: unknown;
 		try {
 			await activeCore.flushOutbox(signal);
 		} catch (error) {
+			if (isRelayLoss(error)) return error;
 			outboxError = error;
 		}
-		if (inboxContext !== context) return undefined;
+		if (!isCurrent()) return undefined;
 		try {
 			await activeCore.evaluateTimeouts(signal);
 		} catch (error) {
+			if (isRelayLoss(error)) return error;
 			outboxError ??= error;
 		}
-		if (inboxContext !== context) return undefined;
-		const isCurrent = (): boolean => inboxContext === context;
+		if (!isCurrent()) return undefined;
 		const guardedCore: TaskCore = {
 			...activeCore,
 			async receive(receiveSignal) {
@@ -109,10 +153,64 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 		}, signal);
 		return outboxError;
 	});
+	const startBackgroundRefresh = (context: ExtensionContext, epoch: number): void => {
+		inboxContext = context;
+		if (backgroundTimer) clearInterval(backgroundTimer);
+		backgroundTimer = setInterval(() => {
+			const currentContext = inboxContext;
+			if (currentContext) void refreshLifecycle(currentContext, epoch);
+		}, BACKGROUND_POLL_MS);
+	};
+	const announceFreshBinding = (context: ExtensionContext): void => {
+		if (pendingRelayLossCount === undefined) return;
+		const count = pendingRelayLossCount;
+		pendingRelayLossCount = undefined;
+		const taskSummary = count === 0 ? "No active tasks required local failure records." : `${count} active ${count === 1 ? "task was" : "tasks were"} marked locally failed with unknown remote outcome.`;
+		context.ui.notify(`Relay state was lost; automatically bound a fresh endpoint. ${taskSummary}`, "warning");
+	};
+	const recoverRelayLoss = async (context: ExtensionContext, epoch: number, activeCore: TaskCore | undefined): Promise<boolean> => {
+		if (!ownedLoader || lifecycleEpoch !== epoch || inboxContext !== context) return false;
+		if (relayLossRecovery) { await relayLossRecovery; return true; }
+		const pending = (async (): Promise<void> => {
+			const recoveryEpoch = ++lifecycleEpoch;
+			const activeTasks = activeCore?.listTasks().filter((task) => task.status === "active") ?? [];
+			inboxContext = undefined;
+			if (backgroundTimer) clearInterval(backgroundTimer);
+			backgroundTimer = undefined;
+			await ownedLoader.close();
+			if (recoveryEpoch !== lifecycleEpoch) return;
+			for (const task of activeTasks) {
+				pi.sendMessage({
+					customType: RELAY_LOSS_CUSTOM_TYPE,
+					content: `## task failed locally\ntask: \`${task.taskId}\`\n\nRelay state was lost; the remote outcome is unknown.`,
+					display: true,
+					details: { taskId: task.taskId, status: "failed", error: { code: RELAY_STATE_LOST_CODE, message: "relay state was lost; remote outcome is unknown", retryable: false }, remoteOutcome: "unknown" },
+				}, { triggerTurn: false });
+			}
+			pendingRelayLossCount = (pendingRelayLossCount ?? 0) + activeTasks.length;
+			closingTaskIds.clear();
+			try {
+				await ownedLoader.start();
+				if (recoveryEpoch !== lifecycleEpoch) return;
+				await ownedLoader(undefined, true);
+				if (recoveryEpoch !== lifecycleEpoch) return;
+				announceFreshBinding(context);
+				context.ui.setStatus("pi-tasks", undefined);
+			} catch (error) {
+				if (recoveryEpoch !== lifecycleEpoch) return;
+				context.ui.setStatus("pi-tasks", context.ui.theme.fg("warning", outboxFailureStatus(error)));
+			}
+			if (recoveryEpoch === lifecycleEpoch) startBackgroundRefresh(context, recoveryEpoch);
+		})();
+		relayLossRecovery = pending;
+		try { await pending; } finally { if (relayLossRecovery === pending) relayLossRecovery = undefined; }
+		return true;
+	};
 	const refreshLifecycle = async (context: ExtensionContext, epoch: number): Promise<void> => {
 		const isCurrent = (): boolean => lifecycleEpoch === epoch && inboxContext === context;
+		let activeCore: (TaskCore & Partial<Pick<OwnedTaskCore, "close">>) | undefined;
 		try {
-			const activeCore = await configuredCore();
+			activeCore = await configuredCore();
 			let connectionError: unknown;
 			try {
 				await activeCore.connect();
@@ -120,12 +218,16 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 				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 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);
 		} catch (error) {
+			if (isCurrent() && isRelayLoss(error) && await recoverRelayLoss(context, epoch, activeCore)) return;
 			if (isCurrent()) context.ui.setStatus("pi-tasks", context.ui.theme.fg("warning", outboxFailureStatus(error)));
 		}
 	};
@@ -159,34 +261,35 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 	pi.on("session_start", async (_event, context) => {
 		closingTaskIds.clear();
 		const epoch = ++lifecycleEpoch;
-		inboxContext = context;
-		if (backgroundTimer) clearInterval(backgroundTimer);
-		backgroundTimer = setInterval(() => {
-			const currentContext = inboxContext;
-			if (currentContext) void refreshLifecycle(currentContext, epoch);
-		}, BACKGROUND_POLL_MS);
+		await ownedLoader?.start();
+		if (epoch !== lifecycleEpoch) return;
+		startBackgroundRefresh(context, epoch);
 		await refreshLifecycle(context, epoch);
 	});
 	pi.on("agent_end", async (_event, context) => {
+		if (!inboxContext) return;
 		const epoch = lifecycleEpoch;
 		inboxContext = context;
 		await refreshLifecycle(context, epoch);
 	});
 	pi.on("agent_settled", async (_event, context) => {
+		if (!inboxContext) return;
 		const epoch = lifecycleEpoch;
 		inboxContext = context;
 		await refreshLifecycle(context, epoch);
 	});
-	pi.on("session_shutdown", () => {
+	pi.on("session_shutdown", async () => {
 		closingTaskIds.clear();
 		lifecycleEpoch += 1;
 		if (backgroundTimer) clearInterval(backgroundTimer);
 		backgroundTimer = undefined;
 		inboxContext = undefined;
+		pendingRelayLossCount = undefined;
+		await ownedLoader?.close();
 	});
 
 	pi.registerTool({
-		name: "agent_task_send", label: "Send Agent Task", description: "Persist an endpoint-owned task and submit its opaque assignment envelope to a relay.", parameters: SendParams,
+		name: "agent_task_send", label: "Send Agent Task", description: "Create a task in this endpoint's RAM and submit its assignment; restart loses active state.", parameters: SendParams,
 		async execute(_id, params, signal) {
 			try {
 				const sent = await (await configuredCore(signal)).createTask({ target: params.to, task: params.task, timeoutMs: params.timeoutMs ?? DEFAULT_TASK_TIMEOUT_MS }, signal);
@@ -201,7 +304,7 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 			try {
 				const activeCore = await configuredCore(signal);
 				const task = activeCore.getTask(params.taskId);
-				if (!task) return taskError(new Error("unknown local task"));
+				if (!task) return taskError(new TaskProtocolError("UNKNOWN_TASK", `unknown task: ${params.taskId}`, { retryable: false }));
 				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); }
@@ -215,7 +318,7 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 				for (;;) {
 					await refreshInbox(signal);
 					const task = (await configuredCore(signal)).getTask(params.taskId);
-					if (!task) return taskError(new Error("unknown local task"));
+					if (!task) return taskError(new TaskProtocolError("UNKNOWN_TASK", `unknown task: ${params.taskId}`, { retryable: false }));
 					if (terminal(task.status)) return toolResult(task, `## task status\n- task: \`${task.taskId}\`\n- status: ${task.status}`);
 					if (Date.now() >= deadline) return toolResult({ taskId: params.taskId, status: task.status }, `## task wait\n- task: \`${params.taskId}\`\n- status: ${task.status}\n- wait timed out`);
 					onUpdate?.({ content: [{ type: "text", text: `waiting for ${params.taskId}...` }], details: {} });
@@ -237,12 +340,12 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 		renderResult(result, _options, theme) { return new Text(theme.fg("accent", text(result))); },
 	});
 	pi.registerTool({
-		name: "agent_task_message", label: "Message Agent Task", description: "Persist a message intent before relay submission.", parameters: MessageParams,
+		name: "agent_task_message", label: "Message Agent Task", description: "Record a message intent in this lifetime before relay submission.", parameters: MessageParams,
 		async execute(_id, params, signal) { try { await (await configuredCore(signal)).submitIntent({ taskId: params.taskId, type: `task.${params.type}`, payload: { message: params.message } }, signal); return toolResult({ taskId: params.taskId }, `## task ${params.type}\n- task: \`${params.taskId}\``); } catch (error) { return taskError(error); } },
 		renderResult(result, _options, theme) { return new Text(theme.fg("accent", text(result))); },
 	});
 	pi.registerTool({
-		name: "agent_task_cancel", label: "Cancel Agent Task", description: "Persist cancellation before relay submission.", parameters: TaskIdParams,
+		name: "agent_task_cancel", label: "Cancel Agent Task", description: "Record cancellation in this lifetime before relay submission.", parameters: TaskIdParams,
 		async execute(_id, params, signal) {
 			try {
 				const activeCore = await configuredCore(signal);
@@ -262,7 +365,7 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 		renderResult(result, _options, theme) { return new Text(theme.fg("accent", text(result))); },
 	});
 	pi.registerTool({
-		name: "agent_task_done", label: "Complete Agent Task", description: "Persist a terminal task intent before relay submission.", parameters: DoneParams,
+		name: "agent_task_done", label: "Complete Agent Task", description: "Record a terminal intent in this lifetime before relay submission.", parameters: DoneParams,
 		async execute(_id, params, signal) {
 			try {
 				const activeCore = await configuredCore(signal);
@@ -275,7 +378,7 @@ export function registerAgentTaskTools(pi: ExtensionAPI, core: TaskCore | undefi
 					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 (!task) return taskError(new TaskProtocolError("UNKNOWN_TASK", `unknown task: ${params.taskId}`, { retryable: false }));
 				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}`),
@@ -313,34 +416,34 @@ export default function piTasks(pi: ExtensionAPI): void {
 }
 
 interface TaskDeliveryEvidence {
-	readonly receiverPersistence: "not_confirmed" | "confirmed";
+	readonly receiverReceipt: "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 receiverReceipt: TaskDeliveryEvidence["receiverReceipt"] = "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.receiverRecorded) receiverReceipt = "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";
+			receiverReceipt = "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" };
+	return { receiverReceipt, 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}`;
+	return `\n- receiver receipt (RAM): ${evidence.receiverReceipt}\n- Pi insertion: ${insertion}\n- wake acceptance: ${evidence.wakeAcceptance}\n- model execution: ${evidence.modelExecution}`;
 }
 
 function toolResult(details: unknown, markdown: string): AgentToolResult<unknown> {
@@ -393,10 +496,19 @@ function blockedDeliveryWarning(error: TaskOutboxDeliveryError, target: TaskEndp
 	return { code: error.code, message: error.message, retryable: false, delivery: "blocked", target, details };
 }
 
-function outboxFailureStatus(error: unknown): "tasks: relay unavailable" | "tasks: outbox degraded" {
+function outboxFailureStatus(error: unknown): string {
+	if (error instanceof TaskProtocolError) {
+		if (RELAY_LOSS_CODES.has(error.code)) return "tasks: relay state lost; rebinding automatically";
+		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";
 }
 
+function isRelayLoss(error: unknown): error is TaskProtocolError {
+	return error instanceof TaskProtocolError && RELAY_LOSS_CODES.has(error.code);
+}
+
 function terminal(status: string): boolean {
 	return ["completed", "failed", "cancelled", "timed_out"].includes(status);
 }

package/src/index.ts

@@ -1,13 +1,11 @@
 export { createInMemoryTaskRelay, InMemoryTaskRelay } from "./in-memory-task-relay";
 export { createTaskCore } from "./task-core";
+export { createConfiguredTaskCore } from "./configured-task-core";
+export type { ConfiguredTaskCoreOptions, OwnedTaskCore } from "./configured-task-core";
 export { createTaskStore } from "./task-store";
-export {
-	createWolfpackTaskCore,
-	createWolfpackTaskRelay,
-	WOLFPACK_TASK_RELAY_ID,
-	WOLFPACK_TASK_RELAY_LEASE_MS,
-	WOLFPACK_TASK_RELAY_PROTOCOL_VERSION,
-} from "./wolfpack-task-relay";
+export { createVolatileTaskSession, VOLATILE_PROFILE } from "./volatile-task-session";
+export type { VolatileTaskSession, VolatileTaskSessionOptions } from "./volatile-task-session";
+export { WOLFPACK_TASK_RELAY_ID } from "./wolfpack-endpoint-view";
 export { runTaskRelayConformance } from "./task-relay-conformance";
 export {
 	MAX_RELAY_PAYLOAD_BYTES,
@@ -25,6 +23,7 @@ export type {
 	RelayInboxPage,
 	RelayReceiveRequest,
 	RelayTargetReference,
+	RelayTransportBinding,
 	TaskEndpoint,
 	TaskEvent,
 	TaskIntent,

package/src/task-core.ts

@@ -25,7 +25,7 @@ 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_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([
@@ -301,6 +301,7 @@ interface PersistedIntent {
 }
 
 function persistIntent(options: TaskCoreOptions, now: () => number, ids: () => string, task: TaskRecord, input: SubmitIntentInput, reservedOperation?: string): PersistedIntent {
+	if (!sameEndpoint(options.endpoint, task.origin) && !sameEndpoint(options.endpoint, task.target)) throw new TaskProtocolError("NOT_PARTICIPANT", "historical task belongs to a different endpoint", { retryable: false });
 	if (sameEndpoint(options.endpoint, task.origin)) {
 		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);
@@ -346,7 +347,7 @@ function deliveryEvidence(input: SubmitIntentInput): DeliveryEvidence | undefine
 	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)
+	if ((stage === TaskDeliveryStage.receiverRecorded || stage === TaskDeliveryStage.piInserted || stage === TaskDeliveryStage.wakeRequested || stage === TaskDeliveryStage.wakeAccepted)
 		&& state === TaskDeliveryEvidenceState.confirmed) {
 		return { eventId: input.payload.eventId, stage, state };
 	}
@@ -400,7 +401,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 && (error.code === TARGET_NOT_REGISTERED_CODE || error.code === INVALID_RELAY_METADATA) && !error.retryable) {
+			if (error instanceof TaskProtocolError && TERMINAL_DELIVERY_CODES.has(error.code) && !error.retryable) {
 				options.store.transaction(() => {
 					options.store.quarantineOutbox(record.envelope.envelopeId, {
 						errorCode: error.code,
@@ -482,7 +483,7 @@ function throwIfTerminalDeliveryBlocked(store: TaskStore, taskId: string): void
 
 function requiredTask(store: TaskStore, taskId: string): TaskSnapshot {
 	const task = store.getTask(taskId);
-	if (!task) throw new TaskProtocolError("UNKNOWN_TASK", `unknown task: ${taskId}`);
+	if (!task) throw new TaskProtocolError("UNKNOWN_TASK", `unknown task: ${taskId}`, { retryable: false });
 	return task;
 }
 

package/src/task-inbox.ts

@@ -5,6 +5,7 @@ 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";
+const TASK_RECORD_CUSTOM_TYPE = "pi-tasks-event-record";
 
 interface InboxContext {
 	readonly isIdle: () => boolean;
@@ -17,16 +18,18 @@ interface InboxPi {
 		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;
+	appendEntry(customType: string, data: { readonly cursor: string } | TaskEventDetails): void;
 }
 
 export interface TaskEventDetails {
 	readonly taskId: string;
 	readonly eventId: string;
+	/** Historical evidence only; never used to rebuild active task state. */
+	readonly event?: TaskEvent;
 }
 
 type DeliveryEvidencePayload =
-	| { readonly stage: typeof TaskDeliveryStage.receiverPersisted | typeof TaskDeliveryStage.wakeRequested | typeof TaskDeliveryStage.wakeAccepted; readonly state: typeof TaskDeliveryEvidenceState.confirmed }
+	| { readonly stage: typeof TaskDeliveryStage.receiverRecorded | 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. */
@@ -44,8 +47,13 @@ export async function deliverTaskInbox(pi: InboxPi, core: TaskCore, context: Inb
 		if (context.hasPendingMessages()) return;
 		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") {
-			await recordDeliveryEvidence(core, eventDetails, { stage: TaskDeliveryStage.receiverPersisted, state: TaskDeliveryEvidenceState.confirmed }, signal);
+			await recordDeliveryEvidence(core, eventDetails, { stage: TaskDeliveryStage.receiverRecorded, state: TaskDeliveryEvidenceState.confirmed }, signal);
 		}
 		let incorporated = incorporatedEvents(context.sessionManager.getEntries()).has(eventKey);
 		if (!incorporated && isModelVisible(event.type)) {
@@ -54,7 +62,7 @@ export async function deliverTaskInbox(pi: InboxPi, core: TaskCore, context: Inb
 				customType: TASK_EVENT_CUSTOM_TYPE,
 				content: renderTaskEvent(event),
 				display: true,
-				details: eventDetails,
+				details: { ...eventDetails, event },
 			}, { triggerTurn: false });
 			incorporated = incorporatedEvents(context.sessionManager.getEntries()).has(eventKey);
 			if (!incorporated) {
@@ -126,6 +134,12 @@ function taskMessageDetails(entries: readonly unknown[], customType: string): re
 	return events;
 }
 
+function recordedEventKeys(entries: readonly unknown[]): Set<string> {
+	return new Set(entries.flatMap(entry => isRecord(entry) && entry.type === "custom" && entry.customType === TASK_RECORD_CUSTOM_TYPE
+		&& isRecord(entry.data) && typeof entry.data.taskId === "string" && typeof entry.data.eventId === "string"
+		? [key(entry.data.taskId, entry.data.eventId)] : []));
+}
+
 function taskMessageKeys(entries: readonly unknown[], customType: string): Set<string> {
 	return new Set(taskMessageDetails(entries, customType).map((event) => key(event.taskId, event.eventId)));
 }

package/src/task-protocol.ts

@@ -6,7 +6,7 @@ export const PARENT_ACKNOWLEDGMENT_OPERATION = "parent_acknowledgment";
 export const TERMINAL_INTENT_OPERATION = "terminal_intent";
 
 export const TaskDeliveryStage = {
-	receiverPersisted: "receiver_persisted",
+	receiverRecorded: "receiver_recorded",
 	piInsertion: "pi_insertion",
 	piInserted: "pi_inserted",
 	wakeRequested: "wake_requested",
@@ -23,6 +23,17 @@ export interface TaskEndpoint {
 	readonly id: string;
 }
 
+/** Endpoint-owned transport binding; not task lifecycle or relay replay state. */
+export interface RelayTransportBinding {
+	readonly profile: "volatile-v1";
+	readonly epoch: string;
+	readonly endpoint: TaskEndpoint;
+	readonly generation: string;
+	readonly callerSession: string;
+	readonly url: string;
+	readonly reset?: true;
+}
+
 /** A provider-defined reference which core resolves without interpreting. */
 export interface RelayTargetReference {
 	readonly relay: string;