@dyyz1993/pi-coding-agent 0.74.24 → 0.74.25

package/dist/extensions/coordinator/handler.ts

@@ -0,0 +1,189 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ServerChannel } from "@dyyz1993/pi-coding-agent";
+import type { CoordinatorChannelContract, DelegatedTask, SessionStatus } from "./types.js";
+
+export interface ProcessManagerApi {
+	delegate(task: string, projectPath: string): Promise<{ sessionId: string; status: "started" | "already_running" }>;
+	delegate_send(fromSessionId: string, toSessionId: string, message: string): Promise<{ delivered: boolean; targetStatus: "active" | "started" | "not_found" }>;
+	delegate_status(sessionId: string): Promise<{ status: SessionStatus }>;
+	delegate_list(): Promise<Array<{ sessionId: string; status: SessionStatus; projectPath: string }>>;
+	delegate_stop(sessionId: string): Promise<boolean>;
+	delegate_fork(sessionId: string, task: string, title?: string): Promise<{ sessionId: string; status: "started" | "already_running" }>;
+	delegate_compact_status(sessionId: string): Promise<{ isCompacting: boolean; contextUsage: { tokens: number | null; contextWindow: number; percent: number | null } }>;
+}
+
+export class TaskStore {
+	private filePath: string;
+	private tasks = new Map<string, DelegatedTask>();
+
+	constructor(sessionDir: string) {
+		this.filePath = path.join(sessionDir, "coordinator-tasks.json");
+		this.load();
+	}
+
+	private load(): void {
+		try {
+			if (fs.existsSync(this.filePath)) {
+				const raw = fs.readFileSync(this.filePath, "utf-8");
+				const arr = JSON.parse(raw) as DelegatedTask[];
+				for (const task of arr) {
+					this.tasks.set(task.sessionId, task);
+				}
+			}
+		}
+		catch (err) {
+			console.debug("[coordinator] task file load failed:", err instanceof Error ? err.message : err);
+		}
+	}
+
+	private save(): void {
+		const arr = Array.from(this.tasks.values());
+		fs.writeFileSync(this.filePath, JSON.stringify(arr, null, 2), "utf-8");
+	}
+
+	add(task: DelegatedTask): void {
+		this.tasks.set(task.sessionId, task);
+		this.save();
+	}
+
+	get(sessionId: string): DelegatedTask | undefined {
+		return this.tasks.get(sessionId);
+	}
+
+	update(sessionId: string, patch: Partial<DelegatedTask>): void {
+		const existing = this.tasks.get(sessionId);
+		if (!existing) return;
+		Object.assign(existing, patch);
+		this.save();
+	}
+
+	remove(sessionId: string): void {
+		this.tasks.delete(sessionId);
+		this.save();
+	}
+
+	list(): DelegatedTask[] {
+		return Array.from(this.tasks.values());
+	}
+
+	buildPrompt(): string {
+		const tasks = this.list();
+		if (tasks.length === 0) return "";
+
+		const lines = ["## Delegated Tasks", ""];
+		for (const t of tasks) {
+			const status = t.status === "completed" ? "DONE" : t.status === "stopped" ? "STOPPED" : t.status.toUpperCase();
+			const compactTag = (t as any).isCompacting ? " COMPACTING" : "";
+			const ctxTag = (t as any).contextUsage?.percent != null ? ` ctx:${Math.round((t as any).contextUsage.percent)}%` : "";
+			const elapsed = t.completedAt
+				? `${((t.completedAt - t.dispatchedAt) / 1000).toFixed(1)}s`
+				: `${((Date.now() - t.dispatchedAt) / 1000).toFixed(0)}s elapsed`;
+			lines.push(`- **${t.title}** (id: \`${t.sessionId}\`) — ${status}${compactTag}${ctxTag} — ${elapsed}`);
+			if (t.result) {
+				const preview = t.result.length > 200 ? `${t.result.slice(0, 200)}...` : t.result;
+				lines.push(`  > ${preview}`);
+			}
+		}
+		return lines.join("\n");
+	}
+}
+
+export function createCoordinatorHandler(
+	channel: ServerChannel<CoordinatorChannelContract>,
+	pm: ProcessManagerApi,
+	getSessionId: () => string,
+	getStore: () => TaskStore,
+): void {
+	channel.handle("session_delegate", async (params: unknown) => {
+		const { task, title } = params as { task: string; title?: string };
+		const projectPath = process.cwd();
+		const result = await pm.delegate(task, projectPath);
+
+		getStore().add({
+			sessionId: result.sessionId,
+			title: title || task.slice(0, 60),
+			task,
+			projectPath,
+			dispatchedAt: Date.now(),
+			status: "idle",
+		});
+
+		channel.emit("task_started", {
+			sessionId: result.sessionId,
+			title: title || task.slice(0, 60),
+			task,
+		});
+
+		return result;
+	});
+
+	channel.handle("session_delegate_send", async (params: unknown) => {
+		const { targetSessionId, message } = params as { targetSessionId: string; message: string };
+		const result = await pm.delegate_send(getSessionId(), targetSessionId, message);
+
+		if (result.delivered) {
+			const store = getStore();
+			const task = store.get(targetSessionId);
+			if (task && task.status === "stopped") {
+				store.update(targetSessionId, { status: "idle" });
+			}
+		}
+
+		return result;
+	});
+
+	channel.handle("session_delegate_status", async (params: unknown) => {
+		const { sessionId } = params as { sessionId: string };
+		const store = getStore();
+		const task = store.get(sessionId);
+		if (!task) {
+			await pm.delegate_status(sessionId);
+			return { task: null };
+		}
+		const remote = await pm.delegate_status(sessionId);
+		store.update(sessionId, { status: remote.status });
+		const compactInfo = await pm.delegate_compact_status(sessionId);
+		return { task: store.get(sessionId) ?? null, isCompacting: compactInfo.isCompacting, contextUsage: compactInfo.contextUsage };
+	});
+
+	channel.handle("session_delegate_list", async () => {
+		const store = getStore();
+		for (const t of store.list()) {
+			const remote = await pm.delegate_status(t.sessionId);
+			store.update(t.sessionId, { status: remote.status });
+		}
+		return { tasks: store.list() };
+	});
+
+	channel.handle("session_delegate_stop", async (params: unknown) => {
+		const { sessionId } = params as { sessionId: string };
+		const ok = await pm.delegate_stop(sessionId);
+		if (ok) {
+			getStore().update(sessionId, { status: "stopped" });
+			channel.emit("task_stopped", { sessionId });
+		}
+		return { ok };
+	});
+
+	channel.handle("session_delegate_fork", async (params: unknown) => {
+		const { sessionId, task, title } = params as { sessionId: string; task: string; title?: string };
+		const result = await pm.delegate_fork(sessionId, task, title);
+		getStore().add({
+			sessionId: result.sessionId,
+			title: title || task.slice(0, 60),
+			task,
+			projectPath: process.cwd(),
+			dispatchedAt: Date.now(),
+			status: "idle",
+		});
+
+		channel.emit("task_started", {
+			sessionId: result.sessionId,
+			title: title || task.slice(0, 60),
+			task,
+		});
+
+		return result;
+	});
+}

