pi-orchestrator-config 4.2.0 → 4.3.2

package/extensions/coms/coms-shared.ts

@@ -1,5 +1,5 @@
 /**
- * coms-shared.ts — Shared utilities for coms and coms-net wrappers.
+ * coms-shared.ts — Shared utilities for coms wrapper.
  *
  * Handles reload resilience: when coms is active and the user runs /reload,
  * session_shutdown fires (upstream cleans up the old socket/connection),
@@ -13,6 +13,10 @@ import * as net from "node:net";
 import * as path from "node:path";
 import * as crypto from "node:crypto";
 import * as os from "node:os";
+import { setComsActive } from "../shared/coms-active.js";
+import { createLogger } from "../shared/logger.js";
+
+const log = createLogger("coms");
 
 /**
  * Tokenize a command string respecting double and single quotes.
@@ -73,7 +77,7 @@ export interface DeferredUpstream {
     flagValues: Map<string, any>;
     /** Whether the upstream extension is active */
     active: boolean;
-    /** Extra persisted state (e.g., serverStartedByUs for coms-net) */
+    /** Extra persisted state */
     extra?: Record<string, any>;
 }
 
@@ -101,11 +105,33 @@ export function createDeferredProxy(
                 case 'getFlag':
                     return (name: string) => state.flagValues.get(name);
                 case 'registerCommand':
-                    return () => {};
+                    // Upstream /coms is owned by the wrapper — swallow it.
+                    // Pass through utility commands (e.g. /coms-queue) so they
+                    // are always available on the real pi, with an active-gate in the handler.
+                    return (name: string, def: any) => {
+                        if (name === 'coms') return;
+                        const origHandler = def?.handler;
+                        if (typeof origHandler === 'function') {
+                            def.handler = async (args: string, ctx: any) => {
+                                if (!state.active) {
+                                    try {
+                                        ctx.ui.notify(
+                                            name.includes('net')
+                                                ? '📡 coms not active — no queue. Run /coms start first.'
+                                                : '📡 coms not active — no queue. Run /coms start first.',
+                                            'info',
+                                        );
+                                    } catch { /* ignore */ }
+                                    return;
+                                }
+                                return origHandler(args, ctx);
+                            };
+                        }
+                        return target.registerCommand(name, def);
+                    };
                 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. " +
@@ -161,8 +187,14 @@ export function createDeferredProxy(
                                     try {
                                         await handler(evt, ctx);
                                         state.active = true;
+                                        setComsActive(true);
                                     } catch (err) {
-                                        console.error(`[coms] reload reactivation failed:`, err);
+                                        state.active = false;
+                                        setComsActive(false);
+                                        persistState(target, persistKey, state);
+                                        const msg = err instanceof Error ? err.message : String(err);
+                                        const error = err instanceof Error ? err : new Error(msg);
+                                        log.error("reload reactivation failed", msg, error);
                                     }
                                 }
                             });
