@sgtbeatdown/pi-tasks 0.1.0 → 0.1.1

package/src/task-board.ts

@@ -0,0 +1,365 @@
+import { readTaskStoreArtifacts } from "./task-artifacts";
+import type { TaskStoreArtifactRecord, TaskStoreDiagnostic } from "./task-artifacts";
+
+const DEFAULT_MAX_GROUPS = 10;
+const DEFAULT_MAX_TASKS_PER_GROUP = 20;
+const DEFAULT_MAX_UNGROUPED_TASKS = 20;
+const TERMINAL_STATUSES: ReadonlySet<string> = new Set(["completed", "failed", "cancelled", "timed_out", "rejected"]);
+
+export interface TaskBoardOptions {
+	readonly maxGroups?: number;
+	readonly maxTasksPerGroup?: number;
+	readonly maxUngroupedTasks?: number;
+}
+
+export interface TaskBoardTask {
+	readonly taskId: string;
+	readonly status: string;
+}
+
+export interface TaskBoardGroup {
+	readonly phaseId: string;
+	readonly issueId: string;
+	readonly rootCause: string;
+	readonly taskCount: number;
+	readonly tasks: readonly TaskBoardTask[];
+	readonly omittedTaskCount: number;
+	readonly statusCounts: Readonly<Record<string, number>>;
+	readonly hasActiveTasks: boolean;
+	readonly latestUpdatedAt: string | null;
+	readonly latestCompletedAt: string | null;
+	readonly verification: {
+		readonly entryCount: number;
+		readonly statusCounts: Readonly<Record<string, number>>;
+	};
+	readonly blockerCount: number;
+	readonly riskCount: number;
+	readonly loopIndicators: {
+		readonly issueTaskCount: number;
+		readonly rootCauseTaskCount: number;
+		readonly rootCauseIssueCount: number;
+		readonly repeatedIssue: boolean;
+		readonly sharedRootCause: boolean;
+		readonly possiblePingPong: boolean;
+		readonly splitWorkCandidate: boolean;
+	};
+}
+
+export interface TaskBoardReport {
+	readonly schemaVersion: 1;
+	readonly tasksRoot: string;
+	readonly totalTaskRecords: number;
+	readonly groupedTaskCount: number;
+	readonly ungroupedTaskCount: number;
+	readonly totalGroupCount: number;
+	readonly groups: readonly TaskBoardGroup[];
+	readonly omittedGroupCount: number;
+	readonly ungrouped: {
+		readonly taskCount: number;
+		readonly tasks: readonly TaskBoardTask[];
+		readonly omittedTaskCount: number;
+		readonly statusCounts: Readonly<Record<string, number>>;
+		readonly reasonCounts: {
+			readonly missingPhaseId: number;
+			readonly missingIssueId: number;
+			readonly missingRootCause: number;
+		};
+	};
+	readonly diagnostics: readonly TaskStoreDiagnostic[];
+}
+
+interface BoardTaskSource extends TaskBoardTask {
+	readonly phaseId: string | undefined;
+	readonly issueId: string | undefined;
+	readonly rootCause: string | undefined;
+	readonly updatedAt: string | undefined;
+	readonly completedAt: string | undefined;
+	readonly verificationEntryCount: number;
+	readonly verificationStatusCounts: Readonly<Record<string, number>>;
+	readonly blockerCount: number;
+	readonly riskCount: number;
+}
+
+interface MutableBoardGroup {
+	readonly phaseId: string;
+	readonly issueId: string;
+	readonly rootCause: string;
+	readonly tasks: BoardTaskSource[];
+	readonly statusCounts: Record<string, number>;
+	readonly verificationStatusCounts: Record<string, number>;
+	verificationEntryCount: number;
+	blockerCount: number;
+	riskCount: number;
+	latestUpdatedAt: string | undefined;
+	latestCompletedAt: string | undefined;
+	hasActiveTasks: boolean;
+}
+
+export async function buildTaskBoard(tasksRoot: string, options: TaskBoardOptions = {}): Promise<TaskBoardReport> {
+	const maxGroups = normalizeLimit(options.maxGroups, DEFAULT_MAX_GROUPS, "maxGroups");
+	const maxTasksPerGroup = normalizeLimit(options.maxTasksPerGroup, DEFAULT_MAX_TASKS_PER_GROUP, "maxTasksPerGroup");
+	const maxUngroupedTasks = normalizeLimit(options.maxUngroupedTasks, DEFAULT_MAX_UNGROUPED_TASKS, "maxUngroupedTasks");
+	const artifactRead = await readTaskStoreArtifacts(tasksRoot);
+	const tasks = artifactRead.records.map(toBoardTaskSource);
+	const issueTaskCounts = countStringValues(tasks.map((task) => task.issueId));
+	const rootCauseTaskCounts = countStringValues(tasks.map((task) => task.rootCause));
+	const rootCauseIssues = collectRootCauseIssues(tasks);
+	const groupedTasks = tasks.filter(hasCompleteGrouping);
+	const ungroupedTasks = tasks.filter((task) => !hasCompleteGrouping(task));
+	const mutableGroups = groupTasks(groupedTasks);
+	const groups = mutableGroups
+		.map((group) => finalizeGroup(group, issueTaskCounts, rootCauseTaskCounts, rootCauseIssues, maxTasksPerGroup))
+		.sort(compareGroups);
+	const visibleGroups = groups.slice(0, maxGroups);
+	const sortedUngroupedTasks = [...ungroupedTasks].sort(compareTasks);
+
+	return {
+		schemaVersion: 1,
+		tasksRoot,
+		totalTaskRecords: tasks.length,
+		groupedTaskCount: groupedTasks.length,
+		ungroupedTaskCount: ungroupedTasks.length,
+		totalGroupCount: groups.length,
+		groups: visibleGroups,
+		omittedGroupCount: groups.length - visibleGroups.length,
+		ungrouped: {
+			taskCount: ungroupedTasks.length,
+			tasks: sortedUngroupedTasks.slice(0, maxUngroupedTasks).map(compactTask),
+			omittedTaskCount: Math.max(0, ungroupedTasks.length - maxUngroupedTasks),
+			statusCounts: sortedCounts(countStatuses(ungroupedTasks)),
+			reasonCounts: countUngroupedReasons(ungroupedTasks),
+		},
+		diagnostics: artifactRead.diagnostics,
+	};
+}
+
+function toBoardTaskSource(record: TaskStoreArtifactRecord): BoardTaskSource {
+	const task = record.task;
+	const structuredResult = record.result && isRecord(record.result.result) ? record.result.result : undefined;
+	const verification = structuredResult && Array.isArray(structuredResult.verification) ? structuredResult.verification : [];
+	const verificationStatusCounts: Record<string, number> = {};
+	for (const entry of verification) {
+		if (isRecord(entry) && nonEmptyString(entry.status)) {
+			increment(verificationStatusCounts, entry.status);
+		}
+	}
+
+	return {
+		taskId: nonEmptyString(task.id) ? task.id : record.taskDirectoryName,
+		status: nonEmptyString(task.status) ? task.status : "unknown",
+		phaseId: metadataValue(task.metadata, "phaseId"),
+		issueId: metadataValue(task.metadata, "issueId"),
+		rootCause: metadataValue(task.metadata, "rootCause"),
+		updatedAt: nonEmptyString(task.updatedAt) ? task.updatedAt : undefined,
+		completedAt: latestTimestamp(
+			nonEmptyString(task.completedAt) ? task.completedAt : undefined,
+			record.result && nonEmptyString(record.result.completedAt) ? record.result.completedAt : undefined,
+		),
+		verificationEntryCount: verification.length,
+		verificationStatusCounts,
+		blockerCount: structuredResult && Array.isArray(structuredResult.blockers) ? structuredResult.blockers.length : 0,
+		riskCount: structuredResult && Array.isArray(structuredResult.risks) ? structuredResult.risks.length : 0,
+	};
+}
+
+function metadataValue(metadata: unknown, field: "phaseId" | "issueId" | "rootCause"): string | undefined {
+	return isRecord(metadata) && nonEmptyString(metadata[field]) ? metadata[field] : undefined;
+}
+
+function hasCompleteGrouping(task: BoardTaskSource): task is BoardTaskSource & { readonly phaseId: string; readonly issueId: string; readonly rootCause: string } {
+	return task.phaseId !== undefined && task.issueId !== undefined && task.rootCause !== undefined;
+}
+
+function groupTasks(tasks: readonly (BoardTaskSource & { readonly phaseId: string; readonly issueId: string; readonly rootCause: string })[]): readonly MutableBoardGroup[] {
+	const byPhase = new Map<string, Map<string, Map<string, MutableBoardGroup>>>();
+	const groups: MutableBoardGroup[] = [];
+	for (const task of tasks) {
+		let byIssue = byPhase.get(task.phaseId);
+		if (!byIssue) {
+			byIssue = new Map();
+			byPhase.set(task.phaseId, byIssue);
+		}
+		let byRootCause = byIssue.get(task.issueId);
+		if (!byRootCause) {
+			byRootCause = new Map();
+			byIssue.set(task.issueId, byRootCause);
+		}
+		let group = byRootCause.get(task.rootCause);
+		if (!group) {
+			group = {
+				phaseId: task.phaseId,
+				issueId: task.issueId,
+				rootCause: task.rootCause,
+				tasks: [],
+				statusCounts: {},
+				verificationStatusCounts: {},
+				verificationEntryCount: 0,
+				blockerCount: 0,
+				riskCount: 0,
+				latestUpdatedAt: undefined,
+				latestCompletedAt: undefined,
+				hasActiveTasks: false,
+			};
+			byRootCause.set(task.rootCause, group);
+			groups.push(group);
+		}
+		addTaskToGroup(group, task);
+	}
+	return groups;
+}
+
+function addTaskToGroup(group: MutableBoardGroup, task: BoardTaskSource): void {
+	group.tasks.push(task);
+	increment(group.statusCounts, task.status);
+	for (const [status, count] of Object.entries(task.verificationStatusCounts)) {
+		group.verificationStatusCounts[status] = (group.verificationStatusCounts[status] ?? 0) + count;
+	}
+	group.verificationEntryCount += task.verificationEntryCount;
+	group.blockerCount += task.blockerCount;
+	group.riskCount += task.riskCount;
+	group.latestUpdatedAt = latestTimestamp(group.latestUpdatedAt, task.updatedAt);
+	group.latestCompletedAt = latestTimestamp(group.latestCompletedAt, task.completedAt);
+	group.hasActiveTasks ||= !TERMINAL_STATUSES.has(task.status);
+}
+
+function finalizeGroup(
+	group: MutableBoardGroup,
+	issueTaskCounts: Readonly<Record<string, number>>,
+	rootCauseTaskCounts: Readonly<Record<string, number>>,
+	rootCauseIssues: ReadonlyMap<string, ReadonlySet<string>>,
+	maxTasksPerGroup: number,
+): TaskBoardGroup {
+	const tasks = [...group.tasks].sort(compareTasks);
+	const issueTaskCount = issueTaskCounts[group.issueId] ?? group.tasks.length;
+	const rootCauseTaskCount = rootCauseTaskCounts[group.rootCause] ?? group.tasks.length;
+	const rootCauseIssueCount = rootCauseIssues.get(group.rootCause)?.size ?? 1;
+	const repeatedIssue = issueTaskCount > 1;
+	const sharedRootCause = rootCauseIssueCount > 1;
+	return {
+		phaseId: group.phaseId,
+		issueId: group.issueId,
+		rootCause: group.rootCause,
+		taskCount: tasks.length,
+		tasks: tasks.slice(0, maxTasksPerGroup).map(compactTask),
+		omittedTaskCount: Math.max(0, tasks.length - maxTasksPerGroup),
+		statusCounts: sortedCounts(group.statusCounts),
+		hasActiveTasks: group.hasActiveTasks,
+		latestUpdatedAt: group.latestUpdatedAt ?? null,
+		latestCompletedAt: group.latestCompletedAt ?? null,
+		verification: {
+			entryCount: group.verificationEntryCount,
+			statusCounts: sortedCounts(group.verificationStatusCounts),
+		},
+		blockerCount: group.blockerCount,
+		riskCount: group.riskCount,
+		loopIndicators: {
+			issueTaskCount,
+			rootCauseTaskCount,
+			rootCauseIssueCount,
+			repeatedIssue,
+			sharedRootCause,
+			possiblePingPong: repeatedIssue,
+			splitWorkCandidate: repeatedIssue || sharedRootCause,
+		},
+	};
+}
+
+function collectRootCauseIssues(tasks: readonly BoardTaskSource[]): ReadonlyMap<string, ReadonlySet<string>> {
+	const rootCauseIssues = new Map<string, Set<string>>();
+	for (const task of tasks) {
+		if (!task.rootCause || !task.issueId) {
+			continue;
+		}
+		let issueIds = rootCauseIssues.get(task.rootCause);
+		if (!issueIds) {
+			issueIds = new Set();
+			rootCauseIssues.set(task.rootCause, issueIds);
+		}
+		issueIds.add(task.issueId);
+	}
+	return rootCauseIssues;
+}
+
+function countUngroupedReasons(tasks: readonly BoardTaskSource[]): TaskBoardReport["ungrouped"]["reasonCounts"] {
+	let missingPhaseId = 0;
+	let missingIssueId = 0;
+	let missingRootCause = 0;
+	for (const task of tasks) {
+		if (!task.phaseId) missingPhaseId += 1;
+		if (!task.issueId) missingIssueId += 1;
+		if (!task.rootCause) missingRootCause += 1;
+	}
+	return { missingPhaseId, missingIssueId, missingRootCause };
+}
+
+function countStatuses(tasks: readonly BoardTaskSource[]): Record<string, number> {
+	const counts: Record<string, number> = {};
+	for (const task of tasks) {
+		increment(counts, task.status);
+	}
+	return counts;
+}
+
+function countStringValues(values: readonly (string | undefined)[]): Record<string, number> {
+	const counts: Record<string, number> = {};
+	for (const value of values) {
+		if (value) increment(counts, value);
+	}
+	return counts;
+}
+
+function compactTask(task: BoardTaskSource): TaskBoardTask {
+	return { taskId: task.taskId, status: task.status };
+}
+
+function compareGroups(left: TaskBoardGroup, right: TaskBoardGroup): number {
+	if (left.hasActiveTasks !== right.hasActiveTasks) {
+		return left.hasActiveTasks ? -1 : 1;
+	}
+	const leftLatest = latestTimestamp(left.latestUpdatedAt ?? undefined, left.latestCompletedAt ?? undefined) ?? "";
+	const rightLatest = latestTimestamp(right.latestUpdatedAt ?? undefined, right.latestCompletedAt ?? undefined) ?? "";
+	return (
+		compareStrings(rightLatest, leftLatest) ||
+		compareStrings(left.issueId, right.issueId) ||
+		compareStrings(left.rootCause, right.rootCause) ||
+		compareStrings(left.phaseId, right.phaseId)
+	);
+}
+
+function compareTasks(left: BoardTaskSource, right: BoardTaskSource): number {
+	return compareStrings(left.taskId, right.taskId);
+}
+
+function latestTimestamp(left: string | undefined, right: string | undefined): string | undefined {
+	if (!left) return right;
+	if (!right) return left;
+	return compareStrings(left, right) >= 0 ? left : right;
+}
+
+function sortedCounts(counts: Readonly<Record<string, number>>): Record<string, number> {
+	return Object.fromEntries(Object.entries(counts).sort(([left], [right]) => compareStrings(left, right)));
+}
+
+function normalizeLimit(value: number | undefined, fallback: number, name: string): number {
+	const limit = value ?? fallback;
+	if (!Number.isInteger(limit) || limit < 0) {
+		throw new RangeError(`${name} must be a non-negative integer`);
+	}
+	return limit;
+}
+
+function increment(counts: Record<string, number>, key: string): void {
+	counts[key] = (counts[key] ?? 0) + 1;
+}
+
+function compareStrings(left: string, right: string): number {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+
+function nonEmptyString(value: unknown): value is string {
+	return typeof value === "string" && value.length > 0;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}

package/src/task-inbox.ts

@@ -0,0 +1,141 @@
+import type { TaskAssignment, TaskEvent, TaskStatus, WolfpackGatewayClient } from "./gateway-client";
+
+const TASK_EVENT_CUSTOM_TYPE = "wolfpack-task-event";
+const TASK_CURSOR_CUSTOM_TYPE = "wolfpack-task-cursor";
+
+interface InboxContext {
+	readonly isIdle: () => boolean;
+	readonly hasPendingMessages: () => boolean;
+	readonly sessionManager: { readonly buildContextEntries: () => readonly unknown[] };
+}
+
+interface InboxPi {
+	sendMessage(message: { readonly customType: string; readonly content: string; readonly display: boolean; readonly details: TaskEventDetails }, options: { readonly triggerTurn: true }): void;
+	appendEntry(customType: string, data: { readonly cursor: string }): void;
+}
+
+interface TaskEventDetails {
+	readonly taskId: string;
+	readonly eventId: string;
+}
+
+interface InboxClient {
+	inbox(cursor: string, includeAcknowledged: boolean): Promise<{ readonly events: readonly TaskEvent[]; readonly nextCursor: string; readonly hasMore: boolean }>;
+	status(taskId: string): Promise<TaskStatus>;
+	delivered(taskId: string, eventId: string): Promise<unknown>;
+}
+
+export async function deliverTaskInbox(pi: InboxPi, client: InboxClient, ctx: InboxContext, initialCursor: string): Promise<string> {
+	if (!ctx.isIdle() || ctx.hasPendingMessages()) return initialCursor;
+	const entries = ctx.sessionManager.buildContextEntries();
+	const incorporated = incorporatedEvents(entries);
+	const includeAcknowledged = initialCursor === "0" && !hasPersistedCursor(entries);
+	let cursor = initialCursor;
+	for (;;) {
+		const page = await client.inbox(cursor, includeAcknowledged);
+		for (const event of page.events) {
+			if (!modelRelevant(event)) continue;
+			if (!ctx.isIdle() || ctx.hasPendingMessages()) return cursor;
+			const eventKey = key(event.taskId, event.id);
+			const snapshot = await client.status(event.taskId);
+			if (!ctx.isIdle() || ctx.hasPendingMessages()) return cursor;
+			if (incorporated.has(eventKey)) {
+				if (event.destination.sessionId === snapshot.task.target.sessionId) await client.delivered(event.taskId, event.id);
+				continue;
+			}
+			if (terminalHistoryAcknowledged(snapshot)) continue;
+			pi.sendMessage({
+				customType: TASK_EVENT_CUSTOM_TYPE,
+				content: renderTaskEvent(event, snapshot),
+				display: true,
+				details: { taskId: event.taskId, eventId: event.id },
+			}, { triggerTurn: true });
+			if (!incorporatedEvents(ctx.sessionManager.buildContextEntries()).has(eventKey)) return cursor;
+			incorporated.add(eventKey);
+			if (event.destination.sessionId === snapshot.task.target.sessionId) await client.delivered(event.taskId, event.id);
+		}
+		// Inbox cursors are machine-local delivery sequences, never task event sequences.
+		cursor = page.nextCursor;
+		pi.appendEntry(TASK_CURSOR_CUSTOM_TYPE, { cursor });
+		if (!page.hasMore) return cursor;
+	}
+}
+
+function hasPersistedCursor(entries: readonly unknown[]): boolean {
+	return entries.some((entry) => isRecord(entry) && entry.type === "custom" && entry.customType === TASK_CURSOR_CUSTOM_TYPE && isRecord(entry.data) && decimal(entry.data.cursor));
+}
+
+function modelRelevant(event: TaskEvent): boolean {
+	return event.type === "task.created" || event.type === "task.question" || event.type === "task.answer" || event.type === "task.information" || terminalEvent(event.type) || event.type === "task.cancel_requested";
+}
+
+function terminalHistoryAcknowledged(snapshot: TaskStatus): boolean {
+	return ["completed", "failed", "cancelled", "timed_out"].includes(snapshot.status) && snapshot.events.some((event) => event.type === "task.parent_acknowledged");
+}
+
+export function restoredInboxCursor(entries: readonly unknown[]): string {
+	let cursor = "0";
+	for (const entry of entries) {
+		if (!isRecord(entry) || entry.type !== "custom" || entry.customType !== TASK_CURSOR_CUSTOM_TYPE || !isRecord(entry.data) || !decimal(entry.data.cursor)) continue;
+		cursor = entry.data.cursor;
+	}
+	return cursor;
+}
+
+export function incorporatedEvents(entries: readonly unknown[]): Set<string> {
+	const events = new Set<string>();
+	for (const entry of entries) {
+		if (!isRecord(entry) || entry.type !== "custom_message" || entry.customType !== TASK_EVENT_CUSTOM_TYPE || !isRecord(entry.details) || !nonEmpty(entry.details.taskId) || !nonEmpty(entry.details.eventId)) continue;
+		events.add(key(entry.details.taskId, entry.details.eventId));
+	}
+	return events;
+}
+
+export function renderTaskEvent(event: TaskEvent, snapshot: TaskStatus): string {
+	const header = `task: \`${event.taskId}\` · event: \`${event.id}\``;
+	if (event.type === "task.created") return renderAssignment(header, snapshot.task, snapshot.warnings);
+	const message = event.message ? `\n\n${event.message}` : "";
+	const completion = event.completion ?? snapshot.completion;
+	const completionText = completion ? `\n\n**summary:** ${completion.summary}` : "";
+	const parentPrompt = terminalEvent(event.type) && snapshot.task.onCompletePrompt
+		? `\n\n## parent follow-up\n${snapshot.task.onCompletePrompt}`
+		: "";
+	const warnings = renderWarnings(snapshot.warnings);
+	return `## task ${label(event.type)}\n${header}${message}${completionText}${parentPrompt}${warnings}`;
+}
+
+function renderAssignment(header: string, assignment: TaskAssignment, warnings: readonly { readonly code: string; readonly message: string }[]): string {
+	const context = assignment.context?.summary ? `\n\n## context\n${assignment.context.summary}` : "";
+	const refs = assignment.context?.refs?.length
+		? `\n\n## selected refs\n${assignment.context.refs.map((ref) => `- \`${ref.path}\`${ref.selector ? ` — ${ref.selector}` : ""}${ref.purpose ? ` — ${ref.purpose}` : ""}`).join("\n")}`
+		: "";
+	return `## task assignment\n${header}\n\n${assignment.task}${context}${refs}${renderWarnings(warnings)}`;
+}
+
+function renderWarnings(warnings: readonly { readonly code: string; readonly message: string }[]): string {
+	return warnings.length === 0 ? "" : `\n\n## gateway warnings\n${warnings.map((warning) => `- ${warning.code}: ${warning.message}`).join("\n")}`;
+}
+
+function label(type: string): string {
+	return type.replace(/^task\./, "").replaceAll("_", " ");
+}
+
+function terminalEvent(type: string): boolean {
+	return type === "task.completed" || type === "task.failed" || type === "task.cancelled" || type === "task.timed_out";
+}
+
+function key(taskId: string, eventId: string): string {
+	return `${taskId}\u0000${eventId}`;
+}
+
+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);
+}