package/dist/extensions/coordinator/index.ts

@@ -0,0 +1,261 @@
+import {
+	createTypedChannel,
+	type ExtensionAPI,
+} from "@dyyz1993/pi-coding-agent";
+import { Type } from "typebox";
+import { COORDINATOR_CHANNEL_NAME, type CoordinatorChannelContract, type SessionStatus } from "./types.js";
+import { createCoordinatorHandler, TaskStore, type ProcessManagerApi } from "./handler.js";
+
+const DelegateParams = Type.Object({
+	task: Type.String({ description: "Task description to delegate to the background session" }),
+	title: Type.Optional(Type.String({ description: "Short title for this delegated task" })),
+});
+
+const DelegateSendParams = Type.Object({
+	targetSessionId: Type.String({ description: "Session ID to send the message to" }),
+	message: Type.String({ description: "Message content to send" }),
+});
+
+const DelegateStatusParams = Type.Object({
+	sessionId: Type.String({ description: "Session ID to check status for" }),
+});
+
+const DelegateStopParams = Type.Object({
+	sessionId: Type.String({ description: "Session ID to stop" }),
+});
+
+const DelegateForkParams = Type.Object({
+	sessionId: Type.String({ description: "Source session ID to fork from" }),
+	task: Type.String({ description: "Task description for the forked session" }),
+	title: Type.Optional(Type.String({ description: "Short title for the forked task" })),
+});
+
+export default function coordinatorExtension(pi: ExtensionAPI) {
+	const rawChannel = pi.registerChannel(COORDINATOR_CHANNEL_NAME);
+
+	const { server: serverChannel, client } = createTypedChannel<CoordinatorChannelContract>(rawChannel);
+
+	let currentSessionId = "";
+	let store: TaskStore | null = null;
+
+	pi.on("session_start", (_event, ctx) => {
+		currentSessionId = ctx.sessionManager.getSessionId();
+		store = new TaskStore(ctx.sessionManager.getSessionDir());
+	});
+
+	const serverProxy: ProcessManagerApi = {
+		async delegate(task, _projectPath) {
+			return client.call("session_delegate", { task }) as Promise<{ sessionId: string; status: "started" | "already_running" }>;
+		},
+
+		async delegate_send(fromSessionId, toSessionId, message) {
+			return client.call("session_delegate_send", {
+				targetSessionId: toSessionId,
+				message,
+			}) as Promise<{ delivered: boolean; targetStatus: "active" | "started" | "not_found" }>;
+		},
+
+		async delegate_status(sessionId) {
+			try {
+				const result = await client.call("session_delegate_status", { sessionId }) as { task: { status: string } | null };
+				return result.task ? { status: result.task.status as SessionStatus } : { status: "stopped" as const };
+			} catch (err) {
+				console.debug("[coordinator] delegate_status failed:", err instanceof Error ? err.message : err);
+				return { status: "stopped" as const };
+			}
+		},
+
+		async delegate_list() {
+			try {
+				const result = await client.call("session_delegate_list", {}) as { tasks: Array<{ sessionId: string; status: SessionStatus; projectPath: string }> };
+				return result.tasks;
+			} catch (err) {
+				console.debug("[coordinator] delegate_list failed:", err instanceof Error ? err.message : err);
+				return [];
+			}
+		},
+
+		async delegate_stop(sessionId) {
+			try {
+				const result = await client.call("session_delegate_stop", { sessionId }) as { ok: boolean };
+				return result.ok;
+			} catch (err) {
+				console.debug("[coordinator] delegate_stop failed:", err instanceof Error ? err.message : err);
+				return false;
+			}
+		},
+
+		async delegate_fork(sessionId, task, title) {
+			return client.call("session_delegate_fork", { sessionId, task, title }) as Promise<{ sessionId: string; status: "started" | "already_running" }>;
+		},
+
+		async delegate_compact_status(sessionId: string) {
+			try {
+				const result = await client.call("session_delegate_status", { sessionId }) as { isCompacting?: boolean; contextUsage?: { tokens: number | null; contextWindow: number; percent: number | null } };
+				return {
+					isCompacting: result.isCompacting ?? false,
+					contextUsage: result.contextUsage ?? { tokens: null as number | null, contextWindow: 0, percent: null as number | null },
+				};
+			} catch (err) {
+				console.debug("[coordinator] delegate_compact_status failed:", err instanceof Error ? err.message : err);
+				return { isCompacting: false, contextUsage: { tokens: null as number | null, contextWindow: 0, percent: null as number | null } };
+			}
+		},
+	};
+
+	createCoordinatorHandler(
+		serverChannel,
+		serverProxy,
+		() => currentSessionId,
+		() => store ?? new TaskStore("/tmp/coordinator-fallback"),
+	);
+
+	pi.on("context", (event, _ctx) => {
+		if (!store) return;
+		const prompt = store.buildPrompt();
+		if (prompt) {
+			event.messages.push({
+				role: "user",
+				content: [{ type: "text", text: prompt }],
+				timestamp: Date.now(),
+			});
+		}
+	});
+
+  pi.registerTool({
+    name: "session_delegate",
+    label: "Session Delegate",
+    description: [
+      "Delegate a task to a background pi session.",
+      "Returns a sessionId for communication via session_delegate_send.",
+      "The delegated session can message back using its own coordinator channel.",
+      "The delegate session is automatically restarted if inactive when receiving messages.",
+    ].join(" "),
+		parameters: DelegateParams,
+		async execute(toolCallId, params, _signal, _onUpdate, ctx) {
+			const sid = currentSessionId || ctx.sessionManager.getSessionId();
+			const result = await serverProxy.delegate(params.task, ctx.cwd);
+
+			if (store) {
+				store.add({
+					sessionId: result.sessionId,
+					title: params.title || params.task.slice(0, 60),
+					task: params.task,
+					projectPath: ctx.cwd,
+					dispatchedAt: Date.now(),
+					status: "idle",
+				});
+			}
+
+			return {
+				content: [{ type: "text" as const, text: `Delegated task to session ${result.sessionId} (status: ${result.status}). Use session_delegate_send to communicate.` }],
+				details: { ...result, dispatchedBy: sid },
+			};
+		},
+	});
+
+  pi.registerTool({
+    name: "session_delegate_send",
+    label: "Session Delegate Send",
+    description: [
+      "Send a message to a delegated session by sessionId.",
+      "If the target session is not active, the server will automatically restart it",
+      "(same as clicking on the session in the UI) and deliver the message.",
+      "The message is injected as a followUp into the target session.",
+      "This tool only fails if the session file has been physically deleted from disk.",
+    ].join(" "),
+    parameters: DelegateSendParams,
+    async execute(toolCallId, params, _signal, _onUpdate, ctx) {
+      const sid = currentSessionId || ctx.sessionManager.getSessionId();
+      const result = await serverProxy.delegate_send(sid, params.targetSessionId, params.message);
+
+      if (!result.delivered) {
+        return {
+          content: [{ type: "text" as const, text: `Could not deliver message to ${params.targetSessionId}: session not found (the session file may have been deleted from disk)` }],
+          details: { delivered: false, targetSessionId: params.targetSessionId },
+        };
+      }
+
+      return {
+        content: [{ type: "text" as const, text: `Message delivered to ${params.targetSessionId} (status: ${result.targetStatus})` }],
+        details: result,
+      };
+    },
+  });
+
+	pi.registerTool({
+		name: "session_delegate_status",
+		label: "Session Delegate Status",
+		description: "Check the status of a delegated task session.",
+		parameters: DelegateStatusParams,
+		async execute(toolCallId, params, _signal, _onUpdate, _ctx) {
+			const task = store?.get(params.sessionId);
+			if (task) {
+				const status = task.status === "completed" ? "DONE" : task.status.toUpperCase();
+				return {
+					content: [{ type: "text" as const, text: `Task "${task.title}" (${params.sessionId}): ${status}` }],
+					details: { task },
+				};
+			}
+			const remote = await serverProxy.delegate_status(params.sessionId);
+			return {
+				content: [{ type: "text" as const, text: `Session ${params.sessionId} status: ${remote.status}` }],
+				details: { task: null },
+			};
+		},
+	});
+
+	pi.registerTool({
+		name: "session_delegate_stop",
+		label: "Session Delegate Stop",
+		description: "Stop a delegated task session.",
+		parameters: DelegateStopParams,
+		async execute(toolCallId, params, _signal, _onUpdate, _ctx) {
+			const ok = await serverProxy.delegate_stop(params.sessionId);
+			if (ok && store) {
+				store.update(params.sessionId, { status: "stopped" });
+			}
+			return {
+				content: [{ type: "text" as const, text: ok ? `Session ${params.sessionId} stopped.` : `Session ${params.sessionId} not found or already stopped.` }],
+				details: { ok },
+			};
+		},
+	});
+
+	pi.registerTool({
+		name: "session_delegate_fork",
+		label: "Session Delegate Fork",
+		description: [
+			"Fork an existing session and delegate a new task to the forked session.",
+			"The forked session starts with a copy of the source session's conversation history.",
+			"The original session continues running unchanged.",
+		].join(" "),
+		parameters: DelegateForkParams,
+		async execute(toolCallId, params, _signal, _onUpdate, ctx) {
+			const sid = currentSessionId || ctx.sessionManager.getSessionId();
+			const result = await serverProxy.delegate_fork(params.sessionId, params.task, params.title);
+			if (store) {
+				store.add({
+					sessionId: result.sessionId,
+					title: params.title || params.task.slice(0, 60),
+					task: params.task,
+					projectPath: ctx.cwd,
+					dispatchedAt: Date.now(),
+					status: "idle",
+				});
+			}
+			return {
+				content: [{ type: "text" as const, text: `Forked session ${params.sessionId} → ${result.sessionId} (status: ${result.status}). Task: ${params.task}` }],
+				details: { ...result, forkedFrom: params.sessionId, dispatchedBy: sid },
+			};
+		},
+	});
+
+	client.on("message_received", (data: unknown) => {
+		const d = data as { fromSessionId: string; message: string };
+		pi.sendUserMessage(
+			`[Coordinator] Message from session ${d.fromSessionId}:\n${d.message}`,
+			{ deliverAs: "followUp" },
+		);
+	});
+}

