omegon 0.6.0

package/extensions/session-log.ts

@@ -0,0 +1,174 @@
+/**
+ * session-log — Append-only session tracking
+ *
+ * Registers `/session-log` command that appends a structured entry to
+ * the .session_log file in the repository root (or reads existing entries).
+ *
+ * Subcommands:
+ *   /session-log           — Generate and append a new entry for this session
+ *   /session-log read      — Show recent entries
+ *   /session-log read <n>  — Show last n entries
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join, basename } from "node:path";
+import type { ExtensionAPI } from "@cwilson613/pi-coding-agent";
+
+const SESSION_LOG_HEADER = `# Session Log
+
+Append-only record of development sessions. Read recent entries for context.
+`;
+
+export default function sessionLogExtension(pi: ExtensionAPI) {
+
+	// ------------------------------------------------------------------
+	// Auto-read session log on session start for context
+	// ------------------------------------------------------------------
+	pi.on("session_start", async (_event, ctx) => {
+		const logPath = join(ctx.cwd, ".session_log");
+		if (existsSync(logPath)) {
+			try {
+				const content = readFileSync(logPath, "utf-8");
+				const lines = content.split("\n");
+				// Show last ~80 lines as context (lightweight, non-intrusive)
+				const tail = lines.slice(-80).join("\n").trim();
+				if (tail) {
+					// Inject as a context message so the LLM knows recent history
+					pi.sendMessage({
+						customType: "session-log-context",
+						content: `Recent .session_log entries (last 80 lines):\n\n${tail}`,
+						display: false,  // Don't clutter the user's display
+					}, { deliverAs: "nextTurn" });
+				}
+			} catch { /* ignore read errors */ }
+		}
+	});
+
+	// ------------------------------------------------------------------
+	// /session-log command
+	// ------------------------------------------------------------------
+	pi.registerCommand("session-log", {
+		description: "Append or read .session_log entries (usage: /session-log [read [n]])",
+		getArgumentCompletions: (prefix: string) => {
+			const items = [
+				{ value: "read", label: "read", description: "Show recent entries" },
+			];
+			const filtered = items.filter((i) => i.value.startsWith(prefix || ""));
+			return filtered.length > 0 ? filtered : null;
+		},
+		handler: async (args, ctx) => {
+			const trimmed = (args || "").trim();
+			const cwd = ctx.cwd;
+			const logPath = join(cwd, ".session_log");
+
+			// ----------------------------------------------------------
+			// /session-log read [n]
+			// ----------------------------------------------------------
+			if (trimmed.startsWith("read")) {
+				if (!existsSync(logPath)) {
+					pi.sendMessage({
+						customType: "view",
+						content: `No .session_log found at \`${logPath}\``,
+						display: true,
+					});
+					return;
+				}
+
+				const content = readFileSync(logPath, "utf-8");
+				const nArg = trimmed.replace(/^read\s*/, "").trim();
+				const n = nArg ? parseInt(nArg, 10) : 5;
+
+				// Split into entries by ## headings
+				const entries = content.split(/^(?=## \d{4}-\d{2}-\d{2})/m);
+				const header = entries[0]?.startsWith("#") && !entries[0]?.startsWith("## 2") ? entries.shift() : "";
+				const recent = entries.slice(-n);
+
+				if (recent.length === 0) {
+					pi.sendMessage({
+						customType: "view",
+						content: "No entries found in `.session_log`",
+						display: true,
+					});
+					return;
+				}
+
+				const display = recent.join("\n").trim();
+				pi.sendMessage({
+					customType: "view",
+					content: `**Recent .session_log entries** (${recent.length} of ${entries.length}):\n\n${display}`,
+					display: true,
+				});
+				return;
+			}
+
+			// ----------------------------------------------------------
+			// /session-log  (generate + append)
+			// ----------------------------------------------------------
+
+			// Get today's date
+			let today = new Date().toISOString().slice(0, 10);
+			try {
+				const dateResult = await pi.exec("date", ["+%Y-%m-%d"], { timeout: 3_000 });
+				today = dateResult.stdout.trim() || today;
+			} catch { /* use JS date */ }
+
+			// Get git info for context
+			let branch = "";
+			let recentCommits = "";
+			try {
+				const branchResult = await pi.exec("git", ["branch", "--show-current"], { timeout: 5_000, cwd });
+				branch = branchResult.stdout.trim();
+			} catch { /* ignore */ }
+			try {
+				const logResult = await pi.exec(
+					"git", ["log", "--oneline", "-5", "--no-decorate"],
+					{ timeout: 5_000, cwd },
+				);
+				recentCommits = logResult.stdout.trim();
+			} catch { /* ignore */ }
+
+			// Bootstrap .session_log if it doesn't exist
+			const logExists = existsSync(logPath);
+
+			// Build the prompt for the LLM to generate and append the entry
+			const prompt = [
+				`Analyze the conversation context and append a session log entry to \`${logPath}\`.`,
+				"",
+				logExists
+					? "The file already exists — append to the end."
+					: `The file does not exist yet. Create it with this header first:\n\n\`\`\`\n${SESSION_LOG_HEADER}\`\`\`\n\nThen append the entry.`,
+				"",
+				`**Today's date:** ${today}`,
+				branch ? `**Branch:** ${branch}` : "",
+				recentCommits ? `**Recent commits:**\n\`\`\`\n${recentCommits}\n\`\`\`` : "",
+				"",
+				"**Entry format** (use exactly this structure):",
+				"",
+				`\`\`\`markdown`,
+				`## ${today} — Brief Topic Title`,
+				"",
+				"### Context",
+				"One-line description of what prompted this session.",
+				"",
+				"### Completed",
+				"- Concise bullet points of what was accomplished",
+				"- Focus on outcomes, not process",
+				"",
+				"### Decisions",
+				"- Choices made and brief rationale",
+				"",
+				"### Open Threads",
+				"- Unfinished work for future sessions",
+				"- Known issues discovered",
+				"```",
+				"",
+				"**Guidelines:**",
+				"- Keep entries concise — they should trigger memory, not replace documentation",
+				"- Focus on outcomes, decisions, and open threads",
+				"- Do NOT overwrite or edit previous entries",
+			].filter(Boolean).join("\n");
+
+			pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+		},
+	});
+}

package/extensions/shared-state.ts

@@ -0,0 +1,146 @@
+/**
+ * Shared state between extensions loaded in the same pi process.
+ *
+ * Uses globalThis to guarantee sharing regardless of module loader
+ * caching behavior (jiti may create separate instances per extension).
+ *
+ * Keep this minimal — only data that genuinely needs cross-extension sharing.
+ */
+
+import type {
+  DesignTreeDashboardState,
+  OpenSpecDashboardState,
+  CleaveState,
+  RecoveryDashboardState,
+} from "./dashboard/types.ts";
+
+import type { EffortState } from "./effort/types.ts";
+import type { ProviderRoutingPolicy } from "./lib/model-routing.ts";
+import type { MemoryInjectionMetrics } from "./project-memory/injection-metrics.ts";
+import type { LifecycleMemoryMessage } from "./project-memory/types.ts";
+import { getDefaultPolicy } from "./lib/model-routing.ts";
+
+export type RecoveryFailureClassification =
+  | "transient_server_error"
+  | "rate_limited"
+  | "quota_exhausted"
+  | "authentication_failed"
+  | "malformed_output"
+  | "context_overflow"
+  | "invalid_request"
+  | "unknown_upstream";
+
+export type RecoveryDisposition =
+  | "retry_same_model"
+  | "cooldown_and_failover"
+  | "guidance_only"
+  | "handled_elsewhere"
+  | "escalate";
+
+export interface RecoveryEvent {
+  provider: string;
+  model: string;
+  turnIndex: number;
+  classification: RecoveryFailureClassification;
+  originalErrorSummary: string;
+  retryable: boolean;
+  disposition: RecoveryDisposition;
+  retryAttempted: boolean;
+  retryCount: number;
+  maxRetries: number;
+  guidance: string;
+  cooldownApplied?: boolean;
+  alternateCandidate?: {
+    provider: string;
+    model: string;
+  };
+  timestamp: number;
+}
+
+// Re-export dashboard types for consumer convenience
+export type {
+  DesignTreeDashboardState,
+  DesignTreeFocusedNode,
+  OpenSpecDashboardState,
+  OpenSpecChangeEntry,
+  CleaveState,
+  CleaveChildState,
+  CleaveStatus,
+  DashboardMode,
+  DashboardState,
+} from "./dashboard/types.ts";
+
+// Re-export routing types for consumer convenience
+export type { ProviderRoutingPolicy, ResolvedTierModel, ModelTier, ProviderName } from "./lib/model-routing.ts";
+
+// Re-export effort types for consumer convenience
+export type {
+  EffortState,
+  EffortConfig,
+  EffortLevel,
+  EffortModelTier,
+  EffortName,
+  ThinkingLevel,
+} from "./effort/types.ts";
+
+/** Event channel fired by producers after writing dashboard state. */
+export const DASHBOARD_UPDATE_EVENT = "dashboard:update" as const;
+
+const SHARED_KEY = Symbol.for("pi-kit-shared-state");
+
+interface SharedState {
+  /** Approximate token count of the last memory injection into context.
+   *  Written by project-memory, read by dashboard for the context gauge. */
+  memoryTokenEstimate: number;
+
+  /** Structured snapshot of the last memory injection payload. */
+  lastMemoryInjection?: MemoryInjectionMetrics;
+
+  /** Design tree summary state. Written by design-tree extension. */
+  designTree?: DesignTreeDashboardState;
+
+  /** OpenSpec changes summary. Written by openspec/cleave extension. */
+  openspec?: OpenSpecDashboardState;
+
+  /** Cleave execution state. Written by cleave extension. */
+  cleave?: CleaveState;
+
+  /** Effort tier state. Written by effort extension, read by model-budget and cleave. */
+  effort?: EffortState;
+
+  /** Session routing policy. Written by operator/preflight, read by cleave and model-budget. */
+  routingPolicy?: ProviderRoutingPolicy;
+
+  /** Pending structured lifecycle candidates waiting for project-memory ingestion. */
+  lifecycleCandidateQueue?: LifecycleMemoryMessage[];
+
+  /** Content prefixes of memory facts to archive (e.g. resolved open questions). */
+  factArchiveQueue?: string[];
+
+  /** Latest upstream recovery event for dashboard/harness visibility. */
+  latestRecoveryEvent?: RecoveryEvent;
+
+  /** Dashboard-friendly recovery summary derived from the latest recovery event. */
+  recovery?: RecoveryDashboardState;
+
+  /** Current dashboard display mode. Written by dashboard extension. */
+  dashboardMode?: string;
+
+  /** Number of conversation turns in the current session. Written by dashboard extension. */
+  dashboardTurns?: number;
+
+  /** Per-request retry ledger for bounded recovery decisions across core and extension-driven retries. */
+  recoveryRetryCounts?: Record<string, number>;
+}
+
+// Initialize once on first import, reuse thereafter via global symbol.
+// New dashboard properties are intentionally omitted — they start as undefined
+// and are populated when each producer extension loads.
+if (!(globalThis as any)[SHARED_KEY]) {
+  (globalThis as any)[SHARED_KEY] = {
+    memoryTokenEstimate: 0,
+    routingPolicy: getDefaultPolicy(),
+  } satisfies SharedState;
+}
+
+export const sharedState: SharedState = (globalThis as any)[SHARED_KEY];

package/extensions/spinner-verbs.ts

@@ -0,0 +1,91 @@
+import type { ExtensionAPI } from "@cwilson613/pi-coding-agent";
+
+const verbs = [
+  "Communing with the Machine Spirit",
+  "Appeasing the Omnissiah",
+  "Reciting the Litany of Ignition",
+  "Applying sacred unguents",
+  "Chanting binharic cant",
+  "Performing the Rite of Clear Mind",
+  "Querying the Noosphere",
+  "Invoking the Motive Force",
+  "Beseeching the Machine God",
+  "Parsing sacred data-stacks",
+  "Administering the Rite of Activation",
+  "Placating the logic engine",
+  "Consulting the Cult Mechanicus",
+  "Interfacing with the cogitator",
+  "Calibrating the mechadendrites",
+  "Burning sacred incense over the server",
+  "Whispering the Cant of Maintenance",
+  "Genuflecting before the datacron",
+  "Consulting the Oracle at Delphi",
+  "Reading the auguries",
+  "Descending into the labyrinth",
+  "Weaving on Athena's loom",
+  "Deciphering the Rosetta Stone",
+  "Consulting the Norns",
+  "Reading the runes",
+  "Forging on Hephaestus's anvil",
+  "Navigating the River Styx",
+  "Unraveling Ariadne's thread",
+  "Stealing fire from Olympus",
+  "Divining from the entrails",
+  "Reciting the Litany of Hate",
+  "Appeasing the Machine Spirit",
+  "Performing the Rite of Percussive Maintenance",
+  "Purging the heretical code",
+  "Suffering not the unclean merge to live",
+  "Deploying the Exterminatus on tech debt",
+  "Consulting the Codex Astartes",
+  "Exorcising the daemon process",
+  "Anointing the deployment manifest",
+  "Sanctifying the build pipeline",
+  "Cataloguing the STC fragments",
+  "Venerating the sacred repository",
+  "Decrypting the Archaeotech",
+  "Supplicating before the Altar of Technology",
+  "Conducting the Binary Psalm",
+  "Fortifying the firewall bastions",
+  "Interrogating the data-looms",
+  "Purifying the corrupted sectors",
+  "Awakening the dormant forge",
+  "Petitioning the Fabricator-General",
+  "Scourging the technical debt",
+  "Flagellating the failing tests",
+  "Martyring the deprecated functions",
+  "Crusading through the backlog",
+  "Performing battlefield triage on the codebase",
+  "Debugging with extreme prejudice",
+  "Servicing the servitors",
+  "Transcribing the sacred schematics",
+  "Committing the Holy Diff",
+  "Invoking the Emperor's Protection",
+  "Loading the bolter rounds",
+  "Administering the Sacred Oils",
+  "Propitiating the wrathful forge-spirit",
+  "Affixing the Purity Seal to the commit",
+  "Performing the Thirteen Rituals of Compilation",
+  "Routing the xenos from the dependency tree",
+  "Reconsecrating the tainted module",
+  "Imploring the Titan's logic core",
+  "Soothing the belligerent plasma coil",
+  "Undertaking the Pilgrimage to Holy Mars",
+  "Grafting the sacred augmetic",
+  "Offering a binary prayer to the void",
+  "Inscribing the litany upon the circuit board",
+];
+
+function randomVerb(): string {
+  return verbs[Math.floor(Math.random() * verbs.length)] + "...";
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.on("turn_start", async (_event, ctx) => {
+    ctx.ui.setWorkingMessage(randomVerb());
+  });
+
+  pi.on("tool_call", async (_event, ctx) => {
+    ctx.ui.setWorkingMessage(randomVerb());
+  });
+}

package/extensions/style.ts

@@ -0,0 +1,281 @@
+/**
+ * style — /style command for the Alpharius design system
+ *
+ * Registers `/style [subcommand]` as an interactive command.
+ * Subcommands: (none), palette, d2, excalidraw, check <file>
+ */
+
+import type { ExtensionAPI } from "@cwilson613/pi-coding-agent";
+
+// ---------------------------------------------------------------------------
+// Palette data — single source of truth
+// ---------------------------------------------------------------------------
+
+const CORE_PALETTE = {
+	primary:       "#2ab4c8",
+	primaryMuted:  "#1a8898",
+	primaryBright: "#6ecad8",
+	fg:            "#c4d8e4",
+	mutedFg:       "#607888",
+	dimFg:         "#344858",
+	bg:            "#06080e",
+	cardBg:        "#0e1622",
+	surfaceBg:     "#131e2e",
+	borderColor:   "#1a3448",
+	borderDim:     "#0e1e30",
+	syntaxType:    "#5aa8e0", // sky-blue, distinct from primary teal
+};
+
+const SIGNALS = {
+	green:  "#1ab878",
+	red:    "#c83030",
+	orange: "#c86418",
+	yellow: "#b89020",
+};
+
+const EXCALIDRAW_SEMANTICS: Record<string, { fill: string; stroke: string; use: string }> = {
+	primary:   { fill: "#1a4a6e", stroke: "#2ab4c8", use: "Default components, neutral nodes" },
+	secondary: { fill: "#1a3a5a", stroke: "#1a8898", use: "Supporting/related components" },
+	tertiary:  { fill: "#0e2a40", stroke: "#344858", use: "Third-level, background detail" },
+	start:     { fill: "#0e2e20", stroke: "#1ab878", use: "Entry points, triggers, inputs" },
+	end:       { fill: "#2e2010", stroke: "#b89020", use: "Outputs, completion, results" },
+	decision:  { fill: "#2a1010", stroke: "#c83030", use: "Conditionals, branches, choices" },
+	ai:        { fill: "#1a1040", stroke: "#6060c0", use: "AI/LLM components, inference" },
+	warning:   { fill: "#2a1808", stroke: "#c86418", use: "Warnings, degraded states" },
+	error:     { fill: "#2e0e0e", stroke: "#c83030", use: "Error states, failures" },
+	evidence:  { fill: "#06080e", stroke: "#1a3448", use: "Code snippets, data samples" },
+	inactive:  { fill: "#0e1622", stroke: "#344858", use: "Disabled, inactive, future-state" },
+};
+
+const D2_STYLE_TEMPLATE = `# Alpharius D2 style template — paste into your .d2 file
+
+# Primary component (ceramite blue-teal)
+component: Label {
+  style: {
+    fill: "#1a4a6e"
+    stroke: "#2ab4c8"
+    font-color: "#c4d8e4"
+    border-radius: 8
+  }
+}
+
+# Start / entry point (hydra green)
+entry: Trigger {
+  style: {
+    fill: "#0e2e20"
+    stroke: "#1ab878"
+    font-color: "#c4d8e4"
+  }
+}
+
+# End / output (brass gold)
+result: Output {
+  style: {
+    fill: "#2e2010"
+    stroke: "#b89020"
+    font-color: "#c4d8e4"
+  }
+}
+
+# Connection
+entry -> component -> result {
+  style: {
+    stroke: "#2ab4c8"
+    font-color: "#c4d8e4"
+  }
+}
+
+# Container
+group: Infrastructure {
+  style: {
+    fill: "#06080e"
+    stroke: "#1a3448"
+    font-color: "#6ecad8"
+  }
+}`;
+
+// Collect all known hex values for color auditing
+const ALL_TOKENS: Record<string, string> = {
+	...CORE_PALETTE,
+	...SIGNALS,
+};
+for (const [name, colors] of Object.entries(EXCALIDRAW_SEMANTICS)) {
+	ALL_TOKENS[`excalidraw.${name}.fill`] = colors.fill;
+	ALL_TOKENS[`excalidraw.${name}.stroke`] = colors.stroke;
+}
+
+// ---------------------------------------------------------------------------
+// Formatters
+// ---------------------------------------------------------------------------
+
+function quickRef(): string {
+	return [
+		"**Alpharius Design System — Quick Reference**",
+		"",
+		"```",
+		"BACKGROUNDS          ACCENTS              SIGNALS",
+		`bg:       ${CORE_PALETTE.bg}    primary:    ${CORE_PALETTE.primary}  green:  ${SIGNALS.green}`,
+		`cardBg:   ${CORE_PALETTE.cardBg}    primaryMu:  ${CORE_PALETTE.primaryMuted}  red:    ${SIGNALS.red}`,
+		`surfaceBg:${CORE_PALETTE.surfaceBg}    primaryBr:  ${CORE_PALETTE.primaryBright}  orange: ${SIGNALS.orange}`,
+		`                                          yellow: ${SIGNALS.yellow}`,
+		"",
+		"TEXT                 BORDERS              SYNTAX",
+		`fg:       ${CORE_PALETTE.fg}    border:     ${CORE_PALETTE.borderColor}  syntaxType: ${CORE_PALETTE.syntaxType}`,
+		`mutedFg:  ${CORE_PALETTE.mutedFg}    borderDim:  ${CORE_PALETTE.borderDim}`,
+		`dimFg:    ${CORE_PALETTE.dimFg}`,
+		"",
+		"EXCALIDRAW SEMANTICS (fill / stroke)",
+		`primary:   ${EXCALIDRAW_SEMANTICS.primary.fill} / ${EXCALIDRAW_SEMANTICS.primary.stroke}    start:     ${EXCALIDRAW_SEMANTICS.start.fill} / ${EXCALIDRAW_SEMANTICS.start.stroke}`,
+		`secondary: ${EXCALIDRAW_SEMANTICS.secondary.fill} / ${EXCALIDRAW_SEMANTICS.secondary.stroke}    end:       ${EXCALIDRAW_SEMANTICS.end.fill} / ${EXCALIDRAW_SEMANTICS.end.stroke}`,
+		`decision:  ${EXCALIDRAW_SEMANTICS.decision.fill} / ${EXCALIDRAW_SEMANTICS.decision.stroke}    ai:        ${EXCALIDRAW_SEMANTICS.ai.fill} / ${EXCALIDRAW_SEMANTICS.ai.stroke}`,
+		`warning:   ${EXCALIDRAW_SEMANTICS.warning.fill} / ${EXCALIDRAW_SEMANTICS.warning.stroke}    error:     ${EXCALIDRAW_SEMANTICS.error.fill} / ${EXCALIDRAW_SEMANTICS.error.stroke}`,
+		`evidence:  ${EXCALIDRAW_SEMANTICS.evidence.fill} / ${EXCALIDRAW_SEMANTICS.evidence.stroke}    inactive:  ${EXCALIDRAW_SEMANTICS.inactive.fill} / ${EXCALIDRAW_SEMANTICS.inactive.stroke}`,
+		"```",
+		"",
+		"`/style palette` — render visual swatch  ·  `/style d2` — D2 style template",
+		"`/style excalidraw` — semantic palette table  ·  `/style check <file>` — audit colors",
+	].join("\n");
+}
+
+function excalidrawTable(): string {
+	const rows = Object.entries(EXCALIDRAW_SEMANTICS).map(
+		([name, { fill, stroke, use }]) => `| \`${name}\` | \`${fill}\` | \`${stroke}\` | ${use} |`
+	);
+	return [
+		"**Excalidraw Semantic Palette**",
+		"",
+		"| Purpose | Fill | Stroke | Use |",
+		"|---------|------|--------|-----|",
+		...rows,
+		"",
+		"Text on all fills: use `#c4d8e4` (Alpharius silver-white foreground)",
+	].join("\n");
+}
+
+function d2Template(): string {
+	return [
+		"**D2 Alpharius Style Template**",
+		"",
+		"Copy and adapt for your diagrams. Renders with `--theme 200 --layout elk`:",
+		"",
+		"```d2",
+		D2_STYLE_TEMPLATE,
+		"```",
+	].join("\n");
+}
+
+function auditColors(filePath: string): string {
+	const fs = require("node:fs");
+	let content: string;
+	try {
+		content = fs.readFileSync(filePath, "utf-8");
+	} catch {
+		return `❌ Could not read file: \`${filePath}\``;
+	}
+
+	const hexPattern = /#[0-9a-fA-F]{6}\b/g;
+	const found = new Set<string>();
+	let match: RegExpExecArray | null;
+	while ((match = hexPattern.exec(content)) !== null) {
+		found.add(match[0].toLowerCase());
+	}
+
+	if (found.size === 0) {
+		return `✅ No hex colors found in \`${filePath}\``;
+	}
+
+	const onPalette: string[] = [];
+	const offPalette: string[] = [];
+	const tokensByHex = new Map<string, string[]>();
+	for (const [name, hex] of Object.entries(ALL_TOKENS)) {
+		const h = hex.toLowerCase();
+		if (!tokensByHex.has(h)) tokensByHex.set(h, []);
+		tokensByHex.get(h)!.push(name);
+	}
+
+	for (const hex of [...found].sort()) {
+		const tokens = tokensByHex.get(hex);
+		if (tokens) {
+			onPalette.push(`  ✅ \`${hex}\` → ${tokens.join(", ")}`);
+		} else {
+			offPalette.push(`  ⚠️  \`${hex}\` — **off-palette**`);
+		}
+	}
+
+	const lines = [`**Color Audit: \`${filePath}\`**`, "", `Found ${found.size} unique hex colors:`, ""];
+	if (onPalette.length) lines.push("**On-palette:**", ...onPalette, "");
+	if (offPalette.length) lines.push("**Off-palette:**", ...offPalette, "");
+	return lines.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Extension
+// ---------------------------------------------------------------------------
+
+export default function styleExtension(pi: ExtensionAPI) {
+	pi.registerCommand("style", {
+		description: "Alpharius design system (usage: /style [palette|d2|excalidraw|check <file>])",
+		getArgumentCompletions: (prefix: string) => {
+			const parts = prefix.split(/\s+/);
+			if (parts.length <= 1) {
+				const subs: Array<{ value: string; label: string; description: string }> = [
+					{ value: "palette", label: "palette", description: "Render visual swatch" },
+					{ value: "d2", label: "d2", description: "D2 style template" },
+					{ value: "excalidraw", label: "excalidraw", description: "Semantic palette table" },
+					{ value: "check", label: "check", description: "Audit file colors" },
+				];
+				const filtered = subs.filter(s => s.value.startsWith(parts[0] || ""));
+				return filtered.length > 0 ? filtered : null;
+			}
+			return null;
+		},
+		handler: async (args, _ctx) => {
+			const trimmed = (args || "").trim();
+			const [subcommand, ...rest] = trimmed.split(/\s+/);
+
+			let output: string;
+
+			switch (subcommand || "") {
+				case "":
+					output = quickRef();
+					break;
+				case "palette":
+					// Delegate to agent to render via render_diagram tool (D2)
+					pi.sendUserMessage(
+						"Render a D2 diagram showing the Alpharius palette as a visual swatch. " +
+						"Use the style skill's color tokens. Group into containers: Core (bg/cardBg/surfaceBg + primary/primaryMuted/primaryBright + fg/mutedFg/dimFg), " +
+						"Signals (green/red/orange/yellow), and Borders (borderColor/borderDim). " +
+						"Style each node with its actual hex value as fill color, appropriate font-color for contrast, " +
+						"and label it with token name + hex value. Use D2 style blocks.",
+						{ deliverAs: "followUp" },
+					);
+					return;
+				case "d2":
+					output = d2Template();
+					break;
+				case "excalidraw":
+					output = excalidrawTable();
+					break;
+				case "check": {
+					const filePath = rest.join(" ");
+					if (!filePath) {
+						output = "Usage: `/style check <file path>`";
+					} else {
+						output = auditColors(filePath);
+					}
+					break;
+				}
+				default:
+					// Treat as a question — delegate to agent with style skill context
+					pi.sendUserMessage(
+						`The user asked about the style system: "${trimmed}". ` +
+						`Answer using the style skill (Alpharius design system). Load /skill:style if needed.`,
+						{ deliverAs: "followUp" },
+					);
+					return;
+			}
+
+			pi.sendMessage({ customType: "view", content: output, display: true });
+		},
+	});
+}