pi-orchestrator-config 4.4.1 → 4.6.0

package/README.md

@@ -65,6 +65,7 @@ Single extension that provides:
 | `/issue-review`                                                                                 | Review a GitHub issue spec and fix it                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | `/release [flags]`                                                                              | Create GitHub release with changelog and version bumping                                                                                                                                                                                                                                                                                                                                                                                                   |
 | `/review-local [branch]`                                                                        | Review local uncommitted or branch changes                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `/qodo-review [--autofix] [--fast\|--deep] [--ticket <url>] [path ...]`                         | Review local changes with Qodo, attach session context, and optionally autofix (max 3 cycles)                                                                                                                                                                                                                                                                                                                                                            |
 | `/review-handler [url] [--autorabbit] [--autoqodo]`                                             | Process PR review comments, fix approved items                                                                                                                                                                                                                                                                                                                                                                                                             |
 | `/domain-model [focus area]`                                                                    | Scan codebase and build/update a CONTEXT.md domain glossary for consistent AI vocabulary                                                                                                                                                                                                                                                                                                                                                                   |
 | `/refine-review <url>`                                                                          | Refine and improve existing PR review comments                                                                                                                                                                                                                                                                                                                                                                                                             |
@@ -76,7 +77,7 @@ Single extension that provides:
 | `/dream`                                                                                        | Run memory consolidation — extract, deduplicate, maintain topic-based memory                                                                                                                                                                                                                                                                                                                                                                               |
 | `/remember <what>`                                                                              | Save a memory for future sessions                                                                                                                                                                                                                                                                                                                                                                                                                          |
 | `/dream-auto`                                                                                   | Toggle automatic memory dreaming (every 3h + session end)                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `/cron add\|list\|list-all\|remove [--persist]`                                                         | Schedule recurring tasks. Session jobs end with the session; `--persist` keeps a job across Pi sessions in this project. Add/remove mutations still work when leader election fails closed on an unsupported platform. For example: `/cron add every 2h check for new issues --persist` or `/cron remove persist:<uuid>`. `/cron list` opens an overlay for the selected jobs (or both when omitted). Persistent delivery is local at-least-once: a crash or leader recovery can repeat a run. |
+| `/cron add\|list\|list-all\|remove [--persist]`                                                         | Schedule recurring tasks. Session jobs end with the session; `--persist` keeps a job across Pi sessions in this project. Add/remove mutations still work when leader election fails closed on an unsupported platform. For example: `/cron add every 2h check for new issues --persist` or `/cron remove persist:<uuid>`. `/cron list` opens an overlay for the selected jobs (or both when omitted). Persistent delivery is local at-least-once: a crash or leader recovery can repeat a run. Project cron writes use a stable OS `flock` (included in Docker via `util-linux`) across the entire transaction; native installations need `flock` and a shared filesystem that supports advisory locks. A busy or unavailable lock fails closed after two seconds. **Upgrade gate (enforced):** stop and drain every old Pi process writing crons on the shared mount before starting a version with this kernel lock; old directory-lock writers do not honor `flock` and must not resume. If a legacy `crons.json.mutation.lock` directory exists, new writes fail closed even if its PID is invisible or its heartbeat expired. Only after verifying every old writer cannot resume may an operator remove that stale directory (not `crons.json` or cron tasks). Never remove it merely because a write timed out. |
 | `/async-kill [name\|id\|all]`                                                                   | Kill async agents (overlay picker or by name/id)                                                                                                                                                                                                                                                                                                                                                                                                           |
 | `/pi-config-settings [project\|global]`                                                         | Interactive TUI settings editor — browse all pi-config settings with scope indicators, smart pickers for providers/models, and immediate save                                                                                                                                                                                                                                                                                                              |
 | `/status`                                                                                       | Unified session snapshot — async agents, cron tasks, git branch, context usage                                                                                                                                                                                                                                                                                                                                                                             |