package/dist/extensions/coordinator/types.d.ts

@@ -0,0 +1,100 @@
+import type { ChannelContract } from "@dyyz1993/pi-coding-agent";
+export declare const COORDINATOR_CHANNEL_NAME = "coordinator";
+export type SessionStatus = "idle" | "streaming" | "stopped" | "completed";
+export interface DelegatedTask {
+    sessionId: string;
+    title: string;
+    task: string;
+    projectPath: string;
+    dispatchedAt: number;
+    status: SessionStatus;
+    completedAt?: number;
+    result?: string;
+}
+export interface DelegateCreateResult {
+    sessionId: string;
+    status: "started" | "already_running";
+}
+export interface DelegateSendResult {
+    delivered: boolean;
+    targetStatus: "active" | "started" | "not_found";
+}
+export interface DelegateListResult {
+    tasks: DelegatedTask[];
+}
+export interface DelegateStatusExt {
+    task: DelegatedTask | null;
+    isCompacting?: boolean;
+    contextUsage?: {
+        tokens: number | null;
+        contextWindow: number;
+        percent: number | null;
+    };
+}
+export interface CoordinatorChannelContract extends ChannelContract {
+    methods: {
+        session_delegate: {
+            params: {
+                task: string;
+                title?: string;
+            };
+            return: DelegateCreateResult;
+        };
+        session_delegate_send: {
+            params: {
+                targetSessionId: string;
+                message: string;
+            };
+            return: DelegateSendResult;
+        };
+        session_delegate_status: {
+            params: {
+                sessionId: string;
+            };
+            return: DelegateStatusExt;
+        };
+        session_delegate_list: {
+            params: Record<string, never>;
+            return: DelegateListResult;
+        };
+        session_delegate_stop: {
+            params: {
+                sessionId: string;
+            };
+            return: {
+                ok: boolean;
+            };
+        };
+        session_delegate_fork: {
+            params: {
+                sessionId: string;
+                task: string;
+                title?: string;
+            };
+            return: DelegateCreateResult;
+        };
+    };
+    events: {
+        message_received: {
+            fromSessionId: string;
+            message: string;
+        };
+        task_started: {
+            sessionId: string;
+            title: string;
+            task: string;
+        };
+        task_stopped: {
+            sessionId: string;
+        };
+        task_completed: {
+            sessionId: string;
+            result?: string;
+        };
+        task_error: {
+            sessionId: string;
+            error: string;
+        };
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/extensions/coordinator/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":"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","sourcesContent":["import type { ChannelContract } from \"@dyyz1993/pi-coding-agent\";\n\nexport const COORDINATOR_CHANNEL_NAME = \"coordinator\";\n\nexport type SessionStatus = \"idle\" | \"streaming\" | \"stopped\" | \"completed\";\n\nexport interface DelegatedTask {\n\tsessionId: string;\n\ttitle: string;\n\ttask: string;\n\tprojectPath: string;\n\tdispatchedAt: number;\n\tstatus: SessionStatus;\n\tcompletedAt?: number;\n\tresult?: string;\n}\n\nexport interface DelegateCreateResult {\n\tsessionId: string;\n\tstatus: \"started\" | \"already_running\";\n}\n\nexport interface DelegateSendResult {\n\tdelivered: boolean;\n\ttargetStatus: \"active\" | \"started\" | \"not_found\";\n}\n\nexport interface DelegateListResult {\n\ttasks: DelegatedTask[];\n}\n\nexport interface DelegateStatusExt {\n\ttask: DelegatedTask | null;\n\tisCompacting?: boolean;\n\tcontextUsage?: { tokens: number | null; contextWindow: number; percent: number | null };\n}\n\nexport interface CoordinatorChannelContract extends ChannelContract {\n\tmethods: {\n\t\tsession_delegate: {\n\t\t\tparams: { task: string; title?: string };\n\t\t\treturn: DelegateCreateResult;\n\t\t};\n\t\tsession_delegate_send: {\n\t\t\tparams: { targetSessionId: string; message: string };\n\t\t\treturn: DelegateSendResult;\n\t\t};\n\t\tsession_delegate_status: {\n\t\t\tparams: { sessionId: string };\n\t\t\treturn: DelegateStatusExt;\n\t\t};\n\t\tsession_delegate_list: {\n\t\t\tparams: Record<string, never>;\n\t\t\treturn: DelegateListResult;\n\t\t};\n\t\tsession_delegate_stop: {\n\t\t\tparams: { sessionId: string };\n\t\t\treturn: { ok: boolean };\n\t\t};\n\t\tsession_delegate_fork: {\n\t\t\tparams: { sessionId: string; task: string; title?: string };\n\t\t\treturn: DelegateCreateResult;\n\t\t};\n\t};\n\tevents: {\n\t\tmessage_received: { fromSessionId: string; message: string };\n\t\ttask_started: { sessionId: string; title: string; task: string };\n\t\ttask_stopped: { sessionId: string };\n\t\ttask_completed: { sessionId: string; result?: string };\n\t\ttask_error: { sessionId: string; error: string };\n\t};\n}\n"]}