@@ -199,21 +231,21 @@ export function persistState(pi: ExtensionAPI, persistKey: string, state: Deferr
 
 /**
  * Prune stale coms registry entries on startup — removes entries with dead PIDs.
- * Call from session_start in both coms.ts and coms-net.ts.
+ * Call from session_start in coms.ts.
  */
 let _pruned = false;
 /**
  * Prune stale coms registry entries — non-blocking.
- * Runs once per session (coms + coms-net both call this).
+ * Runs once per session.
  */
-export function pruneStaleRegistry(): void {
+export function pruneStaleRegistry(comsDir?: string): void {
     if (_pruned) return;
     _pruned = true;
+    const resolvedComsDir = comsDir || path.join(os.homedir(), ".pi", "coms");
     // 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");
+            const projectsDir = path.join(resolvedComsDir, "projects");
             if (!fs.existsSync(projectsDir)) return;
             let dirs: string[];
             try { dirs = fs.readdirSync(projectsDir); } catch { return; }
@@ -280,7 +312,7 @@ export function pruneStaleRegistry(): void {
                 } catch { /* skip unreadable project directory */ }
             }
             // Cleanup orphan sockets (no matching registry entry)
-            const socketsDir = path.join(comsDir, "sockets");
+            const socketsDir = path.join(resolvedComsDir, "sockets");
             if (fs.existsSync(socketsDir)) {
                 try {
                     const allEndpoints = new Set<string>();
@@ -316,7 +348,7 @@ export function pruneStaleRegistry(): void {
     });
 }
 
-// ━━ Shared helpers (used by both coms-p2p.ts and coms-net.ts) ━━━━━━━━━━━━━━
+// ━━ Shared helpers (used by coms-p2p.ts) ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 export const FALLBACK_PALETTE = [
 	"#72F1B8", "#36F9F6", "#FF7EDB", "#FEDE5D",
@@ -429,40 +461,48 @@ export function readFrontmatterFromArgv(argv: string[]): { name?: string; descri
 	}
 }
 
-export function readTaskSummary(cwd: string, sessionId?: string): { total: number; completed: number; in_progress: number } | null {
+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 */ }
+		const { listTasks } = require("../pitasks/index.js");
+		const tasks = listTasks();
+		if (!tasks || tasks.length === 0) return null;
+		let total = 0, completed = 0, in_progress = 0;
+		for (const t of tasks) {
+			total++;
+			if (t.status === "completed") completed++;
+			else if (t.status === "in_progress") in_progress++;
 		}
-		return null;
+		return { total, completed, in_progress };
 	} catch { return null; }
 }
 
+/** Build the customType string for coms inbound display (shown as the header by pi).
+ *  Sanitizes all inputs since senderName/senderCwd come from untrusted peers. */
+export function formatComsInboundType(senderName: string, selfName: string, senderCwd: string): string {
+	const safeSender = sanitizeComsName(senderName);
+	const safeSelf = sanitizeComsName(selfName);
+	const safeCwd = senderCwd.replace(/[\x00-\x1f\x7f-\x9f\[\]]/g, "").trim() || "?";
+	return `from ${safeSender} → ${safeSelf} @ ${safeCwd}`;
+}
+
 export function buildInboundContent(
 	header: string,
 	prompt: string,
 	tasks?: Array<{ subject: string; description: string }> | null,
+	senderName?: string,
+	senderCwd?: string,
 ): string {
-	let content = `${header}\n\n${prompt}`;
+	// Sanitize peer-controlled values — strip control chars and limit length
+	const safeName = senderName ? senderName.replace(/[\x00-\x1f\x7f]/g, '').slice(0, 100) : undefined;
+	const safeCwd = senderCwd ? senderCwd.replace(/[\x00-\x1f\x7f]/g, '').slice(0, 200) : undefined;
+	// Machine-readable prefix so the LLM can distinguish coms messages from user input
+	const fromTag = safeName ? `[from ${safeName}${safeCwd ? ` @ ${safeCwd}` : ''}] ` : '';
+	let content = header ? `${fromTag}${header}\n\n${prompt}` : `${fromTag}${prompt}`;
+	if (safeName) {
+		content += `\n\nReply to me via coms_send(target="${safeName}")`;
+	}
 	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`;
+		content += `\n\n## Assigned Tasks\n\nThese tasks have been added to your task list. Work through them in order:\n\n`;
 		for (const task of tasks) {
 			content += `- **${task.subject}**: ${task.description}\n`;
 		}
@@ -477,13 +517,47 @@ export interface TasksSummary {
 }
 
 /** 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 {
+/** Build the customType string for coms response display (shown as the header by pi). */
+export function formatComsResponseType(targetName: string, selfName?: string, queuedMsgIds?: string[]): string {
+	const safeTarget = sanitizeComsName(targetName);
+	const arrow = selfName ? ` → ${sanitizeComsName(selfName)}` : "";
+	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})` : "";
+	return `coms response from ${safeTarget}${arrow}${queueNote}`;
+}
+
+/** Format the coms response content body (without the header — header is in customType). */
+export function formatComsResponseBody(response: any, error: string | null): string {
+	if (error) return `Error: ${error}`;
+	if (typeof response === "string") return response;
+	if (response === undefined || response === null) return "(no response)";
+	return JSON.stringify(response, null, 2) ?? String(response);
+}
+
+/**
+ * Format the full auto-delivered coms response text, including queued message IDs.
+ * @deprecated Use formatComsResponseType + formatComsResponseBody instead for customType display.
+ */
+export function formatComsResponseText(targetName: string, response: any, error: string | null, queuedMsgIds: string[], selfName?: 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}`;
+	const arrow = selfName ? ` → ${selfName}` : "";
+	if (error) return `[coms response from ${targetName}${arrow}${queueNote}] Error: ${error}`;
 	return typeof response === "string"
