pi-orchestrator-config 4.1.5

package/extensions/coms/coms-shared.ts

@@ -0,0 +1,510 @@
+/**
+ * coms-shared.ts — Shared utilities for coms and coms-net wrappers.
+ *
+ * Handles reload resilience: when coms is active and the user runs /reload,
+ * session_shutdown fires (upstream cleans up the old socket/connection),
+ * then session_start fires with reason="reload". We detect this and
+ * auto-reactivate with the same flags.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import * as fs from "node:fs";
+import * as net from "node:net";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+import * as os from "node:os";
+
+/**
+ * Tokenize a command string respecting double and single quotes.
+ * Quoted values are returned as single tokens with quotes stripped.
+ */
+export function tokenizeArgs(input: string): string[] {
+    const tokens: string[] = [];
+    let current = '';
+    let inQuote: string | null = null;
+    for (const ch of input) {
+        if (inQuote) {
+            if (ch === inQuote) {
+                inQuote = null;
+            } else {
+                current += ch;
+            }
+        } else if (ch === '"' || ch === "'") {
+            inQuote = ch;
+        } else if (/\s/.test(ch)) {
+            if (current) { tokens.push(current); current = ''; }
+        } else {
+            current += ch;
+        }
+    }
+    if (current) tokens.push(current);
+    return tokens;
+}
+
+/**
+ * Parse --key value pairs from command arguments into a Map.
+ * Boolean flags (like --explicit) are set to true without consuming the next token.
+ */
+export function parseFlags(parts: string[], values: Map<string, any>): void {
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (!part.startsWith('--')) continue;
+        const key = part.slice(2);
+        if (key === 'explicit') {
+            values.set(key, true);
+            continue;
+        }
+        if (i + 1 < parts.length) {
+            const val = parts[i + 1];
+            if (val && !val.startsWith('--')) {
+                values.set(key, val);
+                i++;
+            }
+        }
+    }
+}
+
+export interface DeferredUpstream {
+    /** Captured session_start handler from upstream */
+    capturedSessionStart: ((event: any, ctx: any) => Promise<void>) | null;
+    /** Captured session_shutdown handler from upstream */
+    capturedSessionShutdown: (() => Promise<void>) | null;
+    /** Flag values for upstream's getFlag calls */
+    flagValues: Map<string, any>;
+    /** Whether the upstream extension is active */
+    active: boolean;
+    /** Extra persisted state (e.g., serverStartedByUs for coms-net) */
+    extra?: Record<string, any>;
+}
+
+/**
+ * Create a Proxy around the pi API that defers upstream extension activation.
+ * On reload, session_shutdown passes through (upstream cleans up), then
+ * session_start auto-reactivates if the persist key exists.
+ */
+export function createDeferredProxy(
+    pi: ExtensionAPI,
+    state: DeferredUpstream,
+    inactiveMessage: string,
+    persistKey: string,
+): ExtensionAPI {
+    return new Proxy(pi, {
+        get(target: any, prop: string | symbol) {
+            if (typeof prop === 'symbol') {
+                const val = target[prop];
+                return typeof val === 'function' ? val.bind(target) : val;
+            }
+
+            switch (prop) {
+                case 'registerFlag':
+                    return () => {};
+                case 'getFlag':
+                    return (name: string) => state.flagValues.get(name);
+                case 'registerCommand':
+                    return () => {};
+                case 'registerTool':
+                    return (tool: any) => {
+                        // Inject anti-loop warning into coms_send description
+                        // (upstream coms_net_send has this but coms_send doesn't)
+                        if (tool.name === "coms_send" && tool.description && !tool.description.includes("DO NOT")) {
+                            tool.description +=
+                                "\n\n\u26a0\ufe0f  DO NOT call this tool to REPLY to an inbound message. " +
+                                "When you receive a `[from <peer>] \u2026` follow-up, just write your answer as your normal assistant message \u2014 " +
+                                "the coms extension automatically captures the final assistant text at the end of your turn and " +
+                                "submits it back to the original caller. Calling coms_send in response creates a new outbound message, not a reply.";
+                        }
+                        const origExecute = tool.execute;
+                        tool.execute = async (callId: string, params: any, signal?: AbortSignal, ...rest: any[]) => {
+                            if (!state.active) {
+                                return {
+                                    content: [{ type: "text" as const, text: inactiveMessage }],
+                                };
+                            }
+                            // For *_await tools: wrap with abort signal support
+                            // so ESC can interrupt the blocking wait
+                            if (tool.name?.endsWith("_await") && signal) {
+                                return Promise.race([
+                                    origExecute(callId, params, signal, ...rest),
+                                    new Promise<any>((_, reject) => {
+                                        if (signal.aborted) reject(new Error("aborted"));
+                                        signal.addEventListener("abort", () => reject(new Error("aborted")), { once: true });
+                                    }),
+                                ]).catch((err) => ({
+                                    content: [{ type: "text" as const, text: `⚠️ ${tool.name} interrupted: ${err.message}` }],
+                                }));
+                            }
+                            return origExecute(callId, params, signal, ...rest);
+                        };
+                        return target.registerTool(tool);
+                    };
+                case 'on':
+                    return (event: string, handler: any) => {
+                        if (event === 'session_start') {
+                            state.capturedSessionStart = handler;
+                            // Register with real pi to auto-reactivate on reload
+                            return target.on(event, async (evt: any, ctx: any) => {
+                                if (evt?.reason !== "reload") return;
+                                // Check if coms was active before reload
+                                let wasActive = false;
+                                let savedFlags: Record<string, any> = {};
+                                let savedExtra: Record<string, any> = {};
+                                for (const entry of ctx.sessionManager.getEntries()) {
+                                    if (entry.type === "custom" && entry.customType === persistKey) {
+                                        wasActive = entry.data?.active === true;
+                                        savedFlags = entry.data?.flags || {};
+                                        savedExtra = entry.data?.extra || {};
+                                    }
+                                }
+                                if (wasActive) {
+                                    state.flagValues = new Map(Object.entries(savedFlags));
+                                    state.extra = savedExtra;
+                                    try {
+                                        await handler(evt, ctx);
+                                        state.active = true;
+                                    } catch (err) {
+                                        console.error(`[coms] reload reactivation failed:`, err);
+                                    }
+                                }
+                            });
+                        }
+                        if (event === 'session_shutdown') {
+                            state.capturedSessionShutdown = handler;
+                            // Pass through — upstream needs to clean up socket/connection
+                            return target.on(event, handler);
+                        }
+                        return target.on(event, handler);
+                    };
+                default: {
+                    const val = target[prop];
+                    if (typeof val === 'function') {
+                        return val.bind(target);
+                    }
+                    return val;
+                }
+            }
+        }
+    }) as ExtensionAPI;
+}
+
+/**
+ * Persist coms activation state so it survives reload.
+ */
+export function persistState(pi: ExtensionAPI, persistKey: string, state: DeferredUpstream): void {
+    try {
+        const flags: Record<string, any> = {};
+        for (const [k, v] of state.flagValues) flags[k] = v;
+        pi.appendEntry(persistKey, { active: state.active, flags, extra: state.extra || {} });
+    } catch (e: any) { console.debug("[coms-shared] persist state failed:", e?.message || e); }
+}
+
+/**
+ * Prune stale coms registry entries on startup — removes entries with dead PIDs.
+ * Call from session_start in both coms.ts and coms-net.ts.
+ */
+let _pruned = false;
+/**
+ * Prune stale coms registry entries — non-blocking.
+ * Runs once per session (coms + coms-net both call this).
+ */
+export function pruneStaleRegistry(): void {
+    if (_pruned) return;
+    _pruned = true;
+    // Run async to avoid blocking session_start
+    setImmediate(() => {
+        try {
+            const comsDir = process.env.PI_COMS_DIR || path.join(os.homedir(), ".pi", "coms");
+            const projectsDir = path.join(comsDir, "projects");
+            if (!fs.existsSync(projectsDir)) return;
+            let dirs: string[];
+            try { dirs = fs.readdirSync(projectsDir); } catch { return; }
+            for (const proj of dirs) {
+                try {
+                    const projDir = path.join(projectsDir, proj);
+                    if (!fs.lstatSync(projDir).isDirectory()) continue;
+                    const agentsDir = path.join(projDir, "agents");
+                    if (!fs.existsSync(agentsDir)) continue;
+                    for (const file of fs.readdirSync(agentsDir)) {
+                        if (!file.endsWith(".json")) continue;
+                        const fp = path.join(agentsDir, file);
+                        try {
+                            const data = JSON.parse(fs.readFileSync(fp, "utf-8"));
+                            if (typeof data?.pid !== "number") {
+                                try { fs.unlinkSync(fp); } catch {}
+                                continue;
+                            }
+                            // Check socket endpoint — reliable in containers (pid reuse)
+                            const endpoint = data?.endpoint;
+                            if (typeof endpoint !== "string" || !endpoint) {
+                                // No/invalid endpoint — old format entry, remove
+                                try { fs.unlinkSync(fp); } catch {}
+                                continue;
+                            }
+                            if (!fs.existsSync(endpoint)) {
+                                // Socket file gone — definitely dead
+                                try { fs.unlinkSync(fp); } catch {}
+                                continue;
+                            }
+                            // Socket exists — try connect to verify.
+                            // Prefer the ping endpoint (.ping) which runs on a separate
+                            // thread and is immune to main-thread event-loop blocks.
+                            // Probe liveness via .ping endpoint (immune to main-thread blocks).
+                            const pingEndpoint = `${endpoint}.ping`;
+                            const sock = net.createConnection(pingEndpoint);
+                            sock.setTimeout(500);
+                            sock.on("connect", () => sock.destroy()); // alive
+                            sock.on("error", (err: any) => {
+                                sock.destroy();
+                                // Only prune registry on definitive dead signals.
+                                // Never delete socket files — that's destructive and
+                                // irreversible, killing live peers whose ping worker
+                                // may have crashed while the main server is still alive.
+                                if (err?.code === "ECONNREFUSED" || err?.code === "ENOENT") {
+                                    try { fs.unlinkSync(fp); } catch {}
+                                }
+                            });
+                            sock.on("timeout", () => {
+                                sock.destroy();
+                                // Timeout means peer may be busy — only remove registry
+                                // entry, NOT the socket file. The peer's keepalive can
+                                // self-heal the registry, but a deleted socket file is
+                                // permanent and kills the peer's connectivity.
+                                try { fs.unlinkSync(fp); } catch {}
+                                // Do NOT unlink endpoint or endpoint.ping on timeout
+                            });
+                        } catch (e: any) {
+                            if (e?.code === "ESRCH" || e instanceof SyntaxError) {
+                                try { fs.unlinkSync(fp); } catch {}
+                            }
+                        }
+                    }
+                } catch { /* skip unreadable project directory */ }
+            }
+            // Cleanup orphan sockets (no matching registry entry)
+            const socketsDir = path.join(comsDir, "sockets");
+            if (fs.existsSync(socketsDir)) {
+                try {
+                    const allEndpoints = new Set<string>();
+                    // Collect all endpoints from remaining registry entries
+                    for (const p of dirs) {
+                        try {
+                            const pd = path.join(projectsDir, p);
+                            if (!fs.lstatSync(pd).isDirectory()) continue;
+                            const ad = path.join(pd, "agents");
+                            if (!fs.existsSync(ad)) continue;
+                            for (const f of fs.readdirSync(ad)) {
+                                if (!f.endsWith(".json")) continue;
+                                try {
+                                    const d = JSON.parse(fs.readFileSync(path.join(ad, f), "utf-8"));
+                                    if (d?.endpoint) allEndpoints.add(d.endpoint);
+                                } catch {}
+                            }
+                        } catch {}
+                    }
+                    // Remove sockets with no registry entry
+                    for (const sf of fs.readdirSync(socketsDir)) {
+                        if (!sf.endsWith(".sock") && !sf.endsWith(".sock.ping")) continue;
+                        const sp = path.join(socketsDir, sf);
+                        // For .ping files, check if the parent .sock is in the endpoint set
+                        const parentEndpoint = sf.endsWith(".sock.ping") ? sp.slice(0, -5) : sp;
+                        if (!allEndpoints.has(parentEndpoint)) {
+                            try { fs.unlinkSync(sp); } catch {}
+                        }
+                    }
+                } catch {}
+            }
+        } catch (e: any) { console.debug("[coms] async prune failed:", e?.message?.slice(0, 100)); }
+    });
+}
+
+// ━━ Shared helpers (used by both coms-p2p.ts and coms-net.ts) ━━━━━━━━━━━━━━
+
+export const FALLBACK_PALETTE = [
+	"#72F1B8", "#36F9F6", "#FF7EDB", "#FEDE5D",
+	"#C792EA", "#FF8B39", "#4D9DE0", "#FFAA8B",
+];
+
+const CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"; // pragma: allowlist secret
+
+export function ulid(): string {
+	const time = Date.now();
+	const rand = crypto.randomBytes(10);
+	let timeStr = "";
+	let t = time;
+	for (let i = 9; i >= 0; i--) {
+		timeStr = CROCKFORD[t % 32] + timeStr;
+		t = Math.floor(t / 32);
+	}
+	let randStr = "";
+	let bits = 0;
+	let value = 0;
+	for (const byte of rand) {
+		value = (value << 8) | byte;
+		bits += 8;
+		while (bits >= 5) {
+			bits -= 5;
+			randStr += CROCKFORD[(value >> bits) & 31];
+		}
+	}
+	return (timeStr + randStr).slice(0, 26);
+}
+
+export function hexFg(hex: string, s: string): string {
+	const r = parseInt(hex.slice(1, 3), 16);
+	const g = parseInt(hex.slice(3, 5), 16);
+	const b = parseInt(hex.slice(5, 7), 16);
+	return `\x1b[38;2;${r};${g};${b}m${s}\x1b[39m`;
+}
+
+export function isValidHex(hex: string): boolean {
+	return /^#[0-9a-fA-F]{6}$/.test(hex);
+}
+
+export function fallbackColor(sessionId: string): string {
+	const h = crypto.createHash("sha256").update(sessionId).digest("hex").slice(0, 8);
+	return FALLBACK_PALETTE[Number(BigInt("0x" + h)) % FALLBACK_PALETTE.length];
+}
+
+export function comsParseYamlFrontmatter(raw: string): { name?: string; description?: string; color?: string; body: string } {
+	const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+	if (!match) return { body: raw };
+	const frontmatter: Record<string, string> = {};
+	for (const line of match[1].split("\n")) {
+		const idx = line.indexOf(":");
+		if (idx > 0) {
+			const key = line.slice(0, idx).trim();
+			let val = line.slice(idx + 1).trim();
+			if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+				val = val.slice(1, -1);
+			}
+			frontmatter[key] = val;
+		}
+	}
+	return {
+		name: frontmatter.name,
+		description: frontmatter.description,
+		color: frontmatter.color,
+		body: match[2],
+	};
+}
+
+export function nowIso(): string {
+	return new Date().toISOString();
+}
+
+export function abbreviateModel(model: string): string {
+	let m = model || "";
+	if (m.startsWith("claude-")) m = m.slice("claude-".length);
+	if (m.length > 14) m = m.slice(0, 14);
+	return m;
+}
+
+export function findSystemPromptPath(argv: string[]): string | null {
+	const scan = (flag: string): string | null => {
+		for (let i = 0; i < argv.length; i++) {
+			if (argv[i] === flag && i + 1 < argv.length) {
+				const candidate = argv[i + 1];
+				if (candidate.endsWith(".md")) {
+					try {
+						if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+							return candidate;
+						}
+					} catch { /* fall through */ }
+				}
+			}
+		}
+		return null;
+	};
+	return scan("--system-prompt") ?? scan("--append-system-prompt");
+}
+
+export function readFrontmatterFromArgv(argv: string[]): { name?: string; description?: string; color?: string } {
+	const p = findSystemPromptPath(argv);
+	if (!p) return {};
+	try {
+		const raw = fs.readFileSync(p, "utf-8");
+		const { name, description, color } = comsParseYamlFrontmatter(raw);
+		return { name, description, color };
+	} catch {
+		return {};
+	}
+}
+
+export function readTaskSummary(cwd: string, sessionId?: string): { total: number; completed: number; in_progress: number } | null {
+	try {
+		const tasksDir = path.join(cwd, ".pi", "tasks");
+		if (!fs.existsSync(tasksDir)) return null;
+		const candidates = sessionId
+			? [`tasks-${sessionId}.json`, "tasks.json"]
+			: ["tasks.json"];
+		for (const candidate of candidates) {
+			const filePath = path.join(tasksDir, candidate);
+			if (!fs.existsSync(filePath)) continue;
+			try {
+				const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+				if (!Array.isArray(data.tasks) || data.tasks.length === 0) continue;
+				let total = 0, completed = 0, in_progress = 0;
+				for (const t of data.tasks) {
+					total++;
+					if (t.status === "completed") completed++;
+					else if (t.status === "in_progress") in_progress++;
+				}
+				return { total, completed, in_progress };
+			} catch { /* skip corrupt file */ }
+		}
+		return null;
+	} catch { return null; }
+}
+
+export function buildInboundContent(
+	header: string,
+	prompt: string,
+	tasks?: Array<{ subject: string; description: string }> | null,
+): string {
+	let content = `${header}\n\n${prompt}`;
+	if (tasks && tasks.length > 0) {
+		content += `\n\n## Assigned Tasks\n\nThe sender has assigned you these tasks. Use TaskCreate to add them to your task list, then work through them:\n\n`;
+		for (const task of tasks) {
+			content += `- **${task.subject}**: ${task.description}\n`;
+		}
+	}
+	return content;
+}
+
+export interface TasksSummary {
+	total: number;
+	completed: number;
+	in_progress: number;
+}
+
+/** Format the auto-delivered coms response text, including queued message IDs when > 0. */
+export function formatComsResponseText(targetName: string, response: any, error: string | null, queuedMsgIds: string[]): string {
+	const ids = queuedMsgIds.length <= 5 ? queuedMsgIds.join(", ") : `${queuedMsgIds.slice(0, 5).join(", ")} and ${queuedMsgIds.length - 5} more`;
+	const queueNote = queuedMsgIds.length > 0 ? ` (${queuedMsgIds.length} more queued: ${ids})` : "";
+	if (error) return `[coms response from ${targetName}${queueNote}] Error: ${error}`;
+	return typeof response === "string"
+		? `[coms response from ${targetName}${queueNote}] ${response}`
+		: `[coms response from ${targetName}${queueNote}] ${JSON.stringify(response, null, 2)}`;
+}
+
+/** Return " 📨N" suffix string for queue depth, or "" when zero/absent. */
+export function formatQueueStr(queueDepth: number | undefined | null): string {
+	return typeof queueDepth === "number" && queueDepth > 0 ? ` 📨${queueDepth}` : "";
+}
+
+/** Return theme-colored queue indicator for the coms widget list row. */
+export function renderQueuePart(queueDepth: number, theme: any): string {
+	return queueDepth > 0 ? theme.fg("dim", " ") + theme.fg("warning", `📨${queueDepth}`) : "";
+}
+
+export function renderTasksPart(tasks: TasksSummary | null | undefined, theme: any): string {
+	if (!tasks || tasks.total === 0) return "";
+	// Clamp to prevent negative/misleading values from corrupt data
+	const completed = Math.max(0, Math.min(tasks.completed, tasks.total));
+	const in_progress = Math.max(0, Math.min(tasks.in_progress, tasks.total - completed));
+	const pending = Math.max(0, tasks.total - completed - in_progress);
+	const parts: string[] = [];
+	if (completed > 0) parts.push(theme.fg("success", `${completed}✔`));
+	if (in_progress > 0) parts.push(theme.fg("accent", `${in_progress}◼`));
+	if (pending > 0) parts.push(theme.fg("dim", `${pending}◻`));
+	return theme.fg("dim", " ") + parts.join(theme.fg("dim", " "));
+}