package/dist/extensions/coordinator/types.js

@@ -0,0 +1,2 @@
+export const COORDINATOR_CHANNEL_NAME = "coordinator";
+//# sourceMappingURL=types.js.map

package/dist/extensions/coordinator/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,wBAAwB,GAAG,aAAa,CAAC","sourcesContent":["import type { ChannelContract } from \"@dyyz1993/pi-coding-agent\";\n\nexport const COORDINATOR_CHANNEL_NAME = \"coordinator\";\n\nexport type SessionStatus = \"idle\" | \"streaming\" | \"stopped\" | \"completed\";\n\nexport interface DelegatedTask {\n\tsessionId: string;\n\ttitle: string;\n\ttask: string;\n\tprojectPath: string;\n\tdispatchedAt: number;\n\tstatus: SessionStatus;\n\tcompletedAt?: number;\n\tresult?: string;\n}\n\nexport interface DelegateCreateResult {\n\tsessionId: string;\n\tstatus: \"started\" | \"already_running\";\n}\n\nexport interface DelegateSendResult {\n\tdelivered: boolean;\n\ttargetStatus: \"active\" | \"started\" | \"not_found\";\n}\n\nexport interface DelegateListResult {\n\ttasks: DelegatedTask[];\n}\n\nexport interface DelegateStatusExt {\n\ttask: DelegatedTask | null;\n\tisCompacting?: boolean;\n\tcontextUsage?: { tokens: number | null; contextWindow: number; percent: number | null };\n}\n\nexport interface CoordinatorChannelContract extends ChannelContract {\n\tmethods: {\n\t\tsession_delegate: {\n\t\t\tparams: { task: string; title?: string };\n\t\t\treturn: DelegateCreateResult;\n\t\t};\n\t\tsession_delegate_send: {\n\t\t\tparams: { targetSessionId: string; message: string };\n\t\t\treturn: DelegateSendResult;\n\t\t};\n\t\tsession_delegate_status: {\n\t\t\tparams: { sessionId: string };\n\t\t\treturn: DelegateStatusExt;\n\t\t};\n\t\tsession_delegate_list: {\n\t\t\tparams: Record<string, never>;\n\t\t\treturn: DelegateListResult;\n\t\t};\n\t\tsession_delegate_stop: {\n\t\t\tparams: { sessionId: string };\n\t\t\treturn: { ok: boolean };\n\t\t};\n\t\tsession_delegate_fork: {\n\t\t\tparams: { sessionId: string; task: string; title?: string };\n\t\t\treturn: DelegateCreateResult;\n\t\t};\n\t};\n\tevents: {\n\t\tmessage_received: { fromSessionId: string; message: string };\n\t\ttask_started: { sessionId: string; title: string; task: string };\n\t\ttask_stopped: { sessionId: string };\n\t\ttask_completed: { sessionId: string; result?: string };\n\t\ttask_error: { sessionId: string; error: string };\n\t};\n}\n"]}

