omegon 0.6.3 → 0.6.4

package/extensions/bootstrap/index.ts

@@ -10,7 +10,7 @@
  *   /bootstrap          — Run interactive setup (install missing deps + profile)
  *   /bootstrap status   — Show dependency checklist without installing
  *   /bootstrap install  — Install all missing core + recommended deps
- *   /update-pi          — Update pi binary to latest @cwilson613/pi-coding-agent release
+ *   /update-pi          — Update pi binary to latest @styrene-lab/pi-coding-agent release
  *   /update-pi --dry-run — Check for update without installing
  *
  * Guards:
@@ -20,10 +20,10 @@
  */
 
 import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { homedir, tmpdir } from "node:os";
-import type { ExtensionAPI } from "@cwilson613/pi-coding-agent";
+import type { ExtensionAPI } from "@styrene-lab/pi-coding-agent";
 import { checkAllProviders, type AuthResult } from "../01-auth/auth.ts";
 import { loadPiConfig } from "../lib/model-preferences.ts";
 import {
@@ -33,7 +33,7 @@ import {
 	type OperatorCapabilityProfile,
 	type OperatorProfileCandidate,
 } from "../lib/operator-profile.ts";
-import { sharedState } from "../shared-state.ts";
+import { sharedState } from "../lib/shared-state.ts";
 import { getDefaultPolicy, type ProviderRoutingPolicy } from "../lib/model-routing.ts";
 import { DEPS, checkAll, formatReport, bestInstallCmd, sortByRequires, type DepStatus, type DepTier } from "./deps.ts";
 
@@ -313,6 +313,9 @@ export default function (pi: ExtensionAPI) {
 		if (!isFirstRun()) return;
 		if (!ctx.hasUI) return;
 
+		// Signal other extensions to suppress redundant "no providers" warnings
+		sharedState.bootstrapPending = true;
+
 		const statuses = checkAll();
 		const missing = statuses.filter((s) => !s.available);
 		const needsProfile = needsOperatorProfileSetup(getConfigRoot(ctx));
@@ -376,124 +379,316 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	// --- /update-pi: update the pi binary from the cwilson613 fork ---
-	// Pulls the latest @cwilson613/pi-coding-agent from npm and relaunches.
-	// Useful after a new patch is published without leaving pi.
-	pi.registerCommand("update-pi", {
-		description: "Update the pi binary to the latest @cwilson613/pi-coding-agent release",
+	// --- /update: unified update command ---
+	// Detects dev vs installed mode and runs the appropriate lifecycle:
+	//   Dev mode  (.git exists): pull → submodule sync → build → dependency refresh → relink → verify → restart handoff
+	//   Installed (no .git):     npm install -g omegon@latest → verify → restart handoff
+	// Replaces the old split update mental model with a singular-package lifecycle.
+	pi.registerCommand("update", {
+		description: "Run the authoritative Omegon update lifecycle, then hand off to restart",
 		handler: async (args, ctx) => {
 			const dryRun = args.trim() === "--dry-run";
-			const PKG = "@cwilson613/pi-coding-agent";
-
-			// Resolve the npm registry latest
-			ctx.ui.notify(`Checking latest version of ${PKG}…`, "info");
-			let latestVersion: string;
-			try {
-				latestVersion = await new Promise<string>((resolve, reject) => {
-					let out = "";
-					const child = spawn("npm", ["view", PKG, "version", "--json"], {
-						stdio: ["ignore", "pipe", "pipe"],
-					});
-					child.stdout.on("data", (d: Buffer) => { out += d.toString(); });
-					child.on("close", (code: number) => {
-						if (code !== 0) return reject(new Error("npm view failed"));
-						resolve(JSON.parse(out.trim()));
-					});
-				});
-			} catch {
-				ctx.ui.notify(`Failed to query npm registry. Are you online?`, "warning");
-				return;
-			}
+			const omegonRoot = process.env.PI_CODING_AGENT_DIR ?? join(import.meta.dirname ?? ".", "..");
+			const isDevMode = existsSync(join(omegonRoot, ".git"));
 
-			// Determine installed version
-			let installedVersion = "unknown";
-			try {
-				installedVersion = await new Promise<string>((resolve) => {
-					let out = "";
-					const child = spawn("npm", ["list", "-g", PKG, "--json", "--depth=0"], {
-						stdio: ["ignore", "pipe", "pipe"],
-					});
-					child.stdout.on("data", (d: Buffer) => { out += d.toString(); });
-					child.on("close", () => {
-						try {
-							const data = JSON.parse(out);
-							resolve(data.dependencies?.[PKG]?.version ?? "unknown");
-						} catch {
-							resolve("unknown");
-						}
-					});
-				});
-			} catch { /* ignore */ }
-
-			if (installedVersion === latestVersion) {
-				ctx.ui.notify(`Already on latest: ${PKG}@${latestVersion} ✅`, "info");
-				return;
+			if (isDevMode) {
+				await updateDevMode(omegonRoot, dryRun, ctx);
+			} else {
+				await updateInstalledMode(dryRun, ctx);
 			}
-
-			ctx.ui.notify(
-				`Update available: ${installedVersion} → ${latestVersion}\n` +
-				(dryRun ? "(dry run — not installing)" : "Installing…"),
-				"info"
-			);
-
-			if (dryRun) return;
-
-			const confirmed = await ctx.ui.confirm(
-				"Update pi binary?",
-				`Install ${PKG}@${latestVersion} globally via npm?\n\nThis will replace the currently running binary. Restart pi after the update completes.`
-			);
-			if (!confirmed) {
-				ctx.ui.notify("Update cancelled.", "info");
-				return;
-			}
-
-			await new Promise<void>((resolve, reject) => {
-				let stderr = "";
-				const child = spawn("npm", ["install", "-g", `${PKG}@${latestVersion}`], {
-					stdio: ["ignore", "pipe", "pipe"],
-				});
-				child.stderr.on("data", (d: Buffer) => { stderr += d.toString(); });
-				child.on("close", (code: number) => {
-					if (code !== 0) {
-						ctx.ui.notify(`npm install failed:\n${stderr}`, "warning");
-						reject(new Error("install failed"));
-					} else {
-						resolve();
-					}
-				});
-			}).catch(() => { /* error already notified */ return; });
-
-			ctx.ui.notify(
-				`✅ Updated to ${PKG}@${latestVersion}.\n` +
-				"Restart pi to use the new version (/exit, then pi).",
-				"info"
-			);
 		},
 	});
 
-	// --- /refresh: clear jiti transpilation cache + reload ---
-	// jiti's fs cache uses path-based hashing, so source changes aren't
-	// detected on /reload. /refresh clears the cache first.
+	// --- /refresh: lightweight cache clear + reload only ---
 	pi.registerCommand("refresh", {
-		description: "Clear transpilation cache and reload extensions",
+		description: "Clear transpilation cache and reload extensions without package/runtime mutation",
 		handler: async (_args, ctx) => {
-			const jitiCacheDir = join(tmpdir(), "jiti");
-			let cleared = 0;
-			if (existsSync(jitiCacheDir)) {
-				try {
-					const files = readdirSync(jitiCacheDir);
-					cleared = files.length;
-					rmSync(jitiCacheDir, { recursive: true, force: true });
-				} catch { /* best-effort */ }
-			}
-			ctx.ui.notify(cleared > 0
-				? `Cleared ${cleared} cached transpilations. Reloading…`
-				: "No transpilation cache found. Reloading…", "info");
+			clearJitiCache(ctx);
 			await ctx.reload();
 		},
 	});
 }
 
+// ── /update helpers ──────────────────────────────────────────────────────
+
+/** Run a command, collect stdout+stderr, resolve with exit code. */
+function run(
+	cmd: string, args: string[], opts?: { cwd?: string },
+): Promise<{ code: number; stdout: string; stderr: string }> {
+	return new Promise((resolve) => {
+		let stdout = "", stderr = "";
+		const child = spawn(cmd, args, { cwd: opts?.cwd, stdio: ["ignore", "pipe", "pipe"] });
+		child.stdout.on("data", (d: Buffer) => { stdout += d.toString(); });
+		child.stderr.on("data", (d: Buffer) => { stderr += d.toString(); });
+		child.on("close", (code: number) => resolve({ code: code ?? 1, stdout, stderr }));
+	});
+}
+
+/** Clear jiti transpilation cache. Returns count of cleared entries. */
+function clearJitiCache(_ctx?: unknown): number {
+	const jitiCacheDir = join(tmpdir(), "jiti");
+	let cleared = 0;
+	if (existsSync(jitiCacheDir)) {
+		try {
+			cleared = readdirSync(jitiCacheDir).length;
+			rmSync(jitiCacheDir, { recursive: true, force: true });
+		} catch { /* best-effort */ }
+	}
+	return cleared;
+}
+
+export interface PiResolutionInfo {
+	omegonRoot: string;
+	cli: string;
+	resolutionMode: "vendor" | "npm";
+	agentDir: string;
+}
+
+export interface OmegonBinaryVerification {
+	ok: boolean;
+	executableName: string;
+	executablePath: string;
+	realExecutablePath: string;
+	resolution?: PiResolutionInfo;
+	reason?: string;
+}
+
+export function normalizeExecutablePath(executablePath: string): string {
+	if (!executablePath) return "";
+	try {
+		return realpathSync(executablePath);
+	} catch {
+		return executablePath;
+	}
+}
+
+async function getActiveExecutablePath(executableName = "omegon"): Promise<string> {
+	const which = await run("which", [executableName]);
+	return which.code === 0 ? which.stdout.trim() : "";
+}
+
+export function validateOmegonBinaryVerification(
+	executableName: string,
+	executablePath: string,
+	realExecutablePath: string,
+	resolution: PiResolutionInfo,
+): OmegonBinaryVerification {
+	const binaryLooksOwnedByOmegon = /[\\/]omegon[\\/]/.test(realExecutablePath) || /[\\/]omegon[\\/]bin[\\/](?:omegon|pi)(?:\.mjs)?$/.test(realExecutablePath);
+	if (!/omegon(?:[\\/]|$)/.test(resolution.omegonRoot)) {
+		return { ok: false, executableName, executablePath, realExecutablePath, resolution, reason: `active ${executableName} resolved to non-Omegon root: ${resolution.omegonRoot}` };
+	}
+	if (!binaryLooksOwnedByOmegon) {
+		return { ok: false, executableName, executablePath, realExecutablePath, resolution, reason: `active ${executableName} symlink target does not appear to point at Omegon: ${realExecutablePath}` };
+	}
+	return { ok: true, executableName, executablePath, realExecutablePath, resolution };
+}
+
+async function inspectActiveOmegonBinary(): Promise<OmegonBinaryVerification> {
+	const executableName = "omegon";
+	const executablePath = await getActiveExecutablePath(executableName);
+	if (!executablePath) {
+		return { ok: false, executableName, executablePath: "", realExecutablePath: "", reason: "`omegon` command not found on PATH" };
+	}
+	const realExecutablePath = normalizeExecutablePath(executablePath);
+	const probe = await run(executablePath, ["--where"]);
+	if (probe.code !== 0) {
+		return { ok: false, executableName, executablePath, realExecutablePath, reason: "active omegon binary did not return Omegon resolution metadata" };
+	}
+	try {
+		const resolution = JSON.parse(probe.stdout.trim()) as PiResolutionInfo;
+		return validateOmegonBinaryVerification(executableName, executablePath, realExecutablePath, resolution);
+	} catch {
+		return { ok: false, executableName, executablePath, realExecutablePath, reason: "active omegon returned invalid verification metadata" };
+	}
+}
+
+function formatVerification(verification: OmegonBinaryVerification): string {
+	if (!verification.ok || !verification.resolution) {
+		return `✗ omegon target verification failed${verification.reason ? `: ${verification.reason}` : ""}`;
+	}
+	return [
+		`✓ active ${verification.executableName}: ${verification.executablePath}`,
+		`✓ binary target: ${verification.realExecutablePath}`,
+		`✓ runtime root: ${verification.resolution.omegonRoot}`,
+		`✓ core resolution: ${verification.resolution.resolutionMode} (${verification.resolution.cli})`,
+	].join("\n");
+}
+
+/** Dev mode: git pull → submodule update → build → install deps → relink → verify → restart handoff. */
+async function updateDevMode(
+	omegonRoot: string,
+	dryRun: boolean,
+	ctx: { ui: { notify: (message: string, type?: "error" | "warning" | "info") => void } },
+): Promise<void> {
+	const steps: string[] = [];
+
+	// ── Step 1: git pull omegon ──────────────────────────────────────
+	ctx.ui.notify("▸ Pulling omegon…", "info");
+	const pull = await run("git", ["pull", "--ff-only"], { cwd: omegonRoot });
+	if (pull.code !== 0) {
+		// Non-ff merge needed — not fatal, just skip
+		const msg = pull.stderr.includes("fatal")
+			? `git pull failed: ${pull.stderr.trim().split("\n")[0]}`
+			: "git pull: non-fast-forward — skipping (merge manually if needed)";
+		steps.push(`⚠ ${msg}`);
+	} else {
+		const summary = pull.stdout.trim().split("\n").pop() ?? "";
+		const upToDate = pull.stdout.includes("Already up to date");
+		steps.push(upToDate ? "✓ omegon: already up to date" : `✓ omegon: ${summary}`);
+	}
+
+	// ── Step 2: update submodule (pi-mono fork) ──────────────────────
+	ctx.ui.notify("▸ Updating pi-mono submodule…", "info");
+	const sub = await run(
+		"git", ["submodule", "update", "--init", "--recursive"],
+		{ cwd: omegonRoot },
+	);
+	if (sub.code !== 0) {
+		steps.push(`⚠ submodule update failed: ${sub.stderr.trim().split("\n")[0]}`);
+	} else {
+		steps.push("✓ pi-mono submodule synced");
+	}
+
+	// ── Step 3: build pi-mono ────────────────────────────────────────
+	if (dryRun) {
+		steps.push("· build: skipped (dry run)");
+	} else {
+		ctx.ui.notify("▸ Building pi-mono…", "info");
+		const piMonoRoot = join(omegonRoot, "vendor/pi-mono");
+		const build = await run("npm", ["run", "build"], { cwd: piMonoRoot });
+		if (build.code !== 0) {
+			const errLine = build.stderr.trim().split("\n").filter(l => !l.startsWith("npm warn")).pop() ?? "unknown error";
+			steps.push(`✗ build failed: ${errLine}`);
+			ctx.ui.notify(`Update incomplete:\n${steps.join("\n")}`, "warning");
+			return;
+		}
+		steps.push("✓ pi-mono built");
+	}
+
+	// ── Step 4: npm install (pick up any new deps) ───────────────────
+	if (dryRun) {
+		steps.push("· npm install: skipped (dry run)");
+	} else {
+		ctx.ui.notify("▸ Refreshing omegon dependencies…", "info");
+		const inst = await run("npm", ["install", "--install-links=false"], { cwd: omegonRoot });
+		if (inst.code !== 0) {
+			steps.push(`⚠ npm install had issues (non-fatal)`);
+		} else {
+			steps.push("✓ omegon dependencies refreshed");
+		}
+	}
+
+	// ── Step 5: relink omegon globally ───────────────────────────────
+	if (dryRun) {
+		steps.push("· npm link --force: skipped (dry run)");
+	} else {
+		ctx.ui.notify("▸ Relinking omegon globally…", "info");
+		const link = await run("npm", ["link", "--force"], { cwd: omegonRoot });
+		if (link.code !== 0) {
+			steps.push(`✗ npm link failed: ${(link.stderr.trim().split("\n").filter((l) => !l.startsWith("npm warn")).pop() ?? "unknown error")}`);
+			ctx.ui.notify(`Update incomplete:\n${steps.join("\n")}`, "warning");
+			return;
+		}
+		steps.push("✓ omegon relinked globally");
+	}
+
+	// ── Step 6: verify active binary target ──────────────────────────
+	if (dryRun) {
+		steps.push("· omegon target verification: skipped (dry run)");
+		ctx.ui.notify(`Dry run:\n${steps.join("\n")}`, "info");
+		return;
+	}
+	const verification = await inspectActiveOmegonBinary();
+	if (!verification.ok) {
+		steps.push(formatVerification(verification));
+		ctx.ui.notify(`Update incomplete:\n${steps.join("\n")}`, "warning");
+		return;
+	}
+	steps.push(formatVerification(verification));
+
+	// ── Step 7: clear cache + explicit restart handoff ───────────────
+	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");
+	ctx.ui.notify(steps.join("\n"), "info");
+}
+
+/** Installed mode: npm install -g omegon@latest → verify → cache clear → restart handoff. */
+async function updateInstalledMode(
+	dryRun: boolean,
+	ctx: {
+		ui: {
+			notify: (message: string, type?: "error" | "warning" | "info") => void;
+			confirm: (title: string, message: string) => Promise<boolean>;
+		};
+	},
+): Promise<void> {
+	const PKG = "omegon";
+
+	// Check latest version on npm
+	ctx.ui.notify(`Checking latest version of ${PKG}…`, "info");
+	const view = await run("npm", ["view", PKG, "version", "--json"]);
+	if (view.code !== 0) {
+		ctx.ui.notify("Failed to query npm registry. Are you online?", "warning");
+		return;
+	}
+	const latestVersion = JSON.parse(view.stdout.trim());
+
+	// Determine installed version
+	const list = await run("npm", ["list", "-g", PKG, "--json", "--depth=0"]);
+	let installedVersion = "unknown";
+	try {
+		const data = JSON.parse(list.stdout);
+		installedVersion = data.dependencies?.[PKG]?.version ?? "unknown";
+	} catch { /* ignore */ }
+
+	if (installedVersion === latestVersion) {
+		ctx.ui.notify(`Already on latest: ${PKG}@${latestVersion} ✅`, "info");
+		return;
+	}
+
+	ctx.ui.notify(
+		`Update available: ${installedVersion} → ${latestVersion}` +
+		(dryRun ? "\n(dry run — not installing)" : ""),
+		"info"
+	);
+	if (dryRun) return;
+
+	const confirmed = await ctx.ui.confirm(
+		"Update omegon?",
+		`Install ${PKG}@${latestVersion} globally via npm?\n\nThis will update Omegon, its bundled agent core, extensions, themes, and skills.\nRestart Omegon after the update completes.`,
+	);
+	if (!confirmed) {
+		ctx.ui.notify("Update cancelled.", "info");
+		return;
+	}
+
+	ctx.ui.notify("Installing…", "info");
+	const inst = await run("npm", ["install", "-g", `${PKG}@${latestVersion}`]);
+	if (inst.code !== 0) {
+		ctx.ui.notify(`npm install failed:\n${inst.stderr}`, "warning");
+		return;
+	}
+
+	const verification = await inspectActiveOmegonBinary();
+	if (!verification.ok) {
+		ctx.ui.notify(
+			`Updated to ${PKG}@${latestVersion}, but post-install verification failed.\n${formatVerification(verification)}\nResolve the Omegon binary target before restarting Omegon.`,
+			"warning",
+		);
+		return;
+	}
+
+	const cleared = clearJitiCache(ctx);
+	ctx.ui.notify(
+		`✅ Updated to ${PKG}@${latestVersion}.` +
+		`\n${formatVerification(verification)}` +
+		(cleared > 0 ? `\nCleared ${cleared} cached transpilations.` : "") +
+		"\nRestart Omegon to use the new version (/exit, then omegon).",
+		"info"
+	);
+}
+
 async function interactiveSetup(pi: ExtensionAPI, ctx: CommandContext): Promise<void> {
 	const statuses = checkAll();
 	const missing = statuses.filter((s) => !s.available);
@@ -544,14 +739,35 @@ async function interactiveSetup(pi: ExtensionAPI, ctx: CommandContext): Promise<
 		);
 	}
 
+	// API key guidance — check if any cloud provider is configured
+	const providerReadiness = await checkAllProviders(pi);
+	const hasAnyCloudKey = providerReadiness.some(
+		(r: AuthResult) => r.status === "ok" && r.provider !== "local",
+	);
+	if (!hasAnyCloudKey) {
+		ctx.ui.notify(
+			"\n🔑 **No cloud API keys detected.**\n" +
+			"Omegon needs at least one provider key to function. The fastest options:\n" +
+			"  • Anthropic: `/secrets configure ANTHROPIC_API_KEY` (get key at console.anthropic.com)\n" +
+			"  • OpenAI: `/secrets configure OPENAI_API_KEY` (get key at platform.openai.com)\n" +
+			"  • GitHub Copilot: `/login github` (requires Copilot subscription)\n",
+			"warning"
+		);
+	}
+
 	await ensureOperatorProfile(pi, ctx);
 
 	const recheck = checkAll();
 	const stillMissing = recheck.filter((s) => !s.available && (s.dep.tier === "core" || s.dep.tier === "recommended"));
 
-	if (stillMissing.length === 0) {
+	if (stillMissing.length === 0 && hasAnyCloudKey) {
 		ctx.ui.notify("\n🎉 Setup complete! All core and recommended dependencies are available.");
 		markDone();
+	} else if (stillMissing.length === 0) {
+		ctx.ui.notify(
+			"\n✅ Dependencies installed. Configure an API key (see above) to start using Omegon.",
+		);
+		markDone();
 	} else {
 		ctx.ui.notify(
 			`\n⚠️  ${stillMissing.length} dep${stillMissing.length > 1 ? "s" : ""} still missing. `

package/extensions/chronos/index.ts

@@ -13,7 +13,7 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { StringEnum } from "../lib/typebox-helpers";
-import type { ExtensionAPI } from "@cwilson613/pi-coding-agent";
+import type { ExtensionAPI } from "@styrene-lab/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
 
 const CHRONOS_SH = join(import.meta.dirname ?? __dirname, "chronos.sh");

package/extensions/cleave/dispatcher.ts

@@ -19,13 +19,13 @@
 import { spawn } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import type { ExtensionAPI } from "@cwilson613/pi-coding-agent";
-import { DASHBOARD_UPDATE_EVENT, sharedState } from "../shared-state.ts";
+import type { ExtensionAPI } from "@styrene-lab/pi-coding-agent";
+import { DASHBOARD_UPDATE_EVENT, sharedState } from "../lib/shared-state.ts";
 import type { ChildState, CleaveState, ModelTier } from "./types.ts";
 import { computeDispatchWaves } from "./planner.ts";
 import { executeWithReview, type ReviewConfig, type ReviewExecutor, DEFAULT_REVIEW_CONFIG } from "./review.ts";
 import { saveState } from "./workspace.ts";
-import { resolveTier, getDefaultPolicy, type ProviderRoutingPolicy, type RegistryModel } from "../lib/model-routing.ts";
+import { resolveTier, getDefaultPolicy, getViableModels, type ProviderRoutingPolicy, type RegistryModel } from "../lib/model-routing.ts";
 
 // ─── Large-run threshold ────────────────────────────────────────────────────
 
@@ -678,14 +678,14 @@ async function dispatchSingleChild(
 	try {
 		const registry = (pi as any).modelRegistry;
 		if (registry != null) {
-			registryModels = registry.getAll();
+			registryModels = getViableModels(registry);
 		}
 		// If modelRegistry is absent (e.g. test environment), registryModels stays []
 		// and resolveTier will use policy-based fallbacks.
 	} catch (err) {
-		// getAll() threw — log and continue with empty registry so resolver can still
+		// getViableModels() threw — log and continue with empty registry so resolver can still
 		// apply policy-based fallbacks rather than silently passing no --model flag.
-		console.warn("[cleave] modelRegistry.getAll() threw:", err);
+		console.warn("[cleave] getViableModels() threw:", err);
 	}
 	const modelFlag = resolveModelIdForTier(effectiveTier, registryModels, activePolicy, localModel);
 	child.backend = child.executeModel === "local" ? "local" : "cloud";

package/extensions/cleave/index.ts

@@ -14,18 +14,18 @@
  * The Claude Code SDK calls are replaced with pi's extension API.
  */
 
-import type { ExtensionAPI, ExtensionCommandContext, AgentToolUpdateCallback } from "@cwilson613/pi-coding-agent";
-import { truncateTail, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize } from "@cwilson613/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext, AgentToolUpdateCallback } from "@styrene-lab/pi-coding-agent";
+import { truncateTail, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize } from "@styrene-lab/pi-coding-agent";
 
-import { Text } from "@cwilson613/pi-tui";
+import { Text } from "@styrene-lab/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { spawn, execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { createHash } from "node:crypto";
 
-import { sharedState, DASHBOARD_UPDATE_EVENT } from "../shared-state.ts";
-import { sciCall, sciOk, sciErr, sciExpanded } from "../sci-ui.ts";
-import { debug } from "../debug.ts";
+import { sharedState, DASHBOARD_UPDATE_EVENT } from "../lib/shared-state.ts";
+import { sciCall, sciOk, sciErr, sciExpanded } from "../lib/sci-ui.ts";
+import { debug } from "../lib/debug.ts";
 import { emitOpenSpecState } from "../openspec/dashboard-state.ts";
 import { getSharedBridge, buildSlashCommandResult } from "../lib/slash-command-bridge.ts";
 import { buildAssessBridgeResult } from "./bridge.ts";

package/extensions/cleave/planner.ts

@@ -9,7 +9,7 @@
  * a JSON split strategy with 2-4 children.
  */
 
-import type { ExtensionAPI } from "@cwilson613/pi-coding-agent";
+import type { ExtensionAPI } from "@styrene-lab/pi-coding-agent";
 import type { ChildPlan, SplitPlan } from "./types.ts";
 
 /**

package/extensions/cleave/worktree.ts

@@ -9,7 +9,7 @@
 import { mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import type { ExtensionAPI } from "@cwilson613/pi-coding-agent";
+import type { ExtensionAPI } from "@styrene-lab/pi-coding-agent";
 
 /** Base directory for cleave worktrees. */
 const WORKTREE_HOME = join(homedir(), ".pi", "cleave", "wt");