-		? `[coms response from ${targetName}${queueNote}] ${response}`
-		: `[coms response from ${targetName}${queueNote}] ${JSON.stringify(response, null, 2)}`;
+		? `[coms response from ${targetName}${arrow}${queueNote}] ${response}`
+		: `[coms response from ${targetName}${arrow}${queueNote}] ${JSON.stringify(response, null, 2)}`;
+}
+
+/** Sanitize a coms identity name for safe embedding in header strings.
+ *  Strips all control characters (C0/C1), brackets; replaces whitespace with hyphens. */
+export function sanitizeComsName(name: string): string {
+	return name
+		.replace(/[\x00-\x1f\x7f-\x9f\[\]]/g, "") // strip C0/C1 control chars + brackets
+		.trim()
+		.replace(/\s+/g, "-")                        // whitespace → hyphens (keep as single token)
+		|| "?";
 }
 
 /** Return " 📨N" suffix string for queue depth, or "" when zero/absent. */
@@ -508,3 +582,151 @@ export function renderTasksPart(tasks: TasksSummary | null | undefined, theme: a
 	if (pending > 0) parts.push(theme.fg("dim", `${pending}◻`));
 	return theme.fg("dim", " ") + parts.join(theme.fg("dim", " "));
 }
+
+/** Minimal branch entry shape needed by detectMixedTurn. */
+export interface BranchEntry {
+	type: string;
+	message?: { role: string };
+	customType?: string;
+	details?: { msg_id?: string };
+}
+
+/**
+ * Detect whether a user message appeared in the current turn alongside
+ * a coms inbound injection — indicating the assistant's response may be
+ * directed at the user, not the peer (#731).
+ *
+ * Walks the branch backwards: skips trailing assistant messages, then
+ * checks if a user message appears before reaching the specific coms
+ * inbound injection (identified by customType + msg_id).
+ *
+ * @param branch       The session branch array (oldest → newest).
+ * @param inboundMsgId The msg_id of the currently-processing inbound.
+ * @param inboundCustomType  The customType of the coms inbound injection
+ *                           ("coms-inbound" for p2p).
+ * @returns true if a user message was found between the last assistant
+ *          message and the coms inbound injection (mixed turn).
+ */
+export function detectMixedTurn(
+	branch: ReadonlyArray<BranchEntry>,
+	inboundMsgId: string,
+	inboundCustomType: string,
+): boolean {
+	let passedAssistant = false;
+	for (let i = branch.length - 1; i >= 0; i--) {
+		const entry = branch[i];
+		if (entry.type === "message" && entry.message?.role === "assistant") {
+			passedAssistant = true;
+			continue;
+		}
+		if (!passedAssistant) continue; // still in trailing tool results etc.
+		if (entry.type === "custom_message" && entry.customType === inboundCustomType
+			&& entry.details?.msg_id === inboundMsgId) {
+			// Reached the coms inbound injection for this message — no user message in between.
+			return false;
+		}
+		if (entry.type === "message" && entry.message?.role === "user") {
+			return true;
+		}
+	}
+	return false;
+}
+
+// ── Task store integration (direct import from owned pitasks) ──────────
+
+export interface ComsOrigin {
+	sender_session: string;
+	sender_name: string;
+	sender_endpoint?: string;
+}
+
+/** Max tasks accepted from a single inbound message to prevent abuse. */
+const MAX_INBOUND_TASKS = 20;
+/** Max length for task subject/description fields. */
+const MAX_TASK_FIELD_LEN = 2000;
+
+/**
+ * Auto-create tasks on a peer's task store via owned TaskStore API.
+ * Runs on the SENDER side — uses createTaskForSession with the target's session ID.
+ * TaskStore handles locking, file format, everything.
+ */
+export function createComsInboundTasks(
+	tasks: Array<{ subject: string; description: string }>,
+	origin: ComsOrigin,
+	targetSessionId: string,
+	targetCwd?: string,
+): number {
+	if (!tasks || tasks.length === 0 || !targetSessionId) return 0;
+
+	let createTaskForSession: any;
+	try {
+		createTaskForSession = require("../pitasks/index.js").createTaskForSession;
+	} catch { return 0; }
+	if (!createTaskForSession) return 0;
+
+	let created = 0;
+	const capped = tasks.slice(0, MAX_INBOUND_TASKS);
+	for (const task of capped) {
+		const subject = typeof task.subject === "string" ? task.subject.slice(0, MAX_TASK_FIELD_LEN) : "";
+		const description = typeof task.description === "string" ? task.description.slice(0, MAX_TASK_FIELD_LEN) : "";
+		if (!subject) continue;
+		try {
+			const createdBy = {
+				type: "coms" as const,
+				origin: origin.sender_name,
+				session: origin.sender_session,
+				project: "",
+			};
+			const meta = origin.sender_endpoint ? { sender_endpoint: origin.sender_endpoint } : undefined;
+			createTaskForSession(targetSessionId, subject, description, createdBy, meta, targetCwd);
+			created++;
+		} catch { /* best-effort */ }
+	}
+	return created;
+}
+
+/**
+ * Look up a task by ID and return it if created by a coms peer.
+ */
+export async function getComsOriginTask(
+	taskId: string,
+): Promise<{ subject: string; createdBy: { session: string; name: string; endpoint?: string } } | null> {
+	if (!taskId || taskId === "-1") return null;
+	try {
+		const { getTask } = await import("../pitasks/index.js");
+		const task = getTask(taskId);
+		if (task?.createdBy?.type === "coms") {
+			return {
+				subject: task.subject,
+				createdBy: {
+					session: task.createdBy.session,
+					name: task.createdBy.origin,
+					endpoint: task.metadata?.sender_endpoint,
+				},
+			};
+		}
+	} catch { /* ignore */ }
+	return null;
+}
+
+/**
+ * Get all tasks created by coms peers (for keepalive heartbeat).
+ */
+export async function getComsOriginTasks(): Promise<Array<{ taskId: string; subject: string; status: string; createdBy: { session: string; name: string; endpoint?: string } }>> {
+	try {
+		const { listTasks } = await import("../pitasks/index.js");
+		const tasks = listTasks();
+		return tasks
+			.filter((t: any) => t.createdBy?.type === "coms" && t.status !== "deleted")
+			.map((t: any) => ({
+				taskId: t.id,
+				subject: t.subject,
+				status: t.status,
+				createdBy: {
+					session: t.createdBy.session,
+					name: t.createdBy.origin,
+					endpoint: t.metadata?.sender_endpoint,
+				},
+			}));
+	} catch { return []; }
+}