package/src/auto-notify.ts

@@ -1,24 +0,0 @@
-import type { AgentTaskRecord } from "./types";
-
-export function selectUnpromptedTerminalTasks(
-	tasks: readonly AgentTaskRecord[],
-	autoPromptedTaskIds: ReadonlySet<string>,
-): readonly AgentTaskRecord[] {
-	return tasks.filter((task) => !autoPromptedTaskIds.has(task.id));
-}
-
-export function buildBackgroundTaskNotificationPrompt(tasks: readonly AgentTaskRecord[]): string {
-	const taskLines = tasks.map((task) => {
-		const summary = task.error?.message ?? task.status;
-		return `- ${task.id}: status=${task.status}, target=${task.targetSession}, summary=${summary}`;
-	});
-
-	return [
-		"background task results are ready for this parent session.",
-		"call `agent_task_inbox` with `{ ack: true }` now to read and acknowledge the structured results.",
-		"summarize the completed task results to the user concisely.",
-		"do not call agent_task_wait; these tasks already reached a terminal state.",
-		"tasks:",
-		...taskLines,
-	].join("\n");
-}

package/src/protocol.ts

@@ -1,73 +0,0 @@
-import {
-	SUMMARY_MAX_CHARS,
-	TASK_ASSIGNMENT_TYPE,
-	TASK_PROTOCOL_VERSION,
-	type AgentTaskRecord,
-	type StoredTaskResult,
-	type TaskError,
-} from "./types";
-
-export interface AssignmentInput {
-	readonly taskId: string;
-	readonly fromSession: string;
-	readonly instructions: string;
-}
-
-export interface AssignmentEnvelope {
-	readonly type: typeof TASK_ASSIGNMENT_TYPE;
-	readonly taskId: string;
-	readonly fromSession: string;
-	readonly instructions: string;
-	readonly finishByCalling: "agent_task_done";
-	readonly taskProtocol: typeof TASK_PROTOCOL_VERSION;
-	readonly resultContract: {
-		readonly summaryMaxChars: number;
-		readonly noFinalProseAfterTool: true;
-		readonly completionIsStructuredOnly: true;
-	};
-}
-
-export interface CompactTaskResult {
-	readonly schemaVersion: 1;
-	readonly taskId: string;
-	readonly status: AgentTaskRecord["status"];
-	readonly summary: string;
-	readonly artifacts: readonly string[];
-	readonly error: TaskError | null;
-}
-
-export function buildAssignment(input: AssignmentInput): string {
-	const envelope: AssignmentEnvelope = {
-		type: TASK_ASSIGNMENT_TYPE,
-		taskId: input.taskId,
-		fromSession: input.fromSession,
-		instructions: input.instructions,
-		finishByCalling: "agent_task_done",
-		taskProtocol: TASK_PROTOCOL_VERSION,
-		resultContract: {
-			summaryMaxChars: SUMMARY_MAX_CHARS,
-			noFinalProseAfterTool: true,
-			completionIsStructuredOnly: true,
-		},
-	};
-
-	return [
-		"structured task assignment:",
-		"```json",
-		JSON.stringify(envelope, null, 2),
-		"```",
-		"finish by calling agent_task_done exactly once. do not mark completion in prose.",
-	].join("\n");
-}
-
-export function compactTaskResult(task: AgentTaskRecord, result: StoredTaskResult | undefined): CompactTaskResult {
-	return {
-		schemaVersion: 1,
-		taskId: task.id,
-		status: task.status,
-		summary: result?.summary ?? task.error?.message ?? task.status,
-		artifacts: task.resultRef ? [task.resultRef] : [],
-		error: result?.error ?? task.error ?? null,
-	};
-}
-