package/extensions/coms/coms-wrapper.ts

@@ -0,0 +1,138 @@
+/**
+ * coms-wrapper.ts — On-demand P2P agent communication wrapper
+ *
+ * Wraps the P2P coms extension (coms-p2p.ts) to support
+ * activation via /coms command instead of auto-start on session_start.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+import { fuzzyFilter } from "@earendil-works/pi-tui";
+import { parseFlags, tokenizeArgs, createDeferredProxy, persistState, pruneStaleRegistry, type DeferredUpstream } from "./coms-shared.js";
+import upstreamComsInit from "./coms-p2p.js";
+
+function fuzzy(items: AutocompleteItem[], query: string): AutocompleteItem[] | null {
+    if (!query.trim()) return items.length > 0 ? items : null;
+    const result = fuzzyFilter(items, query, i => `${i.label} ${i.description || ""}`);
+    return result.length > 0 ? result : null;
+}
+
+export function registerComs(pi: ExtensionAPI) {
+    const state: DeferredUpstream = {
+        capturedSessionStart: null,
+        capturedSessionShutdown: null,
+        flagValues: new Map(),
+        active: false,
+    };
+
+    const PERSIST_KEY = "coms-state";
+
+    const proxyPi = createDeferredProxy(
+        pi, state, "⚠️ coms not active. Run `/coms start` first.", PERSIST_KEY,
+    );
+
+    upstreamComsInit(proxyPi as any);
+
+    // Prune stale registry entries on session start (cleans up after crashes)
+    // Also reset coms state on fresh starts (non-reload) to clear phantom peers
+    pi.on("session_start", (evt: any) => {
+        try { pruneStaleRegistry(); } catch (e: any) { console.debug("[coms] stale cleanup:", e?.message?.slice(0, 100)); }
+        if (evt?.reason !== "reload") {
+            state.active = false;
+            persistState(pi, PERSIST_KEY, state);
+        }
+    });
+
+    pi.registerCommand("coms", {
+        description: "P2P agent communication: /coms start | stop | status",
+        getArgumentCompletions: (prefix: string) => {
+            // Parse: split on whitespace, trailing space means "next token position"
+            const tokens = prefix.trim().split(/\s+/).filter(Boolean);
+            const atNextToken = prefix.endsWith(" ") || tokens.length === 0;
+            const lastPart = atNextToken ? "" : tokens[tokens.length - 1];
+            const completed = atNextToken ? tokens : tokens.slice(0, -1);
+            const base = atNextToken ? prefix : prefix.slice(0, prefix.length - lastPart.length);
+            const mk = (items: {v: string; l: string; d: string}[]) =>
+                fuzzy(items.map(i => ({ value: base + i.v, label: i.l, description: i.d })), lastPart);
+
+            if (completed.length === 0) {
+                return mk([
+                    { v: "start", l: "start", d: "Start P2P agent communication" },
+                    { v: "stop", l: "stop", d: "Stop coms" },
+                    { v: "status", l: "status", d: "Show coms status" },
+                ]);
+            }
+            if (completed[0] === "start" && (lastPart.startsWith("-") || lastPart === "")) {
+                const used = new Set(completed.filter(p => p.startsWith("--")));
+                return mk([
+                    { v: "--cname ", l: "--cname", d: "Agent name" },
+                    { v: "--purpose ", l: "--purpose", d: "Agent purpose" },
+                    { v: "--project ", l: "--project", d: "Project namespace" },
+                    { v: "--color ", l: "--color", d: "Hex color #RRGGBB" },
+                    { v: "--explicit", l: "--explicit", d: "Hide from auto-discovery" },
+                ].filter(f => !used.has(f.v.trim())));
+            }
+            return null;
+        },
+        handler: async (args: string, ctx: any) => {
+            const trimmed = (args || "").trim();
+            const parts = tokenizeArgs(trimmed);
+            const subcommand = parts[0] || "status";
+
+            if (subcommand === "start") {
+                if (state.active) {
+                    try { ctx.ui.notify("📡 coms already active", "warning"); } catch {}
+                    return;
+                }
+                state.flagValues = new Map();
+                parseFlags(parts.slice(1), state.flagValues);
+
+                if (state.flagValues.has("name")) {
+                    try { ctx.ui.notify("📡 coms: use --cname instead of --name", "error"); } catch {}
+                    return;
+                }
+
+                // Default project to cwd so sessions in different dirs are isolated
+                if (!state.flagValues.has("project")) {
+                    const cwd = ctx.cwd || "";
+                    const proj = cwd.replace(/^[\\/]/,"").replace(/[\\/]/g, "__");
+                    if (!proj) {
+                        try { ctx.ui.notify("📡 coms: cannot start from /. Run from a project directory.", "error"); } catch {}
+                        return;
+                    }
+                    state.flagValues.set("project", proj);
+                }
+
+                if (!state.capturedSessionStart) {
+                    try { ctx.ui.notify("📡 coms: internal error — no session handler captured", "error"); } catch {}
+                    return;
+                }
+
+                try {
+                    await state.capturedSessionStart({}, ctx);
+                    state.active = true;
+                    persistState(pi, PERSIST_KEY, state);
+                } catch (err: any) {
+                    try { ctx.ui.notify(`📡 coms start failed: ${err?.message ?? String(err)}`, "error"); } catch {}
+                }
+            } else if (subcommand === "stop") {
+                if (!state.active) {
+                    try { ctx.ui.notify("📡 coms not active", "info"); } catch {}
+                    return;
+                }
+                if (state.capturedSessionShutdown) {
+                    try { await state.capturedSessionShutdown(); } catch {}
+                }
+                state.active = false;
+                persistState(pi, PERSIST_KEY, state);
+                try { ctx.ui.notify("📡 coms stopped", "info"); } catch {}
+            } else if (subcommand === "status") {
+                try {
+                    ctx.ui.notify(state.active ? "📡 coms: active (P2P)" : "📡 coms: inactive — run /coms start", "info");
+                } catch {}
+            } else {
+                try { ctx.ui.notify(`📡 coms: unknown subcommand "${subcommand}". Use: start | stop | status`, "warning"); } catch {}
+            }
+        },
+    });
+}

package/extensions/coms/index.ts

@@ -0,0 +1,20 @@
+/**
+ * Coms Extension for pi
+ *
+ * Inter-agent communication — P2P (coms) and networked (coms-net).
+ * Activated on-demand via /coms and /coms-net slash commands.
+ *
+ * Standalone extension so it can be loaded independently by pi-sidecar
+ * without pulling in the full orchestrator.
+ *
+ * Forked from disler/pi-vs-claude-code — we own the coms implementation files.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerComs } from "./coms-wrapper.js";
+import { registerComsNet } from "./coms-net-wrapper.js";
+
+export default function (pi: ExtensionAPI) {
+    registerComs(pi);
+    registerComsNet(pi);
+}