@sgtbeatdown/pi-tasks 0.1.6 → 0.1.7

package/src/gateway-client.ts

@@ -1,409 +0,0 @@
-export const DEFAULT_WOLFPACK_PORT = 18_790;
-export const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
-export const DEFAULT_TASK_TIMEOUT_MS = 30 * 60 * 1000;
-export const MIN_TASK_TIMEOUT_MS = 1_000;
-export const MAX_TASK_TIMEOUT_MS = 86_400_000;
-// Initial limits; benchmark representative task/context payloads before adjusting them.
-export const MAX_TASK_BYTES = 16 * 1024;
-export const MAX_CONTEXT_SUMMARY_BYTES = 16 * 1024;
-export const MAX_ASSIGNMENT_ENVELOPE_BYTES = 48 * 1024;
-export const MAX_HTTP_BODY_BYTES = 64 * 1024;
-
-export type GatewayErrorCode =
-	| "ABORTED"
-	| "TIMEOUT"
-	| "NETWORK_ERROR"
-	| "MALFORMED_RESPONSE"
-	| "INVALID_RESPONSE"
-	| string;
-
-export class GatewayClientError extends Error {
-	readonly code: GatewayErrorCode;
-	readonly retryable: boolean;
-	readonly path?: string;
-
-	constructor(code: GatewayErrorCode, message: string, retryable: boolean, path?: string) {
-		super(message);
-		this.name = "GatewayClientError";
-		this.code = code;
-		this.retryable = retryable;
-		this.path = path;
-	}
-}
-
-export interface TaskAddress {
-	readonly machine: string;
-	readonly sessionId: string;
-}
-
-export interface ContextRef {
-	readonly path: string;
-	readonly selector?: string;
-	readonly purpose?: string;
-}
-
-export interface TaskContext {
-	readonly summary?: string;
-	readonly refs?: readonly ContextRef[];
-}
-
-export interface TaskWarning {
-	readonly code: string;
-	readonly message: string;
-}
-
-export interface TaskAssignment {
-	readonly taskId: string;
-	readonly source: TaskAddress;
-	readonly target: TaskAddress;
-	readonly task: string;
-	readonly createdAt: string;
-	readonly expiresAt: string;
-	readonly context?: TaskContext;
-	readonly role?: string;
-	readonly metadata?: Record<string, string>;
-	readonly onCompletePrompt?: string;
-}
-
-export interface TaskEvent {
-	readonly id: string;
-	readonly taskId: string;
-	readonly type: string;
-	readonly actor: "parent" | "receiver" | "sender";
-	readonly source: TaskAddress;
-	readonly destination: TaskAddress;
-	readonly sequence: string;
-	readonly occurredAt: string;
-	readonly message?: string;
-	readonly replyToMessageId?: string;
-	readonly payload: Record<string, unknown>;
-	readonly completion?: TaskCompletion;
-}
-
-export interface TaskCompletion {
-	readonly summary: string;
-	readonly result?: Record<string, unknown>;
-	readonly error?: { readonly code: string; readonly message: string; readonly retryable: boolean };
-	readonly artifacts?: readonly { readonly machine: string; readonly project: string; readonly path: string; readonly mimeType?: string; readonly description?: string }[];
-	readonly warnings: readonly TaskWarning[];
-}
-
-export interface TaskStatus {
-	readonly task: TaskAssignment;
-	readonly status: string;
-	readonly events: readonly TaskEvent[];
-	readonly completion?: TaskCompletion;
-	readonly warnings: readonly TaskWarning[];
-}
-
-export interface TaskReceipt {
-	readonly taskId: string;
-	readonly eventId: string;
-	readonly sequence: string;
-	readonly warnings: readonly TaskWarning[];
-}
-
-export interface InboxPage {
-	readonly events: readonly TaskEvent[];
-	readonly nextCursor: string;
-	readonly hasMore: boolean;
-}
-
-export interface WolfpackGatewayClientOptions {
-	readonly baseUrl?: string;
-	readonly port?: string | undefined;
-	readonly sessionName?: string | undefined;
-	readonly timeoutMs?: number;
-}
-
-export interface SendTaskInput {
-	readonly to: TaskAddress;
-	readonly task: string;
-	readonly context?: TaskContext;
-	readonly role?: string;
-	readonly preflight?: { readonly requiredProject?: string };
-	readonly metadata?: Record<string, string>;
-	readonly onCompletePrompt?: string;
-	readonly timeoutMs?: number;
-	readonly idempotencyKey?: string;
-}
-
-export interface MessageTaskInput {
-	readonly taskId: string;
-	readonly type: "question" | "answer" | "information";
-	readonly message: string;
-	readonly replyToMessageId?: string;
-}
-
-export interface TaskCompletionInput {
-	readonly summary: string;
-	readonly result?: Record<string, unknown>;
-	readonly error?: { readonly code: string; readonly message: string; readonly retryable: boolean };
-	readonly artifacts?: readonly { readonly path: string; readonly mimeType?: string; readonly description?: string }[];
-}
-
-export interface CompleteTaskInput {
-	readonly taskId: string;
-	readonly status: "completed" | "failed" | "cancelled";
-	readonly result: TaskCompletionInput;
-}
-
-export interface WolfpackSessionStatus {
-	readonly session: string;
-	readonly sessionId: string;
-	readonly terminal: { readonly exists: boolean; readonly alive: boolean; readonly status: string };
-}
-
-export interface WolfpackGatewayClient {
-	readonly callerSession: string;
-	request(method: "GET" | "POST", path: string, body?: unknown, signal?: AbortSignal): Promise<unknown>;
-	sessionStatus(signal?: AbortSignal): Promise<WolfpackSessionStatus>;
-	send(input: SendTaskInput, signal?: AbortSignal): Promise<TaskReceipt>;
-	status(taskId: string, signal?: AbortSignal): Promise<TaskStatus>;
-	inbox(cursor: string, includeAcknowledged: boolean, signal?: AbortSignal): Promise<InboxPage>;
-	message(input: MessageTaskInput, signal?: AbortSignal): Promise<TaskReceipt>;
-	complete(input: CompleteTaskInput, signal?: AbortSignal): Promise<TaskReceipt>;
-	cancel(taskId: string, signal?: AbortSignal): Promise<TaskReceipt>;
-	delivered(taskId: string, eventId: string, signal?: AbortSignal): Promise<TaskReceipt>;
-	ack(taskId: string, signal?: AbortSignal): Promise<TaskReceipt>;
-}
-
-export function createWolfpackGatewayClient(options: WolfpackGatewayClientOptions = {}): WolfpackGatewayClient {
-	const baseUrl = options.baseUrl ?? `http://127.0.0.1:${portFrom(options.port ?? process.env.WOLFPACK_PORT)}`;
-	const callerSession = options.sessionName ?? process.env.WOLFPACK_SESSION_NAME ?? "unknown-session";
-	const requestTimeoutMs = boundedRequestTimeout(options.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS);
-
-	async function request(method: "GET" | "POST", path: string, body?: unknown, signal?: AbortSignal): Promise<unknown> {
-		const serializedBody = body === undefined ? undefined : serializeBody(body);
-		const timeout = new AbortController();
-		const timeoutId = setTimeout(() => timeout.abort(), requestTimeoutMs);
-		const controller = new AbortController();
-		const abort = (): void => controller.abort();
-		signal?.addEventListener("abort", abort, { once: true });
-		timeout.signal.addEventListener("abort", abort, { once: true });
-		try {
-			const response = await fetch(new URL(path, baseUrl), {
-				method,
-				headers: body === undefined ? undefined : { "content-type": "application/json" },
-				body: serializedBody,
-				signal: controller.signal,
-			});
-			const parsed = await parseJson(response);
-			if (isErrorEnvelope(parsed)) throw new GatewayClientError(parsed.error.code, parsed.error.message, parsed.error.retryable, parsed.error.path);
-			if (!response.ok) throw new GatewayClientError("MALFORMED_RESPONSE", `wolfpack returned HTTP ${response.status} without a task error envelope`, true);
-			if (!isOkEnvelope(parsed)) throw new GatewayClientError("MALFORMED_RESPONSE", "wolfpack returned an invalid task response", true);
-			return parsed;
-		} catch (error) {
-			if (error instanceof GatewayClientError) throw error;
-			if (signal?.aborted) throw new GatewayClientError("ABORTED", "wolfpack request was cancelled", true);
-			if (timeout.signal.aborted) throw new GatewayClientError("TIMEOUT", `wolfpack request exceeded ${requestTimeoutMs}ms`, true);
-			throw new GatewayClientError("NETWORK_ERROR", error instanceof Error ? error.message : "wolfpack request failed", true);
-		} finally {
-			clearTimeout(timeoutId);
-			signal?.removeEventListener("abort", abort);
-		}
-	}
-
-	return {
-		callerSession,
-		request,
-		async sessionStatus(signal) {
-			return parseSessionStatus(await request("GET", query("/api/session-control/status", { session: callerSession }), undefined, signal));
-		},
-		async send(input, signal) {
-			validateSend(input);
-			return parseReceipt(await request("POST", "/api/tasks/v1/send", { callerSession, ...input }, signal));
-		},
-		async status(taskId, signal) {
-			validateId(taskId, "task id");
-			return parseStatus(await request("GET", query("/api/tasks/v1/status", { callerSession, taskId }), undefined, signal));
-		},
-		async inbox(cursor, includeAcknowledged, signal) {
-			if (!decimal(cursor)) throw new GatewayClientError("INVALID_REQUEST", "inbox cursor must be a decimal delivery sequence", false);
-			return parseInbox(await request("GET", query("/api/tasks/v1/inbox", { callerSession, cursor, includeAcknowledged: String(includeAcknowledged) }), undefined, signal));
-		},
-		async message(input, signal) {
-			validateMessage(input);
-			return parseReceipt(await request("POST", "/api/tasks/v1/message", { callerSession, ...input }, signal));
-		},
-		async complete(input, signal) {
-			validateComplete(input);
-			return parseReceipt(await request("POST", "/api/tasks/v1/complete", { callerSession, ...input }, signal));
-		},
-		async cancel(taskId, signal) {
-			validateId(taskId, "task id");
-			return parseReceipt(await request("POST", "/api/tasks/v1/cancel", { callerSession, taskId }, signal));
-		},
-		async delivered(taskId, eventId, signal) {
-			validateId(taskId, "task id");
-			validateId(eventId, "event id");
-			return parseReceipt(await request("POST", "/api/tasks/v1/delivered", { callerSession, taskId, eventId }, signal));
-		},
-		async ack(taskId, signal) {
-			validateId(taskId, "task id");
-			return parseReceipt(await request("POST", "/api/tasks/v1/ack", { callerSession, taskId }, signal));
-		},
-	};
-}
-
-function portFrom(value: string | undefined): number {
-	const port = value === undefined ? DEFAULT_WOLFPACK_PORT : Number(value);
-	return Number.isInteger(port) && port > 0 && port < 65_536 ? port : DEFAULT_WOLFPACK_PORT;
-}
-
-function boundedRequestTimeout(value: number): number {
-	return Number.isInteger(value) && value >= 1 && value <= 60_000 ? value : DEFAULT_REQUEST_TIMEOUT_MS;
-}
-
-function query(path: string, parameters: Record<string, string>): string {
-	const search = new URLSearchParams(parameters);
-	return `${path}?${search.toString()}`;
-}
-
-async function parseJson(response: Response): Promise<unknown> {
-	try {
-		return await response.json();
-	} catch {
-		throw new GatewayClientError("MALFORMED_RESPONSE", "wolfpack returned invalid JSON", true);
-	}
-}
-
-function serializeBody(body: unknown): string {
-	let serialized: string;
-	try {
-		serialized = JSON.stringify(body);
-	} catch {
-		throw new GatewayClientError("INVALID_REQUEST", "task request must be JSON-serializable", false);
-	}
-	if (bytes(serialized) > MAX_HTTP_BODY_BYTES) throw new GatewayClientError("INVALID_REQUEST", "task request exceeds the 64KiB initial HTTP limit", false);
-	return serialized;
-}
-
-function validateSend(input: SendTaskInput): void {
-	const path = sendValidationPath(input);
-	if (path !== undefined) throw new GatewayClientError("INVALID_REQUEST", "task and target address are required and bounded", false, path);
-	if (input.context?.summary !== undefined && (!nonEmpty(input.context.summary) || bytes(input.context.summary) > MAX_CONTEXT_SUMMARY_BYTES)) throw new GatewayClientError("INVALID_REQUEST", "context summary exceeds the 16KiB initial limit", false, "/context/summary");
-	if (bytes(JSON.stringify(input)) > MAX_ASSIGNMENT_ENVELOPE_BYTES) throw new GatewayClientError("INVALID_REQUEST", "assignment envelope exceeds the 48KiB initial limit", false, "");
-	const timeoutMs = input.timeoutMs ?? DEFAULT_TASK_TIMEOUT_MS;
-	if (!Number.isInteger(timeoutMs) || timeoutMs < MIN_TASK_TIMEOUT_MS || timeoutMs > MAX_TASK_TIMEOUT_MS) throw new GatewayClientError("INVALID_REQUEST", "task timeout must be from 1000ms through 24h", false, "/timeoutMs");
-}
-
-function sendValidationPath(input: SendTaskInput): string | undefined {
-	if (!isRecord(input.to)) return "/to";
-	if (!nonEmpty(input.to.machine)) return "/to/machine";
-	if (!nonEmpty(input.to.sessionId)) return "/to/sessionId";
-	if (!nonEmpty(input.task) || bytes(input.task) > MAX_TASK_BYTES) return "/task";
-	if (input.preflight?.requiredProject !== undefined && !nonEmpty(input.preflight.requiredProject)) return "/preflight/requiredProject";
-	if (input.context?.refs !== undefined) {
-		if (!Array.isArray(input.context.refs)) return "/context/refs";
-		for (const [index, ref] of input.context.refs.entries()) {
-			if (!isRecord(ref)) return `/context/refs/${index}`;
-			if (!nonEmpty(ref.path)) return `/context/refs/${index}/path`;
-		}
-	}
-	return undefined;
-}
-
-function validateMessage(input: MessageTaskInput): void {
-	validateId(input.taskId, "task id");
-	if (!nonEmpty(input.message) || bytes(input.message) > MAX_TASK_BYTES || !["question", "answer", "information"].includes(input.type) || (input.replyToMessageId !== undefined && !nonEmpty(input.replyToMessageId))) throw new GatewayClientError("INVALID_REQUEST", "task message is invalid or exceeds the 16KiB initial limit", false);
-}
-
-function validateComplete(input: CompleteTaskInput): void {
-	validateId(input.taskId, "task id");
-	if (!nonEmpty(input.result.summary) || bytes(input.result.summary) > MAX_TASK_BYTES || !["completed", "failed", "cancelled"].includes(input.status)) throw new GatewayClientError("INVALID_REQUEST", "terminal task result is invalid or exceeds the 16KiB initial limit", false);
-	if (input.result.artifacts?.some((artifact) => !nonEmpty(artifact.path))) throw new GatewayClientError("INVALID_REQUEST", "artifact paths must be non-empty", false);
-}
-
-function validateId(value: string, label: string): void {
-	if (!nonEmpty(value)) throw new GatewayClientError("INVALID_REQUEST", `${label} is required`, false);
-}
-
-function parseSessionStatus(value: unknown): WolfpackSessionStatus {
-	if (!isRecord(value) || value.ok !== true || !nonEmpty(value.session) || !nonEmpty(value.sessionId) || !isRecord(value.terminal) || typeof value.terminal.exists !== "boolean" || typeof value.terminal.alive !== "boolean" || !nonEmpty(value.terminal.status)) throw invalidResponse("invalid structured Wolfpack session status");
-	return { session: value.session, sessionId: value.sessionId, terminal: { exists: value.terminal.exists, alive: value.terminal.alive, status: value.terminal.status } };
-}
-
-function parseReceipt(value: unknown): TaskReceipt {
-	if (!isRecord(value) || !nonEmpty(value.taskId) || !nonEmpty(value.eventId) || !decimal(value.sequence) || (value.warnings !== undefined && !warnings(value.warnings))) throw invalidResponse("invalid task acknowledgement");
-	return { taskId: value.taskId, eventId: value.eventId, sequence: value.sequence, warnings: value.warnings ?? [] };
-}
-
-function parseStatus(value: unknown): TaskStatus {
-	if (!isRecord(value) || !assignment(value.task) || !nonEmpty(value.status) || !events(value.events) || !warnings(value.warnings) || (value.completion !== undefined && !completion(value.completion))) throw invalidResponse("invalid task status response");
-	return { task: value.task, status: value.status, events: value.events, warnings: value.warnings, ...(value.completion && { completion: value.completion }) };
-}
-
-function parseInbox(value: unknown): InboxPage {
-	if (!isRecord(value) || !events(value.events) || !decimal(value.nextCursor) || typeof value.hasMore !== "boolean") throw invalidResponse("invalid task inbox response");
-	return { events: value.events, nextCursor: value.nextCursor, hasMore: value.hasMore };
-}
-
-function invalidResponse(message: string): GatewayClientError {
-	return new GatewayClientError("INVALID_RESPONSE", message, true);
-}
-
-function isOkEnvelope(value: unknown): value is Record<string, unknown> & { readonly ok: true } {
-	return isRecord(value) && value.ok === true;
-}
-
-function isErrorEnvelope(value: unknown): value is { readonly ok: false; readonly error: { readonly code: string; readonly message: string; readonly retryable: boolean; readonly path?: string } } {
-	return isRecord(value) && value.ok === false && isRecord(value.error) && nonEmpty(value.error.code) && typeof value.error.message === "string" && typeof value.error.retryable === "boolean"
-		&& (value.error.path === undefined || jsonPointer(value.error.path));
-}
-
-function jsonPointer(value: unknown): value is string {
-	return typeof value === "string" && /^(?:|\/(?:[^~/]|~[01])*)*$/.test(value);
-}
-
-function assignment(value: unknown): value is TaskAssignment {
-	return isRecord(value) && nonEmpty(value.taskId) && isAddress(value.source) && isAddress(value.target) && nonEmpty(value.task) && iso(value.createdAt) && iso(value.expiresAt)
-		&& (value.context === undefined || context(value.context)) && (value.role === undefined || nonEmpty(value.role)) && (value.metadata === undefined || stringRecord(value.metadata)) && (value.onCompletePrompt === undefined || nonEmpty(value.onCompletePrompt));
-}
-
-function context(value: unknown): value is TaskContext {
-	return isRecord(value) && (value.summary === undefined || nonEmpty(value.summary)) && (value.refs === undefined || (Array.isArray(value.refs) && value.refs.every((ref) => isRecord(ref) && nonEmpty(ref.path) && (ref.selector === undefined || typeof ref.selector === "string") && (ref.purpose === undefined || typeof ref.purpose === "string"))));
-}
-
-function events(value: unknown): value is readonly TaskEvent[] {
-	return Array.isArray(value) && value.every((event) => isRecord(event) && nonEmpty(event.id) && nonEmpty(event.taskId) && nonEmpty(event.type) && (event.actor === "parent" || event.actor === "receiver" || event.actor === "sender") && isAddress(event.source) && isAddress(event.destination) && decimal(event.sequence) && iso(event.occurredAt) && isRecord(event.payload) && (event.message === undefined || typeof event.message === "string") && (event.replyToMessageId === undefined || nonEmpty(event.replyToMessageId)) && (event.completion === undefined || completion(event.completion)));
-}
-
-function completion(value: unknown): value is TaskCompletion {
-	return isRecord(value) && nonEmpty(value.summary) && warnings(value.warnings)
-		&& (value.result === undefined || isRecord(value.result))
-		&& (value.error === undefined || (isRecord(value.error) && nonEmpty(value.error.code) && typeof value.error.message === "string" && typeof value.error.retryable === "boolean"))
-		&& (value.artifacts === undefined || (Array.isArray(value.artifacts) && value.artifacts.every((artifact) => isRecord(artifact) && nonEmpty(artifact.machine) && nonEmpty(artifact.project) && nonEmpty(artifact.path) && (artifact.mimeType === undefined || typeof artifact.mimeType === "string") && (artifact.description === undefined || typeof artifact.description === "string"))));
-}
-
-function warnings(value: unknown): value is readonly TaskWarning[] {
-	return Array.isArray(value) && value.every((warning) => isRecord(warning) && nonEmpty(warning.code) && typeof warning.message === "string");
-}
-
-function stringRecord(value: unknown): value is Record<string, string> {
-	return isRecord(value) && Object.values(value).every((field) => typeof field === "string");
-}
-
-function isAddress(value: unknown): value is TaskAddress {
-	return isRecord(value) && nonEmpty(value.machine) && nonEmpty(value.sessionId);
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-function nonEmpty(value: unknown): value is string {
-	return typeof value === "string" && value.length > 0;
-}
-
-function decimal(value: unknown): value is string {
-	return typeof value === "string" && /^(0|[1-9][0-9]*)$/.test(value);
-}
-
-function iso(value: unknown): value is string {
-	return typeof value === "string" && !Number.isNaN(Date.parse(value));
-}
-
-function bytes(value: string): number {
-	return new TextEncoder().encode(value).byteLength;
-}

package/src/legacy-extension.ts

@@ -1,241 +0,0 @@
-import { StringEnum } from "@earendil-works/pi-ai";
-import type { AgentToolResult, ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import { Type } from "typebox";
-
-import { abortableSleep } from "./abortable-sleep";
-import {
-	DEFAULT_TASK_TIMEOUT_MS,
-	GatewayClientError,
-	MAX_TASK_TIMEOUT_MS,
-	MIN_TASK_TIMEOUT_MS,
-	createWolfpackGatewayClient,
-	type TaskCompletionInput,
-	type TaskStatus,
-	type WolfpackGatewayClient,
-} from "./gateway-client";
-import { deliverTaskInbox, restoredInboxCursor } from "./legacy-task-inbox";
-
-const BACKGROUND_POLL_MS = 5_000;
-const WAIT_POLL_MS = 250;
-const SUMMARY_MAX_CHARS = 1_200;
-
-const AddressParams = Type.Object({
-	machine: Type.String({ minLength: 1, description: "local or a canonical Wolfpack machine identity" }),
-	sessionId: Type.String({ minLength: 1, description: "Stable opaque Wolfpack broker session id" }),
-});
-
-const ContextRefParams = Type.Object({
-	path: Type.String({ minLength: 1 }),
-	selector: Type.Optional(Type.String()),
-	purpose: Type.Optional(Type.String()),
-});
-
-const SendParams = Type.Object({
-	to: AddressParams,
-	task: Type.String({ minLength: 1, maxLength: 16 * 1024 }),
-	context: Type.Optional(Type.Object({
-		summary: Type.Optional(Type.String({ minLength: 1, maxLength: 16 * 1024 })),
-		refs: Type.Optional(Type.Array(ContextRefParams)),
-	})),
-	role: Type.Optional(Type.String()),
-	preflight: Type.Optional(Type.Object({ requiredProject: Type.Optional(Type.String()) })),
-	metadata: Type.Optional(Type.Object({
-		phaseId: Type.Optional(Type.String()),
-		issueId: Type.Optional(Type.String()),
-		verificationTier: Type.Optional(Type.String()),
-		rootCause: Type.Optional(Type.String()),
-	})),
-	onCompletePrompt: Type.Optional(Type.String({ maxLength: 4_000 })),
-	timeoutMs: Type.Optional(Type.Integer({ minimum: MIN_TASK_TIMEOUT_MS, maximum: MAX_TASK_TIMEOUT_MS })),
-	idempotencyKey: Type.Optional(Type.String({ minLength: 1 })),
-});
-
-const TaskIdParams = Type.Object({ taskId: Type.String({ minLength: 1 }) });
-const WaitParams = Type.Object({ taskId: Type.String({ minLength: 1 }), timeoutMs: Type.Optional(Type.Integer({ minimum: MIN_TASK_TIMEOUT_MS, maximum: MAX_TASK_TIMEOUT_MS })) });
-const InboxParams = Type.Object({ includeAcknowledged: Type.Optional(Type.Boolean({ default: false })) });
-const MessageParams = Type.Object({
-	taskId: Type.String({ minLength: 1 }),
-	type: StringEnum(["question", "answer", "information"] as const),
-	message: Type.String({ minLength: 1, maxLength: 16 * 1024 }),
-	replyToMessageId: Type.Optional(Type.String({ minLength: 1 })),
-});
-const DoneParams = Type.Object({
-	taskId: Type.String({ minLength: 1 }),
-	status: StringEnum(["completed", "failed", "cancelled"] as const),
-	summary: Type.String({ minLength: 1, maxLength: SUMMARY_MAX_CHARS }),
-	result: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
-	error: Type.Optional(Type.Object({ code: Type.String(), message: Type.String(), retryable: Type.Boolean() })),
-	artifacts: Type.Optional(Type.Array(Type.Object({ path: Type.String({ minLength: 1, description: "artifact paths must name receiver-project-relative regular files to inspect; artifacts are not a changed-file list." }), mimeType: Type.Optional(Type.String()), description: Type.Optional(Type.String()) }))),
-});
-
-export function registerAgentTaskTools(pi: ExtensionAPI, client: WolfpackGatewayClient = createWolfpackGatewayClient()): void {
-	let backgroundTimer: ReturnType<typeof setInterval> | undefined;
-	let inboxContext: ExtensionContext | undefined;
-	const refreshInbox = createSingleFlightInboxRefresh(async () => {
-		if (!inboxContext) return;
-		const cursor = restoredInboxCursor(inboxContext.sessionManager.getEntries());
-		await deliverTaskInbox(pi, client, inboxContext, cursor);
-	});
-
-	pi.on("session_start", async (_event, ctx) => {
-		inboxContext = ctx;
-		ctx.ui.setStatus("wolfpack-tasks", ctx.ui.theme.fg("dim", `tasks: ${client.callerSession}`));
-		backgroundTimer = setInterval(() => {
-			void refreshInbox().catch(() => ctx.ui.setStatus("wolfpack-tasks", ctx.ui.theme.fg("warning", "tasks: unavailable")));
-		}, BACKGROUND_POLL_MS);
-		await refreshInbox().catch(() => undefined);
-	});
-	pi.on("agent_end", async (_event, ctx) => {
-		inboxContext = ctx;
-		setTimeout(() => { void refreshInbox().catch(() => undefined); }, 0);
-	});
-	pi.on("session_shutdown", () => {
-		if (backgroundTimer) clearInterval(backgroundTimer);
-		backgroundTimer = undefined;
-		inboxContext = undefined;
-	});
-
-	pi.registerTool({
-		name: "agent_task_send", label: "Send Agent Task", description: "Durably send a bounded task to an existing Wolfpack Pi session.",
-		promptSnippet: "Send nonblocking structured tasks through the local Wolfpack gateway",
-		promptGuidelines: ["Use agent_task_send for normal nonblocking delegation; do not wait unless the user explicitly asks."],
-		parameters: SendParams,
-		async execute(_toolCallId, params, signal) {
-			try {
-				const receipt = await client.send(params, signal);
-				return toolResult(receipt, `## task accepted\n- task: \`${receipt.taskId}\`\n- target: \`${params.to.machine}/${params.to.sessionId}\`\n- delivery: pending adapter insertion (confirmed by \`task.delivered\`)\n${warnings(receipt.warnings)}`);
-			} catch (error) { return clientError(error); }
-		}, renderResult(result, _options, theme) { return new Text(theme.fg("accent", text(result))); },
-	});
-
-	pi.registerTool({
-		name: "agent_task_status", label: "Task Status", description: "Read compact structured task status from Wolfpack.", parameters: TaskIdParams,
-		async execute(_toolCallId, params, signal) {
-			try { const status = await client.status(params.taskId, signal); return statusResult(status); } catch (error) { return clientError(error); }
-		}, renderResult(result, _options, theme) { return new Text(theme.fg("accent", text(result))); },
-	});
-
-	pi.registerTool({
-		name: "agent_task_wait", label: "Wait Agent Task", description: "Block only when explicitly invoked until a task reaches a terminal state or this wait times out.", parameters: WaitParams,
-		async execute(_toolCallId, params, signal, onUpdate) {
-			const deadline = Date.now() + (params.timeoutMs ?? DEFAULT_TASK_TIMEOUT_MS);
-			try {
-				for (;;) {
-					throwIfAborted(signal);
-					const status = await client.status(params.taskId, signal);
-					if (terminal(status.status)) return statusResult(status);
-					if (Date.now() >= deadline) return toolResult({ taskId: params.taskId, status: status.status, error: { code: "WAIT_TIMEOUT", retryable: true } }, `## task wait\n- task: \`${params.taskId}\`\n- status: ${status.status}\n- wait timed out`);
-					onUpdate?.({ content: [{ type: "text", text: `waiting for ${params.taskId}...` }], details: {} });
-					await abortableSleep(Math.min(WAIT_POLL_MS, Math.max(1, deadline - Date.now())), signal, () => new GatewayClientError("ABORTED", "task wait was cancelled", true));
-				}
-			} catch (error) { return clientError(error); }
-		}, renderResult(result, _options, theme) { return new Text(theme.fg("accent", text(result))); },
-	});
-
-	pi.registerTool({
-		name: "agent_task_inbox", label: "Task Inbox", description: "Read inbox task events without acknowledging them.", parameters: InboxParams,
-		async execute(_toolCallId, params, signal) {
-			try {
-				let cursor = "0";
-				const taskIds = new Set<string>();
-				for (;;) {
-					const page = await client.inbox(cursor, params.includeAcknowledged ?? false, signal);
-					for (const event of page.events) taskIds.add(event.taskId);
-					if (!page.hasMore) break;
-					cursor = page.nextCursor;
-				}
-				const tasks = await Promise.all([...taskIds].map((taskId) => client.status(taskId, signal)));
-				return toolResult({ tasks }, `## task inbox\n${tasks.length === 0 ? "- empty" : tasks.map((task) => `- \`${task.task.taskId}\`: ${task.status}${task.completion ? ` — ${task.completion.summary}` : ""}`).join("\n")}`);
-			} catch (error) { return clientError(error); }
-		}, renderResult(result, _options, theme) { return new Text(theme.fg("accent", text(result))); },
-	});
-
-	pi.registerTool({
-		name: "agent_task_ack", label: "Acknowledge Agent Task", description: "Acknowledge one independently verified terminal task.", parameters: TaskIdParams,
-		async execute(_toolCallId, params, signal) {
-			try { return toolResult(await client.ack(params.taskId, signal), `## task acknowledged\n- task: \`${params.taskId}\``); } catch (error) { return clientError(error); }
-		}, renderResult(result, _options, theme) { return new Text(theme.fg("accent", text(result))); },
-	});
-
-	pi.registerTool({
-		name: "agent_task_message", label: "Message Agent Task", description: "Durably send a question, answer, or information event for a task.", parameters: MessageParams,
-		async execute(_toolCallId, params, signal) {
-			try {
-				const [identity, status] = await Promise.all([client.sessionStatus(signal), client.status(params.taskId, signal)]);
-				const receipt = await client.message(params, signal);
-				const receiverQuestion = params.type === "question" && identity.sessionId === status.task.target.sessionId;
-				return { ...toolResult(receipt, `## task ${params.type}\n- task: \`${params.taskId}\`\n${params.message}`), ...(receiverQuestion ? { terminate: true } : {}) };
-			} catch (error) { return clientError(error); }
-		}, renderResult(result, _options, theme) { return new Text(theme.fg("accent", text(result))); },
-	});
-
-	pi.registerTool({
-		name: "agent_task_cancel", label: "Cancel Agent Task", description: "Request cancellation for a non-terminal task through Wolfpack.", parameters: TaskIdParams,
-		async execute(_toolCallId, params, signal) {
-			try { const receipt = await client.cancel(params.taskId, signal); return toolResult(receipt, `## task cancellation requested\n- task: \`${params.taskId}\`${warnings(receipt.warnings)}`); } catch (error) { return clientError(error); }
-		}, renderResult(result, _options, theme) { return new Text(theme.fg("accent", text(result))); },
-	});
-
-	pi.registerTool({
-		name: "agent_task_done", label: "Complete Agent Task", description: "Finish an assigned task with a structured terminal result. Report source modifications in result.changedFiles; artifacts are receiver-project-relative regular files to inspect, not a changed-file list. Use exactly once as the final action.",
-		promptSnippet: "Complete an assigned task: report changed files in result.changedFiles and artifacts separately", promptGuidelines: ["Report source modifications under result.changedFiles. Reserve artifacts for receiver-project-relative regular files a parent should inspect, not changed-file lists.", "Use agent_task_done exactly once as the final action for an assigned task."], parameters: DoneParams,
-		async execute(_toolCallId, params, signal) {
-			try {
-				const result: TaskCompletionInput = { summary: params.summary, ...(params.result && { result: params.result }), ...(params.error && { error: params.error }), ...(params.artifacts && { artifacts: params.artifacts }) };
-				const receipt = await client.complete({ taskId: params.taskId, status: params.status, result }, signal);
-				return { ...toolResult(receipt, `## task ${params.status}\n- task: \`${params.taskId}\`\n- ${params.summary}${warnings(receipt.warnings)}`), terminate: true };
-			} catch (error) { return clientError(error); }
-		}, renderResult(result, _options, theme) { return new Text(theme.fg("accent", text(result))); },
-	});
-}
-
-export function createSingleFlightInboxRefresh(refresh: () => Promise<void>): () => Promise<void> {
-	let inFlight: Promise<void> | undefined;
-	return (): Promise<void> => {
-		if (inFlight) return inFlight;
-		const current = refresh().finally(() => {
-			if (inFlight === current) inFlight = undefined;
-		});
-		inFlight = current;
-		return current;
-	};
-}
-
-export default function piTasks(pi: ExtensionAPI): void {
-	registerAgentTaskTools(pi);
-}
-
-function statusResult(status: TaskStatus): AgentToolResult<unknown> {
-	return toolResult(status, `## task status\n- task: \`${status.task.taskId}\`\n- status: ${status.status}${status.completion ? `\n- summary: ${status.completion.summary}` : ""}${warnings(status.warnings)}`);
-}
-
-function toolResult(details: unknown, markdown: string): AgentToolResult<unknown> {
-	return { content: [{ type: "text", text: markdown }], details };
-}
-
-function clientError(error: unknown): AgentToolResult<unknown> {
-	const gateway = error instanceof GatewayClientError ? error : new GatewayClientError("CLIENT_ERROR", error instanceof Error ? error.message : "task gateway request failed", true);
-	const path = gateway.path === undefined ? {} : { path: gateway.path };
-	return toolResult(
-		{ error: { code: gateway.code, message: gateway.message, retryable: gateway.retryable, ...path } },
-		`## task gateway error\n- ${gateway.code}: ${gateway.message}${gateway.path === undefined ? "" : `\n- path: \`${gateway.path}\``}`,
-	);
-}
-
-function warnings(values: readonly { readonly code: string; readonly message: string }[]): string {
-	return values.length === 0 ? "" : `\n## gateway warnings\n${values.map((value) => `- ${value.code}: ${value.message}`).join("\n")}`;
-}
-
-function terminal(status: string): boolean {
-	return status === "completed" || status === "failed" || status === "cancelled" || status === "timed_out";
-}
-
-function text(result: { readonly content?: readonly unknown[] }): string {
-	const first = result.content?.[0];
-	return first && typeof first === "object" && "type" in first && first.type === "text" && "text" in first && typeof first.text === "string" ? first.text : "";
-}
-
-function throwIfAborted(signal: AbortSignal | undefined): void {
-	if (signal?.aborted) throw new GatewayClientError("ABORTED", "task wait was cancelled", true);
-}