package/dist/extensions/coordinator/types.ts

@@ -0,0 +1,72 @@
+import type { ChannelContract } from "@dyyz1993/pi-coding-agent";
+
+export const COORDINATOR_CHANNEL_NAME = "coordinator";
+
+export type SessionStatus = "idle" | "streaming" | "stopped" | "completed";
+
+export interface DelegatedTask {
+	sessionId: string;
+	title: string;
+	task: string;
+	projectPath: string;
+	dispatchedAt: number;
+	status: SessionStatus;
+	completedAt?: number;
+	result?: string;
+}
+
+export interface DelegateCreateResult {
+	sessionId: string;
+	status: "started" | "already_running";
+}
+
+export interface DelegateSendResult {
+	delivered: boolean;
+	targetStatus: "active" | "started" | "not_found";
+}
+
+export interface DelegateListResult {
+	tasks: DelegatedTask[];
+}
+
+export interface DelegateStatusExt {
+	task: DelegatedTask | null;
+	isCompacting?: boolean;
+	contextUsage?: { tokens: number | null; contextWindow: number; percent: number | null };
+}
+
+export interface CoordinatorChannelContract extends ChannelContract {
+	methods: {
+		session_delegate: {
+			params: { task: string; title?: string };
+			return: DelegateCreateResult;
+		};
+		session_delegate_send: {
+			params: { targetSessionId: string; message: string };
+			return: DelegateSendResult;
+		};
+		session_delegate_status: {
+			params: { sessionId: string };
+			return: DelegateStatusExt;
+		};
+		session_delegate_list: {
+			params: Record<string, never>;
+			return: DelegateListResult;
+		};
+		session_delegate_stop: {
+			params: { sessionId: string };
+			return: { ok: boolean };
+		};
+		session_delegate_fork: {
+			params: { sessionId: string; task: string; title?: string };
+			return: DelegateCreateResult;
+		};
+	};
+	events: {
+		message_received: { fromSessionId: string; message: string };
+		task_started: { sessionId: string; title: string; task: string };
+		task_stopped: { sessionId: string };
+		task_completed: { sessionId: string; result?: string };
+		task_error: { sessionId: string; error: string };
+	};
+}