omegon 0.6.10 → 0.6.13

package/bin/omegon.mjs

@@ -52,10 +52,14 @@ function injectBundledResourceArgs(argv) {
     }
   };
 
+  // Omegon is the sole authority for bundled resources.
+  // Suppress pi's auto-discovery of skills, prompts, and themes (which scans
+  // ~/.pi/agent/*, installed packages, and project .pi/ dirs) so only our
+  // manifest-declared resources load. The --no-* flags disable discovery
+  // but still allow CLI-injected paths (our --extension manifest).
+  // Extensions are NOT suppressed — project-local .pi/extensions/ should still work.
+  injected.push("--no-skills", "--no-prompt-templates", "--no-themes");
   pushPair("--extension", omegonRoot);
-  pushPair("--skill", join(omegonRoot, "skills"));
-  pushPair("--prompt-template", join(omegonRoot, "prompts"));
-  pushPair("--theme", join(omegonRoot, "themes"));
   return injected;
 }
 

package/extensions/bootstrap/deps.ts

@@ -46,46 +46,9 @@ function hasCmd(cmd: string): boolean {
 	}
 }
 
-/**
- * Detect immutable/atomic Linux distros (Bazzite, Silverblue, Kinoite, etc.)
- * where dnf/apt are unavailable or aliased to guides. These distros typically
- * use Homebrew (Linuxbrew) or Flatpak for user-space packages.
- */
-function isImmutableLinux(): boolean {
-	if (process.platform !== "linux") return false;
-	try {
-		const osRelease = execSync("cat /etc/os-release 2>/dev/null", { encoding: "utf-8" });
-		// Bazzite, Silverblue, Kinoite, Aurora, Bluefin — all Fedora Atomic variants
-		return /VARIANT_ID=.*(silverblue|kinoite|bazzite|aurora|bluefin|atomic)/i.test(osRelease)
-			|| /ostree/i.test(osRelease);
-	} catch {
-		return false;
-	}
-}
-
-/** Cached immutable Linux detection */
-const _isImmutable = isImmutableLinux();
-
 /** Get the best install command for the current platform */
 export function bestInstallCmd(dep: Dep): string | undefined {
 	const plat = process.platform === "darwin" ? "darwin" : "linux";
-
-	// On immutable Linux (Bazzite, Silverblue, etc.), dnf/apt are unavailable
-	// or aliased to documentation guides. Prefer brew commands.
-	// On regular Linux, prefer non-brew (apt/dnf) unless brew is the only option.
-	const hasBrew = hasCmd("brew");
-	if (plat === "linux" && (_isImmutable || !hasBrew)) {
-		// Immutable: must use brew (skip apt/dnf). Regular without brew: skip brew commands.
-		const candidates = dep.install.filter((o) => o.platform === plat || o.platform === "any");
-		if (_isImmutable && hasBrew) {
-			const brewCmd = candidates.find((o) => o.cmd.startsWith("brew "));
-			if (brewCmd) return brewCmd.cmd;
-		} else if (!_isImmutable) {
-			const nonBrew = candidates.find((o) => !o.cmd.startsWith("brew "));
-			if (nonBrew) return nonBrew.cmd;
-		}
-	}
-
 	return (
 		dep.install.find((o) => o.platform === plat)?.cmd ??
 		dep.install.find((o) => o.platform === "any")?.cmd ??
@@ -108,6 +71,18 @@ export function installHints(dep: Dep): string[] {
  */
 export const DEPS: Dep[] = [
 	// --- Core: most users want these ---
+	{
+		id: "nix",
+		name: "Nix",
+		purpose: "Universal package manager — installs all other dependencies on any OS",
+		usedBy: ["bootstrap"],
+		tier: "core",
+		check: () => hasCmd("nix"),
+		install: [
+			{ platform: "any", cmd: "curl --proto '=https' --tlsv1.2 -sSf -L https://install.determinate.systems/nix | sh -s -- install" },
+		],
+		url: "https://zero-to-nix.com",
+	},
 	{
 		id: "ollama",
 		name: "Ollama",
@@ -115,9 +90,9 @@ export const DEPS: Dep[] = [
 		usedBy: ["local-inference", "project-memory", "cleave", "offline-driver"],
 		tier: "core",
 		check: () => hasCmd("ollama"),
+		requires: ["nix"],
 		install: [
-			{ platform: "darwin", cmd: "brew install ollama" },
-			{ platform: "linux", cmd: "curl -fsSL https://ollama.com/install.sh | sh" },
+			{ platform: "any", cmd: "nix profile install nixpkgs#ollama" },
 		],
 		url: "https://ollama.com",
 	},
@@ -128,9 +103,9 @@ export const DEPS: Dep[] = [
 		usedBy: ["render", "view"],
 		tier: "core",
 		check: () => hasCmd("d2"),
+		requires: ["nix"],
 		install: [
-			{ platform: "darwin", cmd: "brew install d2" },
-			{ platform: "linux", cmd: "curl -fsSL https://d2lang.com/install.sh | sh" },
+			{ platform: "any", cmd: "nix profile install nixpkgs#d2" },
 		],
 		url: "https://d2lang.com",
 	},
@@ -143,10 +118,9 @@ export const DEPS: Dep[] = [
 		usedBy: ["01-auth"],
 		tier: "recommended",
 		check: () => hasCmd("gh"),
+		requires: ["nix"],
 		install: [
-			{ platform: "darwin", cmd: "brew install gh" },
-			{ platform: "linux", cmd: "brew install gh" },
-			{ platform: "linux", cmd: "sudo apt install gh || sudo dnf install gh" },
+			{ platform: "any", cmd: "nix profile install nixpkgs#gh" },
 		],
 		url: "https://cli.github.com",
 	},
@@ -157,9 +131,9 @@ export const DEPS: Dep[] = [
 		usedBy: ["view"],
 		tier: "recommended",
 		check: () => hasCmd("pandoc"),
+		requires: ["nix"],
 		install: [
-			{ platform: "darwin", cmd: "brew install pandoc" },
-			{ platform: "linux", cmd: "sudo apt install pandoc || sudo dnf install pandoc" },
+			{ platform: "any", cmd: "nix profile install nixpkgs#pandoc" },
 		],
 		url: "https://pandoc.org",
 	},
@@ -171,9 +145,7 @@ export const DEPS: Dep[] = [
 		tier: "recommended",
 		check: () => hasCmd("cargo"),
 		install: [
-			// -s -- -y passes -y to rustup-init, suppressing the interactive
-			// "1) Proceed / 2) Customise / 3) Cancel" prompt that otherwise hangs.
-			{ platform: "any", cmd: "curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y" },
+			{ platform: "any", cmd: "nix profile install nixpkgs#rustup && rustup default stable" },
 		],
 		url: "https://rustup.rs",
 	},
@@ -199,10 +171,9 @@ export const DEPS: Dep[] = [
 		usedBy: ["view"],
 		tier: "optional",
 		check: () => hasCmd("rsvg-convert"),
+		requires: ["nix"],
 		install: [
-			{ platform: "darwin", cmd: "brew install librsvg" },
-			{ platform: "linux", cmd: "brew install librsvg" },
-			{ platform: "linux", cmd: "sudo apt install librsvg2-bin" },
+			{ platform: "any", cmd: "nix profile install nixpkgs#librsvg" },
 		],
 	},
 	{
@@ -212,10 +183,9 @@ export const DEPS: Dep[] = [
 		usedBy: ["view"],
 		tier: "optional",
 		check: () => hasCmd("pdftoppm"),
+		requires: ["nix"],
 		install: [
-			{ platform: "darwin", cmd: "brew install poppler" },
-			{ platform: "linux", cmd: "brew install poppler" },
-			{ platform: "linux", cmd: "sudo apt install poppler-utils" },
+			{ platform: "any", cmd: "nix profile install nixpkgs#poppler_utils" },
 		],
 	},
 	{
@@ -225,9 +195,9 @@ export const DEPS: Dep[] = [
 		usedBy: ["render"],
 		tier: "optional",
 		check: () => hasCmd("uv"),
+		requires: ["nix"],
 		install: [
-			{ platform: "darwin", cmd: "brew install uv" },
-			{ platform: "any", cmd: "curl -LsSf https://astral.sh/uv/install.sh | sh" },
+			{ platform: "any", cmd: "nix profile install nixpkgs#uv" },
 		],
 		url: "https://docs.astral.sh/uv/",
 	},
@@ -238,10 +208,9 @@ export const DEPS: Dep[] = [
 		usedBy: ["01-auth"],
 		tier: "optional",
 		check: () => hasCmd("aws"),
+		requires: ["nix"],
 		install: [
-			{ platform: "darwin", cmd: "brew install awscli" },
-			{ platform: "linux", cmd: "brew install awscli" },
-			{ platform: "linux", cmd: "sudo apt install awscli" },
+			{ platform: "any", cmd: "nix profile install nixpkgs#awscli2" },
 		],
 	},
 	{
@@ -251,10 +220,9 @@ export const DEPS: Dep[] = [
 		usedBy: ["01-auth"],
 		tier: "optional",
 		check: () => hasCmd("kubectl"),
+		requires: ["nix"],
 		install: [
-			{ platform: "darwin", cmd: "brew install kubectl" },
-			{ platform: "linux", cmd: "brew install kubectl" },
-			{ platform: "linux", cmd: "sudo apt install kubectl" },
+			{ platform: "any", cmd: "nix profile install nixpkgs#kubectl" },
 		],
 	},
 ];
@@ -269,13 +237,40 @@ export function checkAll(): DepStatus[] {
 	}));
 }
 
+/**
+ * Detect whether the terminal supports Unicode emoji rendering.
+ *
+ * Returns true for modern terminals (Windows Terminal, VS Code, xterm-256color,
+ * iTerm2, etc.) and false for legacy consoles (Windows conhost.exe) where emoji
+ * render as blank boxes.  Errs on the side of ASCII when uncertain.
+ */
+function supportsEmoji(): boolean {
+	// Windows Terminal sets WT_SESSION; conhost.exe does not
+	if (process.env["WT_SESSION"]) return true;
+	// VS Code integrated terminal
+	if (process.env["TERM_PROGRAM"] === "vscode") return true;
+	// iTerm2, Hyper, and other macOS/Linux terminals advertising 256-color
+	if (process.env["TERM_PROGRAM"] === "iTerm.app") return true;
+	// xterm-256color and similar modern TERM values
+	const term = process.env["TERM"] ?? "";
+	if (term.includes("256color") || term === "xterm-kitty") return true;
+	// COLORTERM=truecolor or 24bit signals a modern terminal
+	const colorterm = process.env["COLORTERM"] ?? "";
+	if (colorterm === "truecolor" || colorterm === "24bit") return true;
+	// CI environments typically render emoji correctly
+	if (process.env["CI"]) return true;
+	// Non-Windows: default to emoji; on Windows without the above signals, use ASCII
+	return process.platform !== "win32";
+}
+
 /** Format a single dep status as a line, with install hint if missing */
 function formatStatus(s: DepStatus): string {
-	const icon = s.available ? "✅" : "❌";
+	const emoji = supportsEmoji();
+	const icon = s.available ? (emoji ? "✅" : "[ok]") : (emoji ? "❌" : "[x]");
 	let line = `${icon}  ${s.dep.name} — ${s.dep.purpose}`;
 	if (!s.available) {
 		const cmd = bestInstallCmd(s.dep);
-		if (cmd) line += `\n      → \`${cmd}\``;
+		if (cmd) line += `\n      ${emoji ? "→" : "->"} \`${cmd}\``;
 	}
 	return line;
 }
@@ -303,10 +298,11 @@ export function formatReport(statuses: DepStatus[]): string {
 	}
 
 	const missing = statuses.filter((s) => !s.available);
+	const emoji = supportsEmoji();
 	if (missing.length === 0) {
-		lines.push("🎉 All dependencies are available!");
+		lines.push(emoji ? "🎉 All dependencies are available!" : "[ok] All dependencies are available!");
 	} else {
-		lines.push(`**${missing.length} missing** — run \`/bootstrap\` to install interactively.`);
+		lines.push(`${emoji ? "⚠️ " : "[!] "}**${missing.length} missing** — run \`/bootstrap\` to install interactively.`);
 	}
 
 	return lines.join("\n");

package/extensions/bootstrap/index.ts

@@ -25,6 +25,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir, tmpdir } from "node:os";
 import type { ExtensionAPI } from "@styrene-lab/pi-coding-agent";
+import { resolveOmegonSubprocess } from "../lib/omegon-subprocess.ts";
 import { checkAllProviders, type AuthResult } from "../01-auth/auth.ts";
 import { loadPiConfig } from "../lib/model-preferences.ts";
 import {
@@ -362,11 +363,15 @@ export default function (pi: ExtensionAPI) {
 
 			if (sub === "status") {
 				const statuses = checkAll();
-				cmdCtx.say(formatReport(statuses));
 				const profile = loadOperatorProfile(getConfigRoot(cmdCtx));
-				cmdCtx.say(profile
+				const profileLine = profile
 					? `\nOperator capability profile: ${profile.setupComplete ? "configured" : "defaulted"}`
-					: "\nOperator capability profile: not configured");
+					: "\nOperator capability profile: not configured";
+				// Merge into a single say() call — the pi TUI showStatus() deduplication
+				// pattern replaces the previous notification when two consecutive say()
+				// calls are made synchronously, so splitting these would silently discard
+				// the dependency report.
+				cmdCtx.say(formatReport(statuses) + profileLine);
 				return;
 			}
 
@@ -409,10 +414,48 @@ export default function (pi: ExtensionAPI) {
 			await ctx.reload();
 		},
 	});
+
+	// --- /restart: full process restart ---
+	pi.registerCommand("restart", {
+		description: "Restart Omegon (clears cache, spawns fresh process)",
+		handler: async (_args, ctx) => {
+			clearJitiCache(ctx);
+			ctx.ui.notify("Restarting Omegon…", "info");
+			await new Promise((r) => setTimeout(r, 500));
+			restartOmegon();
+		},
+	});
 }
 
 // ── /update helpers ──────────────────────────────────────────────────────
 
+/**
+ * Replace the current Omegon process with a fresh instance.
+ *
+ * Spawns a new detached Omegon process with inherited stdio, then exits
+ * the current process. The user sees the terminal briefly reset and the
+ * new session starts automatically — no manual re-launch needed.
+ */
+function restartOmegon(): never {
+	const { command, argvPrefix } = resolveOmegonSubprocess();
+	// Pass through any user-facing args from the original invocation
+	// (skip argv[0]=node, argv[1]=omegon.mjs which argvPrefix covers)
+	const userArgs = process.argv.slice(2).filter(a =>
+		// Strip injected resource flags — the new process injects its own
+		!a.startsWith("--extensions-dir=") &&
+		!a.startsWith("--themes-dir=") &&
+		!a.startsWith("--skills-dir=") &&
+		!a.startsWith("--prompts-dir=")
+	);
+	const child = spawn(command, [...argvPrefix, ...userArgs], {
+		stdio: "inherit",
+		detached: true,
+		env: process.env,
+	});
+	child.unref();
+	process.exit(0);
+}
+
 /** Run a command, collect stdout+stderr, resolve with exit code. */
 function run(
 	cmd: string, args: string[], opts?: { cwd?: string },
@@ -609,11 +652,15 @@ async function updateDevMode(
 	}
 	steps.push(formatVerification(verification));
 
-	// ── Step 7: clear cache + explicit restart handoff ───────────────
+	// ── Step 7: clear cache + restart ────────────────────────────────
 	const cleared = clearJitiCache(ctx);
 	if (cleared > 0) steps.push(`✓ cleared ${cleared} cached transpilations`);
-	steps.push("✓ update complete — restart Omegon now (/exit, then `omegon`) to load the rebuilt runtime");
+	steps.push("✓ update complete — restarting Omegon…");
 	ctx.ui.notify(steps.join("\n"), "info");
+
+	// Brief pause so the user sees the summary before the terminal resets
+	await new Promise((r) => setTimeout(r, 1500));
+	restartOmegon();
 }
 
 /** Installed mode: npm install -g omegon@latest → verify → cache clear → restart handoff. */
@@ -687,9 +734,12 @@ async function updateInstalledMode(
 		`✅ Updated to ${PKG}@${latestVersion}.` +
 		`\n${formatVerification(verification)}` +
 		(cleared > 0 ? `\nCleared ${cleared} cached transpilations.` : "") +
-		"\nRestart Omegon to use the new version (/exit, then omegon).",
+		"\nRestarting Omegon…",
 		"info"
 	);
+
+	await new Promise((r) => setTimeout(r, 1500));
+	restartOmegon();
 }
 
 async function interactiveSetup(pi: ExtensionAPI, ctx: CommandContext): Promise<void> {
@@ -973,6 +1023,21 @@ function patchPathForCargo(): void {
 	}
 }
 
+/** After Determinate Nix install, add nix to PATH so subsequent installs work. */
+function patchPathForNix(): void {
+	const nixPaths = [
+		"/nix/var/nix/profiles/default/bin",
+		join(homedir(), ".nix-profile", "bin"),
+	];
+	const current = process.env.PATH ?? "";
+	const parts = current.split(":");
+	for (const nixBin of nixPaths) {
+		if (existsSync(nixBin) && !parts.includes(nixBin)) {
+			process.env.PATH = `${nixBin}:${process.env.PATH}`;
+		}
+	}
+}
+
 async function installDeps(ctx: CommandContext, deps: DepStatus[]): Promise<void> {
 	// Sort so prerequisites come first (e.g., cargo before mdserve)
 	const sorted = sortByRequires(deps);
@@ -1008,8 +1073,11 @@ async function installDeps(ctx: CommandContext, deps: DepStatus[]): Promise<void
 			(line) => ctx.ui.notify(line),
 		);
 
-		// Rustup installs to ~/.cargo/bin — patch PATH immediately so the rest
-		// of the install sequence (e.g. mdserve) can find cargo.
+		// Patch PATH immediately after installing bootstrapping deps so the rest
+		// of the install sequence can find them without a new shell.
+		if (dep.id === "nix" && exitCode === 0) {
+			patchPathForNix();
+		}
 		if (dep.id === "cargo" && exitCode === 0) {
 			patchPathForCargo();
 		}

package/extensions/cleave/index.ts

@@ -20,7 +20,7 @@ import { truncateTail, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize } from "
 import { Text } from "@styrene-lab/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { spawn, execFile } from "node:child_process";
-import { registerCleaveProc, deregisterCleaveProc, killCleaveProc, killAllCleaveSubprocesses } from "./subprocess-tracker.ts";
+import { registerCleaveProc, deregisterCleaveProc, killCleaveProc, killAllCleaveSubprocesses, cleanupOrphanedProcesses } from "./subprocess-tracker.ts";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { promisify } from "node:util";
@@ -1647,6 +1647,21 @@ export function createAssessStructuredExecutors(pi: ExtensionAPI, overrides?: As
 // ─── Extension ──────────────────────────────────────────────────────────────
 
 export default function cleaveExtension(pi: ExtensionAPI) {
+	// ── Guard: skip cleave in child processes ───────────────────────
+	// Cleave children are spawned with PI_CHILD=1. If we load cleave
+	// in children, they can spawn NESTED children — exponential process
+	// growth. Children should never invoke cleave tools.
+	if (process.env.PI_CHILD) return;
+
+	// ── Kill orphaned children from previous sessions ───────────────
+	// If a previous omegon session was killed (SIGKILL, crash, machine
+	// reboot), its detached children may still be alive. Clean them up
+	// before doing anything else.
+	const orphansKilled = cleanupOrphanedProcesses();
+	if (orphansKilled > 0) {
+		console.warn(`[cleave] killed ${orphansKilled} orphaned subprocess(es) from a previous session`);
+	}
+
 	// ── Initialize dashboard state ──────────────────────────────────
 	emitCleaveState(pi, "idle");
 

package/extensions/cleave/subprocess-tracker.ts

@@ -1,16 +1,113 @@
 /**
  * cleave/subprocess-tracker — Process registry for cleave subprocesses.
  *
- * Mirrors the extraction-v2 pattern: all spawned child processes are tracked
- * in a Set, killed by process group (SIGTERM to -pid), and cleaned up on
- * session_shutdown. Prevents orphaned `pi` processes when assessments time
- * out or sessions exit mid-dispatch.
+ * All spawned child processes are tracked in a Set and killed on:
+ *   1. Explicit call to killAllCleaveSubprocesses() (from session_shutdown)
+ *   2. process.on('exit') safety net (catches crashes, SIGTERM, SIGINT,
+ *      uncaught exceptions — anything session_shutdown misses)
+ *   3. PID file scan on startup (catches SIGKILL to parent, machine reboot
+ *      with processes still running)
+ *
+ * Children are spawned with `detached: true` so we can kill their entire
+ * process group via `kill(-pid)`. The downside: detached children survive
+ * parent death by default. The exit handler and PID file compensate for this.
  */
 
 import type { ChildProcess } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 const allCleaveProcs = new Set<ChildProcess>();
 
+// ── PID file ────────────────────────────────────────────────────────────────
+// Each parent process writes its tracked child PIDs to a temp file.
+// On startup, cleanupOrphanedProcesses() scans for files whose parent PID
+// is dead and kills the orphaned children.
+
+const PID_FILE_PREFIX = "omegon-cleave-";
+const PID_FILE_SUFFIX = ".pids";
+
+function pidFilePath(): string {
+	return join(tmpdir(), `${PID_FILE_PREFIX}${process.pid}${PID_FILE_SUFFIX}`);
+}
+
+/** Write current tracked PIDs to the PID file. */
+function syncPidFile(): void {
+	const pids = [...allCleaveProcs]
+		.map(p => p.pid)
+		.filter((pid): pid is number => pid !== undefined && pid > 0);
+	if (pids.length === 0) {
+		// No tracked children — remove the file
+		try { unlinkSync(pidFilePath()); } catch { /* ok */ }
+		return;
+	}
+	try {
+		writeFileSync(pidFilePath(), JSON.stringify({ parentPid: process.pid, childPids: pids }));
+	} catch { /* best effort */ }
+}
+
+/**
+ * Scan for PID files from dead parents and kill their orphaned children.
+ * Call this during extension initialization (before any new spawns).
+ * Returns the number of orphaned processes killed.
+ */
+export function cleanupOrphanedProcesses(): number {
+	let killed = 0;
+	try {
+		const dir = tmpdir();
+		const files = readdirSync(dir).filter(
+			f => f.startsWith(PID_FILE_PREFIX) && f.endsWith(PID_FILE_SUFFIX),
+		);
+		for (const file of files) {
+			const filepath = join(dir, file);
+			try {
+				const data = JSON.parse(readFileSync(filepath, "utf-8"));
+				const parentPid = data?.parentPid;
+
+				// Check if the parent that wrote this file is still alive
+				if (parentPid && parentPid !== process.pid) {
+					try {
+						process.kill(parentPid, 0); // signal 0 = existence check
+						continue; // Parent alive — not orphans, skip
+					} catch {
+						// Parent dead — these are orphans, kill them
+					}
+				} else if (parentPid === process.pid) {
+					// Our own file from a previous lifecycle (shouldn't happen), clean up
+					try { unlinkSync(filepath); } catch { /* ok */ }
+					continue;
+				}
+
+				const childPids = data?.childPids;
+				if (Array.isArray(childPids)) {
+					for (const pid of childPids) {
+						if (typeof pid !== "number" || pid <= 0) continue;
+						try {
+							// Kill the process group (detached children have their own group)
+							process.kill(-pid, "SIGKILL");
+							killed++;
+						} catch {
+							try {
+								process.kill(pid, "SIGKILL");
+								killed++;
+							} catch { /* already dead */ }
+						}
+					}
+				}
+				// Remove the stale PID file
+				try { unlinkSync(filepath); } catch { /* ok */ }
+			} catch {
+				// Malformed file — remove it
+				try { unlinkSync(filepath); } catch { /* ok */ }
+			}
+		}
+	} catch { /* best effort — tmpdir unreadable is non-fatal */ }
+	return killed;
+}
+
+// ── Core tracking ───────────────────────────────────────────────────────────
+
 /** Kill a single subprocess by process group, with fallback to direct kill. */
 export function killCleaveProc(proc: ChildProcess): void {
 	try {
@@ -20,14 +117,16 @@ export function killCleaveProc(proc: ChildProcess): void {
 	}
 }
 
-/** Add a subprocess to the tracked set. */
+/** Add a subprocess to the tracked set and update the PID file. */
 export function registerCleaveProc(proc: ChildProcess): void {
 	allCleaveProcs.add(proc);
+	syncPidFile();
 }
 
-/** Remove a subprocess from the tracked set. */
+/** Remove a subprocess from the tracked set and update the PID file. */
 export function deregisterCleaveProc(proc: ChildProcess): void {
 	allCleaveProcs.delete(proc);
+	syncPidFile();
 }
 
 /**
@@ -44,7 +143,7 @@ function forceKillCleaveProc(proc: ChildProcess): void {
 
 /**
  * Kill all tracked cleave subprocesses and clear the registry.
- * Sends SIGTERM immediately, then SIGKILL after 5 seconds to any survivors.
+ * Sends SIGTERM immediately, then SIGKILL after 2 seconds to any survivors.
  * Because cleave subprocesses are spawned with `detached: true`, they will
  * NOT receive SIGHUP when the parent exits — SIGKILL escalation is required.
  */
@@ -53,20 +152,54 @@ export function killAllCleaveSubprocesses(): void {
 	for (const proc of snapshot) {
 		killCleaveProc(proc);
 	}
-	// Escalate: SIGKILL after 5s for any process that ignored SIGTERM.
-	// The timer is unref'd so it does not keep the Node.js event loop alive.
+	// Escalate: SIGKILL after 2s for any process that ignored SIGTERM.
+	// NOT unref'd — we MUST keep the event loop alive long enough for this
+	// to fire, otherwise children may survive. 2s (not 5s) because at shutdown
+	// speed matters more than grace.
 	if (snapshot.length > 0) {
 		const escalation = setTimeout(() => {
 			for (const proc of snapshot) {
 				if (!proc.killed) forceKillCleaveProc(proc);
 			}
-		}, 5_000);
-		escalation.unref();
+		}, 2_000);
+		// Do NOT unref — this timer must fire even during shutdown.
+		// The previous implementation used .unref() which allowed the process
+		// to exit before SIGKILL was sent, leaving orphaned children alive.
+		void escalation;
 	}
 	allCleaveProcs.clear();
+	syncPidFile();
 }
 
 /** Number of currently tracked subprocesses (for diagnostics). */
 export function cleaveTrackedProcCount(): number {
 	return allCleaveProcs.size;
 }
+
+// ── Process exit safety net ─────────────────────────────────────────────────
+//
+// This is the critical fix for orphaned `pi` processes.
+//
+// `process.on('exit')` fires synchronously when the parent exits for ANY
+// reason: normal exit, uncaught exception, SIGTERM, SIGINT. It does NOT
+// fire on SIGKILL (which is why we also have the PID file mechanism).
+//
+// `process.kill()` is synchronous — safe to call inside an exit handler.
+// We send SIGKILL (not SIGTERM) because at this point the parent is dying
+// and we can't wait for graceful shutdown.
+//
+// This handler fires AFTER session_shutdown (which sends SIGTERM).
+// If children are already dead from SIGTERM, the SIGKILL throws ESRCH
+// and we catch it — no harm done.
+
+process.on("exit", () => {
+	for (const proc of allCleaveProcs) {
+		try {
+			if (proc.pid) process.kill(-proc.pid, "SIGKILL");
+		} catch {
+			try { proc.kill("SIGKILL"); } catch { /* already dead */ }
+		}
+	}
+	// Clean up PID file — no orphans to track if we killed everything
+	try { unlinkSync(pidFilePath()); } catch { /* ok */ }
+});

package/extensions/clipboard-diag/index.ts

@@ -0,0 +1,64 @@
+/**
+ * clipboard-diag — Diagnostic command for clipboard image paste.
+ *
+ * Registers /cliptest to diagnose why Ctrl+V image paste may fail.
+ */
+import type { ExtensionAPI } from "../../vendor/pi-mono/packages/coding-agent/src/core/extensions/types.js";
+
+export default function clipboardDiag(pi: ExtensionAPI) {
+	pi.registerCommand("cliptest", {
+		description: "Test clipboard image access (diagnostic)",
+		async handler() {
+			const lines: string[] = ["**Clipboard Image Diagnostic**", ""];
+
+			// 1. Check native module
+			let clipModule: string | null = null;
+			let clipboard: { hasImage: () => boolean; getImageBinary: () => Promise<unknown> } | null = null;
+			const candidates = ["@cwilson613/clipboard", "@mariozechner/clipboard"];
+			for (const name of candidates) {
+				try {
+					// eslint-disable-next-line @typescript-eslint/no-require-imports
+					const mod = require(name);
+					clipboard = mod;
+					clipModule = name;
+					break;
+				} catch {
+					// next
+				}
+			}
+
+			if (!clipboard) {
+				lines.push("❌ No clipboard native module found");
+				lines.push(`   Tried: ${candidates.join(", ")}`);
+			} else {
+				lines.push(`✓ Module: ${clipModule}`);
+
+				// 2. Check hasImage
+				try {
+					const has = clipboard.hasImage();
+					lines.push(`${has ? "✓" : "❌"} hasImage(): ${has}`);
+
+					// 3. Try reading
+					if (has) {
+						try {
+							const data = await clipboard.getImageBinary();
+							const len = Array.isArray(data) ? data.length : (data as Uint8Array)?.length ?? 0;
+							lines.push(`${len > 0 ? "✓" : "❌"} getImageBinary(): ${len} bytes`);
+						} catch (e) {
+							lines.push(`❌ getImageBinary() threw: ${e instanceof Error ? e.message : String(e)}`);
+						}
+					}
+				} catch (e) {
+					lines.push(`❌ hasImage() threw: ${e instanceof Error ? e.message : String(e)}`);
+				}
+			}
+
+			// 4. Platform info
+			lines.push("");
+			lines.push(`Platform: ${process.platform}, TERM: ${process.env.TERM ?? "unset"}`);
+			lines.push(`DISPLAY: ${process.env.DISPLAY ?? "unset"}, WAYLAND: ${process.env.WAYLAND_DISPLAY ?? "unset"}`);
+
+			pi.sendMessage({ customType: "view", content: lines.join("\n"), display: true });
+		},
+	});
+}

package/extensions/project-memory/factstore.ts

@@ -258,7 +258,7 @@ export class FactStore {
     fs.mkdirSync(memoryDir, { recursive: true });
     this.db = new Database(this.dbPath);
     this.db.pragma("journal_mode = WAL");
-    this.db.pragma("busy_timeout = 5000");
+    this.db.pragma("busy_timeout = 10000");
     this.db.pragma("foreign_keys = ON");
     this.initSchema();
     this.runMigrations();

package/extensions/project-memory/lifecycle.ts

@@ -304,9 +304,10 @@ export function ingestLifecycleCandidatesBatch(
     factIds: [],
   };
   
-  // Use transaction for batch processing
-  const tx = (store as any).db.transaction(() => {
-    for (const candidate of candidates) {
+  // Process candidates individually (no batch transaction) to minimize write-lock
+  // hold time and avoid SQLITE_BUSY when concurrent processes share the DB.
+  for (const candidate of candidates) {
+    try {
       const candidateResult = ingestLifecycleCandidate(store, mind, candidate);
       
       if (candidateResult.autoStored) {
@@ -323,9 +324,17 @@ export function ingestLifecycleCandidatesBatch(
       } else {
         result.rejected++;
       }
+    } catch (err: any) {
+      // SQLITE_BUSY: another process holds the write lock. Skip this candidate
+      // rather than failing the entire batch — it will be re-extracted next cycle.
+      if (err?.code === "SQLITE_BUSY") {
+        result.rejected++;
+        console.warn(`[project-memory] lifecycle ingest skipped (DB busy): ${candidate.content.slice(0, 60)}`);
+      } else {
+        throw err; // Re-throw non-contention errors
+      }
     }
-  });
+  }
   
-  tx();
   return result;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "omegon",
-	"version": "0.6.10",
+	"version": "0.6.13",
 	"description": "Omegon — an opinionated distribution of pi (by Mario Zechner) with extensions for lifecycle management, memory, orchestration, and visualization",
 	"bin": {
 		"omegon": "bin/omegon.mjs",
@@ -73,13 +73,17 @@
 			"./extensions/tool-profile",
 			"./extensions/vault",
 			"./extensions/version-check.ts",
-			"./extensions/web-ui"
+			"./extensions/web-ui",
+			"./extensions/clipboard-diag/index.ts"
 		],
 		"skills": [
 			"./skills"
 		],
 		"prompts": [
 			"./prompts"
+		],
+		"themes": [
+			"./themes"
 		]
 	},
 	"dependencies": {