package/extensions/coms/coms-wrapper.ts

@@ -8,8 +8,15 @@
 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 * as path from "node:path";
+import * as os from "node:os";
 import { parseFlags, tokenizeArgs, createDeferredProxy, persistState, pruneStaleRegistry, type DeferredUpstream } from "./coms-shared.js";
 import upstreamComsInit from "./coms-p2p.js";
+import { getSetting } from "../orchestrator/project-settings.js";
+import { setComsActive } from "../shared/coms-active.js";
+import { createLogger } from "../shared/logger.js";
+
+const log = createLogger("coms");
 
 function fuzzy(items: AutocompleteItem[], query: string): AutocompleteItem[] | null {
     if (!query.trim()) return items.length > 0 ? items : null;
@@ -35,14 +42,94 @@ export function registerComs(pi: ExtensionAPI) {
 
     // 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)); }
+    pi.on("session_start", (evt: any, ctx: any) => {
+        try {
+            const cwd = ctx?.cwd || process.cwd();
+            const comsDir = getSetting(cwd, "coms_dir") || path.join(os.homedir(), ".pi", "coms");
+            pruneStaleRegistry(comsDir);
+        } catch (e: any) {
+            const err = e instanceof Error ? e : new Error(String(e?.message ?? e));
+            log.warn("stale cleanup failed", err.message?.slice(0, 100), err);
+        }
         if (evt?.reason !== "reload") {
             state.active = false;
+            setComsActive(false);
             persistState(pi, PERSIST_KEY, state);
         }
     });
 
+    const comsCmdHandler = 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;
+                setComsActive(true);
+                persistState(pi, PERSIST_KEY, state);
+            } catch (err: any) {
+                setComsActive(false);
+                const msg = err?.message ?? String(err);
+                const error = err instanceof Error ? err : new Error(msg);
+                log.error("/coms start failed", msg, error);
+                try { ctx.ui.notify(`📡 coms start failed: ${msg}`, "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 (err: any) {
+                    const msg = err?.message ?? String(err);
+                    const error = err instanceof Error ? err : new Error(msg);
+                    log.warn("/coms stop: session shutdown threw", msg, error);
+                }
+            }
+            state.active = false;
+            setComsActive(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 {}
+        }
+    };
     pi.registerCommand("coms", {
         description: "P2P agent communication: /coms start | stop | status",
         getArgumentCompletions: (prefix: string) => {
@@ -74,65 +161,16 @@ export function registerComs(pi: ExtensionAPI) {
             }
             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 {}
-            }
-        },
+        handler: comsCmdHandler,
     });