@@ -466,6 +467,13 @@ settings; it reads the project locally and stores its regenerable graph in `./gr
 Native installations require Node.js 22+, npm 12+, Python 3, `make`, and G++; the
 installer uses the same audited strict installation and failure remains non-fatal.
 
+**Persistent cron locking:** The image includes `flock` from `util-linux` for kernel-backed,
+cross-container store mutations on shared mounts. The shared filesystem must support
+advisory locks. Before deploying this version alongside old Pi containers, stop and
+drain every legacy cron writer. An existing legacy mutation-lock directory blocks
+new writes until an operator verifies old writers cannot resume and removes only
+that directory. Do not stop running containers merely to test this PR.
+
 **CLI provider binaries (optional `cli_agents`):** The image installs the CLIs used by
 `cli-*` providers — `claude` (Claude Code), `gemini` (`@google/gemini-cli`), and
 `agent` (Cursor Agent CLI). Enable with `cli_agents` in settings (e.g.
@@ -710,6 +718,7 @@ PI_PIDIFF_ENABLE=false pi
 | `-v "$HOME/.claude/credentials.json":"$HOME/.claude/credentials.json":ro`                                                       | Claude CLI auth (for acpx-claude / cli-claude models) |
 | `-v "$HOME/.config/glab-cli":"$HOME/.config/glab-cli":ro`                                                                       | GitLab CLI config (auth tokens, host settings)        |
 | `-v "$HOME/.coderabbit":"$HOME/.coderabbit":rw`                                                                                 | CodeRabbit CLI auth and review data                   |
+| `-v "$HOME/.qodo":"$HOME/.qodo":rw`                                                                                             | Qodo CLI auth directory (mount at the container user's `$HOME/.qodo`; with `PI_HOST_USER`, that is `/home/$PI_HOST_USER/.qodo`). Create it on the host first with `mkdir -p "$HOME/.qodo"`; inside the container run `qodo read whoami` and, if signed out, `qodo login`. Host OS-keychain credentials may not work inside the container. |
 | `-v "$HOME/screenshots":"$HOME/screenshots"`                                                                                    | Share screenshots/images with the agent               |
 | `-v /var/run/docker.sock:/var/run/docker.sock:ro` + `--group-add $(stat -c '%g' /var/run/docker.sock)`                          | Docker container inspection via `docker-safe`         |
 | `-v /var/run/podman/podman.sock:/var/run/podman/podman.sock:ro`                                                                 | Podman container inspection via `docker-safe`         |
@@ -740,6 +749,7 @@ PI_PIDIFF_ENABLE=false pi
 | `jq`                | JSON processing                                                                                                                                                                                                                                                                                                                |
 | `rg` (ripgrep)      | Fast recursive search                                                                                                                                                                                                                                                                                                          |
 | `cr`                | CodeRabbit CLI — local AI code reviews                                                                                                                                                                                                                                                                                         |
+| `qodo`              | Qodo CLI — local code reviews (`qodo --version`; mount `~/.qodo` as above and authenticate inside the container if needed)                                                                                                                                                                                                   |
 | `curl`              | HTTP requests                                                                                                                                                                                                                                                                                                                  |
 
 #### `myk-pi-tools` subcommands
@@ -886,7 +896,7 @@ See [DEVELOPMENT.md](DEVELOPMENT.md) for tips on testing extensions locally, run
 
 ## Prerequisites
 
-- [pi](https://github.com/badlogic/pi-mono) (minimum version: **0.84.4**). Pidash uses Pi's `ui_prompt_start` and `ui_prompt_end` events to show prompt wait separately from agent work.
+- [pi](https://github.com/badlogic/pi-mono) (minimum version: **0.87.0**). Pidash uses Pi's `ui_prompt_start` and `ui_prompt_end` events to show prompt wait separately from agent work.
 - `gh` CLI (for GitHub operations)
 - `uv` (for Python execution)
 - `myk-pi-tools` (optional, for `/pr-review` and `/release`)

package/extensions/coms/coms-p2p.ts

@@ -848,10 +848,11 @@ export default function (pi: ExtensionAPI) {
 		ackOk(socket, env.msg_id);
 	}
 
-	function buildAgentCard(): AgentCard {
+	async function buildAgentCard(): Promise<AgentCard> {
 		const ctx = currentCtx;
 		const ident = identity;
 		const pct = ctx ? Math.round(ctx.getContextUsage()?.percent ?? 0) : 0;
+		log.debug("build_agent_card", { hasIdentity: !!ident });
 		return {
 			name: ident?.name ?? "unknown",
 			purpose: ident?.purpose ?? "",
@@ -859,22 +860,24 @@ export default function (pi: ExtensionAPI) {
 			color: ident?.color ?? "#36F9F6",
 			context_used_pct: pct,
 			queue_depth: getPendingInboundCount(),
-			tasks_summary: readTaskSummary(currentCtx?.cwd ?? process.cwd(), currentCtx?.sessionManager?.getSessionId?.()),
+			tasks_summary: await readTaskSummary(currentCtx?.cwd ?? process.cwd(), currentCtx?.sessionManager?.getSessionId?.()),
 		};
 	}
 
 	/** Push current agent card to ping worker so it can respond independently */
-	function updatePingWorkerCard(): void {
+	async function updatePingWorkerCard(): Promise<void> {
+		log.debug("update_ping_worker_card", { ready: pingWorkerReady });
 		if (!pingWorker || !pingWorkerReady) return;
 		try {
-			const card = buildAgentCard();
+			const card = await buildAgentCard();
 			const pong: Pong = { type: "pong", msg_id: "", agent_card: card };
 			pingWorker.postMessage({ type: "update_card", pong });
 		} catch { /* ignore */ }
 	}
 
-	function handlePing(socket: net.Socket, env: PingEnvelope): void {
-		const card = buildAgentCard();
+	async function handlePing(socket: net.Socket, env: PingEnvelope): Promise<void> {
+		log.debug("handle_ping", { msgId: env.msg_id });
+		const card = await buildAgentCard();
 		const pong: Pong = { type: "pong", msg_id: env.msg_id, agent_card: card };
 		try {
 			socket.write(JSON.stringify(pong) + "\n");
@@ -883,7 +886,7 @@ export default function (pi: ExtensionAPI) {
 		}
 		try { socket.end(); } catch { /* ignore */ }
 		// Also update worker with latest card
-		updatePingWorkerCard();
+		await updatePingWorkerCard();
 	}
 
 	function isValidEnvelope(obj: any): obj is Envelope {
@@ -935,7 +938,7 @@ export default function (pi: ExtensionAPI) {
 				} else if (parsed.type === "response") {
 					handleResponse(socket, parsed as ResponseEnvelope);
 				} else if (parsed.type === "ping") {
-					handlePing(socket, parsed as PingEnvelope);
+					void handlePing(socket, parsed as PingEnvelope).catch(() => nack(socket, parsed.msg_id, "internal error"));
 				} else if (parsed.type === "task_update") {
 					handleTaskUpdate(socket, parsed as TaskUpdateEnvelope);
 				} else if (parsed.type === "queue_manage") {
@@ -1994,7 +1997,7 @@ Do not respond to this message.`;
 			// Append sender's active tasks for this peer to the prompt
 			let promptText = params.prompt;
 			try {
-				const { listTasksForSession } = require("../pitasks/index.js");
+				const { listTasksForSession } = await import("../pitasks/index.js");
 				const targetPiSessionId = target.pi_session_id || target.coms_session_id;
 				const allTasks = listTasksForSession(targetPiSessionId, target.cwd) || [];
 				const myTasks = allTasks.filter((t: any) =>
@@ -2021,27 +2024,8 @@ Do not respond to this message.`;
 				tasks: params.tasks ?? null,
 			};
 
-			// Send the envelope synchronously and wait for the receiver's ack.
-			await sendEnvelope(target.endpoint, env);
-			comsSendCalledThisTurn.add(target.coms_session_id);
-
-			// Auto-create tasks on the target's task store (sender-side, instant)
-			if (params.tasks && params.tasks.length > 0 && target.coms_session_id) {
-				try {
-					const count = createComsInboundTasks(
-						params.tasks,
-						{ sender_session: identity.coms_session_id, sender_name: identity.name, sender_endpoint: identity.endpoint },
-						target.pi_session_id || target.coms_session_id,
-						target.cwd,
-					);
-					if (count > 0) {
-						log.info("tasks_auto_created", msg_id, "to", target.name, "count", count);
-					}
-				} catch { /* best-effort */ }
-			}
-
-			// Register a pending entry whose promise the receiver-side handleResponse
-			// (or the timeout below) will settle.
+			// Register before sending. A peer may acknowledge and respond before
+			// task creation's dynamic import completes.
 			let resolveFn!: (v: { response?: any; error?: string | null }) => void;
 			let rejectFn!: (e: Error) => void;
 			const promise = new Promise<{ response?: any; error?: string | null }>((res, rej) => {
@@ -2069,13 +2053,37 @@ Do not respond to this message.`;
 			try { (entry.timer as any).unref?.(); } catch { /* ignore */ }
 			pendingReplies.set(msg_id, entry);
 
-			log.debug("outbound_prompt", msg_id, "to", target.name, "hops", hops);
-
-			// Track pending outbound
 			const targetKey = target.name;
 			if (!pendingOutbound.has(targetKey)) pendingOutbound.set(targetKey, new Set());
 			pendingOutbound.get(targetKey)!.add(msg_id);
 
+			try {
+				await sendEnvelope(target.endpoint, env);
+			} catch (error) {
+				pendingReplies.delete(msg_id);
+				pendingOutbound.get(targetKey)?.delete(msg_id);
+				if (pendingOutbound.get(targetKey)?.size === 0) pendingOutbound.delete(targetKey);
+				if (entry.timer) clearTimeout(entry.timer);
+				throw error;
+			}
+			comsSendCalledThisTurn.add(target.coms_session_id);
+
+			if (params.tasks && params.tasks.length > 0 && target.coms_session_id) {
+				try {
+					const count = await createComsInboundTasks(
+						params.tasks,
+						{ sender_session: identity.coms_session_id, sender_name: identity.name, sender_endpoint: identity.endpoint },
+						target.pi_session_id || target.coms_session_id,
+						target.cwd,
+					);
+					if (count > 0) log.info("tasks_auto_created", msg_id, "to", target.name, "count", count);
+				} catch (error) {
+					log.warn("tasks_auto_create_failed", { msg_id, target: target.name, error: error instanceof Error ? error.message : String(error) });
+				}
+			}
+
+			log.debug("outbound_prompt", msg_id, "to", target.name, "hops", hops);
+
 			// Peer status from peerCards
 			const peerCard = peerCards.get(target.coms_session_id);
 			const peer_queue_depth = peerCard?.queue_depth ?? 0;
@@ -2305,6 +2313,7 @@ Do not respond to this message.`;
 			}), { description: "Tasks to create on the peer" }),
 		}),
 		async execute(_callId, params) {
+			log.debug("coms_tasks_create_start", { target: params.target, count: params.tasks?.length ?? 0 });
 			if (!identity) throw new Error("coms not initialised");
 			if (!params.tasks || params.tasks.length === 0) throw new Error("coms_tasks_create requires at least one task");
 			const target = await resolveTarget(params.target);
@@ -2320,7 +2329,7 @@ Do not respond to this message.`;
 			if (identity.endpoint) meta.sender_endpoint = identity.endpoint;
 
 			try {
-				const { createTasksForSession, listTasksForSession, updateTaskForSession } = require("../pitasks/index.js");
+				const { createTasksForSession, listTasksForSession, updateTaskForSession } = await import("../pitasks/index.js");
 				const targetPiSessionId = target.pi_session_id || target.coms_session_id;
 
 				// Create all tasks in one batch
@@ -2401,12 +2410,13 @@ Do not respond to this message.`;
 			task_id: Type.String({ description: "Task ID to delete." }),
 		}),
 		async execute(_callId, params) {
+			log.debug("coms_task_delete_start", { target: params.target, taskId: params.task_id });
 			if (!identity) throw new Error("coms not initialised");
 			const target = await resolveTarget(params.target);
 			if (!target) throw new Error(`coms: no live agent matching "${params.target}"`);
 
 			try {
-				const { getTaskForSession, deleteTaskForSession } = require("../pitasks/index.js");
+				const { getTaskForSession, deleteTaskForSession } = await import("../pitasks/index.js");
 				const targetPiSessionId = target.pi_session_id || target.coms_session_id;
 				const task = getTaskForSession(targetPiSessionId, params.task_id, target.cwd);
 				if (!task) throw new Error(`Task #${params.task_id} not found`);
@@ -2440,12 +2450,13 @@ Do not respond to this message.`;
 			target: Type.String({ description: "Peer name or session_id." }),
 		}),
 		async execute(_callId, params) {
+			log.debug("coms_task_list_start", { target: params.target });
 			if (!identity) throw new Error("coms not initialised");
 			const target = await resolveTarget(params.target);
 			if (!target) throw new Error(`coms: no live agent matching "${params.target}"`);
 
 			try {
-				const { listTasksForSession } = require("../pitasks/index.js");
+				const { listTasksForSession } = await import("../pitasks/index.js");
 				const targetPiSessionId = target.pi_session_id || target.coms_session_id;
 				const tasks = listTasksForSession(targetPiSessionId, target.cwd);
 				log.debug("coms_task_list", target.name, "tasks", tasks?.length ?? 0);
@@ -2494,12 +2505,13 @@ Do not respond to this message.`;
 			task_id: Type.String({ description: "Task ID to retrieve." }),
 		}),
 		async execute(_callId, params) {
+			log.debug("coms_task_get_start", { target: params.target, taskId: params.task_id });
 			if (!identity) throw new Error("coms not initialised");
 			const target = await resolveTarget(params.target);
 			if (!target) throw new Error(`coms: no live agent matching "${params.target}"`);
 
 			try {
-				const { getTaskForSession } = require("../pitasks/index.js");
+				const { getTaskForSession, listTasksForSession } = await import("../pitasks/index.js");
 				const targetPiSessionId = target.pi_session_id || target.coms_session_id;
 				const task = getTaskForSession(targetPiSessionId, params.task_id, target.cwd);
 				if (!task) throw new Error(`Task #${params.task_id} not found on ${target.name}`);
@@ -2512,7 +2524,6 @@ Do not respond to this message.`;
 				if (task.owner) lines.push(`Owner: ${task.owner}`);
 				lines.push(`Description: ${desc}`);
 				if (task.blockedBy?.length > 0) {
-					const { listTasksForSession } = require("../pitasks/index.js");
 					const allTasks = listTasksForSession(targetPiSessionId, target.cwd);
 					const openBlockers = task.blockedBy.filter((bid: string) => {
 						const blocker = allTasks.find((bt: any) => bt.id === bid);
@@ -2549,12 +2560,13 @@ Do not respond to this message.`;
 			addBlockedBy: Type.Optional(Type.Array(Type.String(), { description: "Task IDs that block this task" })),
 		}),
 		async execute(_callId, params) {
+			log.debug("coms_task_update_start", { target: params.target, taskId: params.task_id });
 			if (!identity) throw new Error("coms not initialised");
 			const target = await resolveTarget(params.target);
 			if (!target) throw new Error(`coms: no live agent matching "${params.target}"`);
 
 			try {
-				const { getTaskForSession, updateTaskForSession } = require("../pitasks/index.js");
+				const { getTaskForSession, updateTaskForSession } = await import("../pitasks/index.js");
 				const targetPiSessionId = target.pi_session_id || target.coms_session_id;
 				const task = getTaskForSession(targetPiSessionId, params.task_id, target.cwd);
 				if (!task) throw new Error(`Task #${params.task_id} not found on ${target.name}`);

package/extensions/coms/coms-shared.ts

@@ -461,9 +461,10 @@ export function readFrontmatterFromArgv(argv: string[]): { name?: string; descri
 	}
 }
 
-export function readTaskSummary(_cwd: string, _sessionId?: string): { total: number; completed: number; in_progress: number } | null {
+export async function readTaskSummary(_cwd: string, _sessionId?: string): Promise<{ total: number; completed: number; in_progress: number } | null> {
+	log.debug("read_task_summary", { hasSessionId: !!_sessionId });
 	try {
-		const { listTasks } = require("../pitasks/index.js");
+		const { listTasks } = await import("../pitasks/index.js");
 		const tasks = listTasks();
 		if (!tasks || tasks.length === 0) return null;
 		let total = 0, completed = 0, in_progress = 0;
@@ -650,17 +651,18 @@ const MAX_TASK_FIELD_LEN = 2000;
  * Runs on the SENDER side — uses createTaskForSession with the target's session ID.
  * TaskStore handles locking, file format, everything.
  */
-export function createComsInboundTasks(
+export async function createComsInboundTasks(
 	tasks: Array<{ subject: string; description: string }>,
 	origin: ComsOrigin,
 	targetSessionId: string,
 	targetCwd?: string,
-): number {
+): Promise<number> {
+	log.debug("create_coms_inbound_tasks", { targetSessionId, count: tasks?.length ?? 0 });
 	if (!tasks || tasks.length === 0 || !targetSessionId) return 0;
 
 	let createTaskForSession: any;
 	try {
-		createTaskForSession = require("../pitasks/index.js").createTaskForSession;
+		createTaskForSession = (await import("../pitasks/index.js")).createTaskForSession;
 	} catch { return 0; }
 	if (!createTaskForSession) return 0;