+    // Expose handler to pidash for browser command dispatch
+    try {
+        if ((globalThis as any).__coms_pidash_listener) {
+            try { pi.events.removeListener("pidash:request-commands", (globalThis as any).__coms_pidash_listener); } catch {}
+        }
+        const registerWithPidash = () => pi.events.emit("pidash:register-command", { name: "coms", handler: comsCmdHandler });
+        (globalThis as any).__coms_pidash_listener = registerWithPidash;
+        registerWithPidash();
+        pi.events.on("pidash:request-commands", registerWithPidash);
+    } catch {}
 }

package/extensions/coms/index.ts

@@ -1,8 +1,8 @@
 /**
  * Coms Extension for pi
  *
- * Inter-agent communication — P2P (coms) and networked (coms-net).
- * Activated on-demand via /coms and /coms-net slash commands.
+ * Inter-agent communication — P2P (coms).
+ * Activated on-demand via /coms slash command.
  *
  * Standalone extension so it can be loaded independently by pi-sidecar
  * without pulling in the full orchestrator.
@@ -11,10 +11,14 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createLogger } from "../shared/logger.js";
+import { shouldSkipOneshotRegister } from "../shared/oneshot.js";
 import { registerComs } from "./coms-wrapper.js";
-import { registerComsNet } from "./coms-net-wrapper.js";
+
+const log = createLogger("coms");
 
 export default function (pi: ExtensionAPI) {
+    if (shouldSkipOneshotRegister(log)) return;
+    log.debug("register coms");
     registerComs(pi);
-    registerComsNet(pi);
 }

package/extensions/coms/mixed-turn.ts

@@ -0,0 +1,26 @@
+/**
+ * extensions/coms/mixed-turn.ts — Pure helpers for coms mixed-turn detection.
+ * Kept dependency-free so both the coms extension handlers and unit tests can
+ * import the SAME production logic (no mirrored copies). The shared logger is
+ * dependency-light (node builtins only via file-logger) so importing it here
+ * does not pull in pi-tui and keeps the module test-importable — the same
+ * pattern used by extensions/pitasks/reminders.ts.
+ */
+
+import { createLogger } from "../shared/logger.js";
+
+const log = createLogger("coms-mixed-turn");
+
+/** True when a real user message (role "user") arrives while a coms inbound turn is being processed (#741). */
+export function isUserMessageDuringInbound(processingInbound: boolean, role: string | undefined): boolean {
+	const result = processingInbound === true && role === "user";
+	log.debug("isUserMessageDuringInbound", processingInbound, role, result);
+	return result;
+}
+
+/** True when the turn must be handled as a mixed turn (re-inject the inbound instead of auto-capturing assistant text). */
+export function computeMixedTurn(inboundSetDuringUserTurn: boolean, userMessageDuringInbound: boolean): boolean {
+	const result = inboundSetDuringUserTurn || userMessageDuringInbound;
+	log.debug("computeMixedTurn", inboundSetDuringUserTurn, userMessageDuringInbound, result);
+	return result;
+}