omegon 0.8.0 → 0.8.2

package/README.md

@@ -42,7 +42,7 @@ omegon      # start Omegon in any project directory
 
 ![Omegon Architecture](docs/img/architecture.png)
 
-Omegon extends `@styrene-lab/pi-coding-agent` with **27 extensions**, **12 skills**, and **4 prompt templates** — loaded automatically on session start.
+Omegon extends `@styrene-lab/pi-coding-agent` with **31 extensions**, **12 skills**, and **4 prompt templates** — loaded automatically on session start.
 
 ### Development Methodology
 
@@ -87,8 +87,10 @@ Structured design exploration with persistent markdown documents — the upstrea
 - **Blocked audit**: `design_tree(action="blocked")` returns all stalled nodes with each blocking dependency's id, title, and status
 - **Priority**: `set_priority` (1 = critical → 5 = trivial) on any node; `ready` auto-sorts by it
 - **Issue types**: `set_issue_type` classifies nodes as `epic | feature | task | bug | chore` — bugs and chores are now first-class tracked work
-- **OpenSpec bridge**: `design_tree_update` with `action: "implement"` scaffolds `openspec/changes/<node-id>/` from a decided node's content; `/cleave` executes it
-- **Full pipeline**: design → decide → implement → `/cleave` → `/assess spec` → archive
+- **Auto-transition**: Adding research or decisions to a `seed` node automatically transitions it to `exploring` and scaffolds the design spec — no manual ceremony
+- **Substance-over-ceremony gates**: `set_status(decided)` checks for open questions and recorded decisions instead of artifact directory existence. Design specs are auto-extracted from doc content and archived
+- **OpenSpec bridge**: `design_tree_update` with `action: "implement"` scaffolds `openspec/changes/<node-id>/` from a decided node's content, auto-checkouts the directive branch, forks a scoped memory mind, and sets design focus; `/cleave` executes it
+- **Full pipeline**: design → decide → implement (auto-checkout + mind fork) → `/cleave` → `/assess spec` → archive (mind merge-back + cleanup)
 
 ### 🧠 Project Memory
 
@@ -98,8 +100,9 @@ Persistent, cross-session knowledge stored in SQLite. Accumulates architectural
 - **Semantic retrieval**: Embedding-based search via Ollama (`qwen3-embedding`), falls back to FTS5 keyword search
 - **Background extraction**: Auto-discovers facts from tool output without interrupting work
 - **Episodic memory**: Generates session narratives at shutdown for "what happened last time" context
+- **Directive minds**: `implement` forks a scoped memory mind from `default`; all fact reads/writes auto-scope to the directive. `archive` ingests discoveries back to `default` and cleans up. Zero-copy fork with parent-chain inheritance — no fact duplication, parent embeddings and edges are reused
 - **Global knowledge base**: Cross-project facts at `~/.pi/memory/global.db`
-- **Git sync**: Exports to JSONL for version-controlled knowledge sharing across machines
+- **Git sync**: Exports to JSONL for version-controlled knowledge sharing across machines; volatile runtime scoring metadata (confidence, reinforcement counts, decay scores) omitted from exports for stable diffs
 
 ![Memory Lifecycle](docs/img/memory-lifecycle.png)
 
@@ -112,6 +115,7 @@ Live status panel showing design tree, OpenSpec changes, cleave dispatch, and gi
 - **Raised mode**: Full-width expanded view (toggle with `/dash`)
   - Git branch tree rooted at repo name, annotated with linked design nodes
   - Two-column split at ≥120 terminal columns: design tree + cleave left, OpenSpec right
+  - Directive indicator: shows `▸ directive: name ✓` (branch match) or `▸ directive: name ⚠ main` (mismatch) when a directive mind is active
   - Context gauge · model · thinking level in shared footer zone
   - No line cap — renders as much content as needed
 - **Keyboard**: `Ctrl+Shift+B` toggles raised/compact

package/extensions/cleave/assessment.ts

@@ -194,21 +194,22 @@ export const PATTERNS: Record<string, PatternDefinition> = {
 		modifiersDefault: ["breaking_changes"],
 		splitStrategy: ["New versioned endpoint", "Deprecation + dual-support", "Client migration"],
 	},
-	simple_refactor: {
-		name: "Simple Refactor",
-		description: "Code cleanup, renaming, or structural changes without functional modifications",
+	refactor: {
+		name: "Refactor",
+		description: "Code cleanup, renaming, restructuring, or replacing implementations while preserving behavior",
 		keywords: [
 			"refactor", "rename", "reorganize", "cleanup", "extract", "inline", "move",
-			"restructure", "mechanical", "no functional",
+			"restructure", "mechanical", "no functional", "replace", "rewrite",
+			"swap", "substitute", "modernize",
 		],
-		requiredAny: ["refactor", "rename", "cleanup", "extract", "reorganize"],
+		requiredAny: ["refactor", "rename", "cleanup", "extract", "reorganize", "replace", "rewrite", "swap", "substitute"],
 		expectedComponents: {
-			operation: ["rename", "extract", "inline", "move", "reorganize"],
-			scope: ["function", "class", "file", "module", "component", "method"],
+			operation: ["rename", "extract", "inline", "move", "reorganize", "replace", "rewrite", "swap", "substitute"],
+			scope: ["function", "class", "file", "module", "component", "method", "implementation", "approach", "library", "framework", "pattern"],
 		},
 		systemsBase: 1,
 		modifiersDefault: [],
-		splitStrategy: ["By module/scope", "Update tests"],
+		splitStrategy: ["Implement replacement / perform refactor", "Update call sites + tests", "Remove old implementation"],
 	},
 	bug_fix: {
 		name: "Bug Fix",
@@ -282,21 +283,27 @@ export const PATTERNS: Record<string, PatternDefinition> = {
 		modifiersDefault: ["state_coordination"],
 		splitStrategy: ["Core data model", "Rendering/UI layer", "Event handling + state management", "Application shell"],
 	},
-	refactor: {
-		name: "Refactor",
-		description: "Replace or rewrite implementation while preserving behavior",
+	infrastructure_tooling: {
+		name: "Infrastructure & Tooling",
+		description: "Extension development, CLI tooling, internal infrastructure, build systems, or agentic framework work",
 		keywords: [
-			"refactor", "replace", "rewrite", "improve", "clean", "restructure", "reorganize",
-			"swap", "substitute", "modernize",
+			"extension", "plugin", "tool", "command", "cli", "config", "configuration",
+			"pipeline", "build", "deploy", "ci", "cd", "workflow", "script", "hook",
+			"provider", "routing", "dispatch", "handler", "registry", "loader",
+			"prompt", "agent", "inference",
+			"dashboard", "diagnostic", "telemetry", "logging",
+			"skill", "template", "scaffold", "generate", "emit",
 		],
-		requiredAny: ["replace", "rewrite", "swap", "substitute", "refactor"],
+		requiredAny: ["extension", "plugin", "provider", "routing",
+			"dispatch", "registry", "agent", "skill"],
 		expectedComponents: {
-			operation: ["replace", "rewrite", "swap", "substitute"],
-			target: ["implementation", "approach", "library", "framework", "pattern"],
+			core: ["extension", "plugin", "tool", "command", "handler", "provider", "registry"],
+			integration: ["config", "pipeline", "workflow", "routing", "dispatch", "loader"],
+			surface: ["cli", "dashboard", "status", "prompt", "template", "diagnostic"],
 		},
-		systemsBase: 1.0,
+		systemsBase: 1,
 		modifiersDefault: [],
-		splitStrategy: ["Implement replacement", "Update call sites", "Remove old implementation"],
+		splitStrategy: ["Core implementation", "Integration + wiring", "Tests + documentation"],
 	},
 };
 
@@ -462,11 +469,18 @@ export function detectModifiers(directive: string): string[] {
 }
 
 /**
- * Calculate complexity: (1 + systems) × (1 + 0.5 × modifiers).
+ * Calculate complexity: systems × (1 + 0.5 × modifiers).
+ *
+ * Previous formula was (1 + systems) which gave a floor of 2.0 even for
+ * single-system, zero-modifier directives — making the heuristic path
+ * always exceed the default threshold of 2.0. Using bare `systems`
+ * allows trivial directives (1 system, 0 modifiers) to score 1.0,
+ * so they correctly get `needs_assessment` instead of `cleave`.
+ *
  * Capped at 100.0.
  */
 export function calculateComplexity(systems: number, modifiers: string[]): number {
-	const raw = (1 + systems) * (1 + 0.5 * modifiers.length);
+	const raw = systems * (1 + 0.5 * modifiers.length);
 	return Math.round(Math.min(raw, 100.0) * 10) / 10;
 }
 
@@ -536,7 +550,7 @@ export function assessDirective(
 			reasoning:
 				`Pattern '${match.name}' matched with ${(match.confidence * 100).toFixed(0)}% confidence. ` +
 				`Systems: ${systemsForDisplay}, Modifiers: ${allModifiers.length}. ` +
-				`Formula: (1 + ${systemsForCalc}) × (1 + 0.5 × ${allModifiers.length}) = ${complexity}. ` +
+				`Formula: ${systemsForCalc} × (1 + 0.5 × ${allModifiers.length}) = ${complexity}. ` +
 				`Effective (validate=${validate}): ${effComplexity}`,
 			skipInterrogation: false,
 		};
@@ -545,7 +559,7 @@ export function assessDirective(
 		if (
 			match.confidence >= 0.90 &&
 			effComplexity <= threshold &&
-			match.name === "Simple Refactor"
+			match.name === "Refactor"
 		) {
 			result.skipInterrogation = true;
 		}

package/extensions/cleave/index.ts

@@ -1586,7 +1586,7 @@ export default function cleaveExtension(pi: ExtensionAPI) {
 			"Every non-trivial code change must include tests in co-located *.test.ts files. Untested code is incomplete — do not commit without tests for new functions and changed behavior.",
 			"Call cleave_assess before starting any multi-system or cross-cutting task to determine if decomposition is needed",
 			"If decision is 'execute', proceed directly. If 'cleave', use /cleave to decompose. If 'needs_assessment', proceed directly — it means no pattern matched but the task is likely simple enough for in-session execution.",
-			"Complexity formula: (1 + systems) × (1 + 0.5 × modifiers). Threshold default: 2.0.",
+			"Complexity formula: systems × (1 + 0.5 × modifiers). Threshold default: 2.0.",
 			"The /assess command provides code assessment: `/assess cleave` (adversarial review + auto-fix), `/assess diff [ref]` (review only), `/assess spec [change]` (validate against OpenSpec scenarios), `/assess design [node-id]` (evaluate design-tree node readiness before set_status(decided)).",
 			"When the repo has openspec/ with active changes, suggest `/assess spec` after implementation and before `/opsx:archive`.",
 			"Run `/assess design <node-id>` before calling design_tree_update with set_status(decided) to verify acceptance criteria are satisfied.",

package/extensions/openspec/spec.ts

@@ -427,9 +427,13 @@ export function computeAssessmentSnapshot(repoPath: string, changeName: string):
 	const gitHead = safeReadGit(repoPath, ["rev-parse", "HEAD"]);
 	const dirty = detectGitDirty(repoPath, snapshotPaths);
 
+	// Fingerprint represents implementation file content — NOT git HEAD.
+	// Including gitHead would create a chicken-and-egg: committing the
+	// assessment.json (which lives in-repo) changes HEAD, which invalidates
+	// the fingerprint, making the assessment permanently stale.
+	// Git HEAD is stored separately in the snapshot for informational use.
 	const fingerprintSeed = JSON.stringify({
 		changeName,
-		gitHead,
 		dirty,
 		files,
 	});

package/extensions/spinner-verbs.ts

@@ -1,6 +1,9 @@
 import type { ExtensionAPI } from "@styrene-lab/pi-coding-agent";
 
 const verbs = [
+  // ═══════════════════════════════════════════════════
+  // Adeptus Mechanicus — Rites of the Omnissiah
+  // ═══════════════════════════════════════════════════
   "Communing with the Machine Spirit",
   "Appeasing the Omnissiah",
   "Reciting the Litany of Ignition",
@@ -19,54 +22,17 @@ const verbs = [
   "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",
@@ -74,6 +40,170 @@ const verbs = [
   "Grafting the sacred augmetic",
   "Offering a binary prayer to the void",
   "Inscribing the litany upon the circuit board",
+  "Consulting the Electro-Priests",
+  "Rotating the sacred engrams",
+  "Downloading wisdom from the data-vaults of Triplex Phall",
+  "Genuflecting before the Censer of Compilation",
+  "Parsing the Machine Cant in trinary",
+  "Applying the Unguent of Optimal Throughput",
+  "Reciting the Canticle of the Blessed Diff",
+  "Interfacing with the ancient dataslab",
+
+  // ═══════════════════════════════════════════════════
+  // Imperium of Man — Warfare & Devotion
+  // ═══════════════════════════════════════════════════
+  "Reciting the Litany of Hate",
+  "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",
+  "Fortifying the firewall bastions",
+  "Loading the bolter rounds",
+  "Administering the Sacred Oils",
+  "Affixing the Purity Seal to the commit",
+  "Routing the xenos from the dependency tree",
+  "Invoking the Emperor's Protection",
+  "Committing the Holy Diff",
+  "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",
+  "Dispatching the Officio Assassinorum against the regression",
+  "Filing the grievance with the Administratum",
+  "Awaiting parchmentwork from the Adeptus Terra",
+  "Consulting the Tarot of the Emperor",
+  "Fortifying this position (the Codex Astartes supports this action)",
+  "Mounting a Drop Pod assault on the issue tracker",
+  "Declaring Exterminatus on the node_modules",
+  "Summoning the Grey Knights to purge the warp-tainted test suite",
+
+  // ═══════════════════════════════════════════════════
+  // Classical Antiquity — Greek & Roman
+  // ═══════════════════════════════════════════════════
+  "Consulting the Oracle at Delphi",
+  "Reading the auguries",
+  "Descending into the labyrinth",
+  "Weaving on Athena's loom",
+  "Deciphering the Rosetta Stone",
+  "Unraveling Ariadne's thread",
+  "Stealing fire from Olympus",
+  "Divining from the entrails",
+  "Navigating the River Styx",
+  "Forging on Hephaestus's anvil",
+  "Bargaining with the Sphinx",
+  "Pouring libations to Hermes, patron of automation",
+  "Petitioning Athena for architectural wisdom",
+  "Cleaning the Augean stables of legacy code",
+  "Consulting Tiresias about the deprecation warnings",
+  "Binding the code with Odysseus's cunning",
+  "Awaiting judgment from the Areopagus",
+  "Constructing the Antikythera mechanism",
+  "Charting a course between Scylla and Charybdis",
+
+  // ═══════════════════════════════════════════════════
+  // Norse — Sagas & Runes
+  // ═══════════════════════════════════════════════════
+  "Consulting the Norns",
+  "Reading the runes",
+  "Asking Mímir's head for guidance",
+  "Hanging from Yggdrasil for wisdom",
+  "Forging in the heart of Niðavellir",
+  "Sailing the Bifrost to the deployment realm",
+  "Summoning the Einherjar for code review",
+  "Sharpening Gram upon the whetstone of tests",
+  "Consulting the Völva about the sprint forecast",
+  "Feeding Huginn and Muninn the latest telemetry",
+  "Braving the Fimbulwinter of dependency hell",
+
+  // ═══════════════════════════════════════════════════
+  // Arthurian & Medieval
+  // ═══════════════════════════════════════════════════
+  "Questing for the Holy Grail of zero bugs",
+  "Pulling the sword from the CI/CD stone",
+  "Convening the Round Table for design review",
+  "Consulting Merlin's grimoire",
+  "Defending the castle walls against merge conflicts",
+  "Dispatching knights-errant into the codebase",
+  "Illuminating the manuscript of requirements",
+
+  // ═══════════════════════════════════════════════════
+  // Lovecraftian — Cosmic Horror
+  // ═══════════════════════════════════════════════════
+  "Gazing into the non-Euclidean geometry of the type system",
+  "Consulting the Necronomicon of legacy documentation",
+  "Invoking That Which Should Not Be Refactored",
+  "Descending into the R'lyeh of nested callbacks",
+  "Bargaining with Nyarlathotep for more compute",
+  "Performing rites that would drive lesser compilers mad",
+  "Glimpsing truths that the garbage collector dare not reclaim",
+
+  // ═══════════════════════════════════════════════════
+  // Dune — Arrakis & the Imperium
+  // ═══════════════════════════════════════════════════
+  "Walking without rhythm to avoid the sandworm",
+  "Consulting the Mentat about computational complexity",
+  "Folding space through the Holtzman drive",
+  "Navigating the Golden Path of the refactor",
+  "Deploying the hunter-seeker against the flaky test",
+  "Consuming the spice of stack traces",
+  "Reciting the Litany Against Fear (of production deploys)",
+  "Awaiting the Kwisatz Haderach of frameworks",
+  "Surviving the Gom Jabbar of code review",
+
+  // ═══════════════════════════════════════════════════
+  // Tolkien — Middle-earth
+  // ═══════════════════════════════════════════════════
+  "Consulting the palantír",
+  "Speaking 'friend' and entering the API",
+  "Casting the One Ring into the fires of refactoring",
+  "Seeking the counsel of Elrond",
+  "Delving too greedily and too deep into the codebase",
+  "Riding the Eagles to production",
+  "Reading the inscription by the light of Ithildin",
+  "Following the Fellowship through the mines of Moria",
+
+  // ═══════════════════════════════════════════════════
+  // Eastern — Sun Tzu, Miyamoto Musashi, Zen
+  // ═══════════════════════════════════════════════════
+  "Contemplating the sound of one hand coding",
+  "Applying the thirty-six stratagems to the architecture",
+  "Achieving mushin no shin — mind without mind",
+  "Striking with the void, per the Book of Five Rings",
+  "Knowing the enemy (the bug) and knowing thyself (the fix)",
+  "Sitting with the kōan of the failing assertion",
+  "Raking the sand garden of the test suite",
+
+  // ═══════════════════════════════════════════════════
+  // Alchemy & Occult
+  // ═══════════════════════════════════════════════════
+  "Transmuting the base code into gold",
+  "Distilling the quintessence from the logs",
+  "Consulting the Emerald Tablet of Hermes Trismegistus",
+  "Performing the Great Work upon the monolith",
+  "Seeking the Philosopher's Stone of zero downtime deploys",
+  "Drawing the sigil of binding upon the interface contract",
+  "Invoking the egregore of the open source community",
+
+  // ═══════════════════════════════════════════════════
+  // Sci-Fi Miscellany
+  // ═══════════════════════════════════════════════════
+  "Reversing the polarity of the neutron flow",
+  "Aligning the deflector dish to emit a solution beam",
+  "Rerouting auxiliary power to the build server",
+  "Engaging the probability drive",
+  "Computing the Answer (it's always 42)",
+  "Checking if the cake is a lie",
+  "Bypassing the Kobayashi Maru",
+  "Opening the pod bay doors",
+  "Reticulating splines",
 ];
 
 function randomVerb(): string {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "omegon",
-	"version": "0.8.0",
+	"version": "0.8.2",
 	"description": "Omegon — an opinionated distribution of pi (by Mario Zechner) with extensions for lifecycle management, memory, orchestration, and visualization",
 	"bin": {
 		"omegon": "bin/omegon.mjs",
@@ -58,7 +58,6 @@
 			"./extensions/cleave",
 			"./extensions/openspec",
 			"./extensions/defaults.ts",
-			"./extensions/distill.ts",
 			"./extensions/render",
 			"./extensions/local-inference",
 			"./extensions/mcp-bridge",
@@ -77,8 +76,7 @@
 			"./extensions/tool-profile",
 			"./extensions/vault",
 			"./extensions/version-check.ts",
-			"./extensions/web-ui",
-			"./extensions/clipboard-diag/index.ts"
+			"./extensions/web-ui"
 		],
 		"skills": [
 			"./skills"

package/skills/cleave/SKILL.md

@@ -91,15 +91,21 @@ This status is injected into the agent context (not just displayed).
 ## Complexity Formula
 
 ```
-complexity = (1 + systems) × (1 + 0.5 × modifiers)
+complexity = systems × (1 + 0.5 × modifiers)
 effective  = complexity + 1  (when validation enabled)
 ```
 
-## Patterns (9)
+The formula uses bare `systems` (not `1 + systems`) so that single-system,
+zero-modifier directives score 1.0 (effective 2.0) — at the default threshold
+of 2.0, they get `needs_assessment` rather than being falsely recommended
+for decomposition.
+
+## Patterns (12)
 
 Full-Stack CRUD, Authentication System, External Service Integration,
 Database Migration, Performance Optimization, Breaking API Change,
-Simple Refactor, Bug Fix, Refactor.
+Refactor, Bug Fix, Greenfield Project, Multi-Module Library,
+Application Bootstrap, Infrastructure & Tooling.
 
 ## Adversarial Review Loop
 

package/extensions/clipboard-diag/index.ts

@@ -1,64 +0,0 @@
-/**
- * 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/distill.ts

@@ -1,127 +0,0 @@
-/**
- * distill — Context distillation for session handoff
- *
- * Registers `/distill` command that analyzes the current conversation context
- * and produces a portable distillation summary for bootstrapping a fresh session.
- *
- * The extension handles the mechanical parts (directory creation, file writing,
- * git status collection) and delegates the summarization to the LLM via
- * sendUserMessage.
- */
-
-import { existsSync, mkdirSync } from "node:fs";
-import { join, basename } from "node:path";
-import type { ExtensionAPI } from "@styrene-lab/pi-coding-agent";
-
-export default function distillExtension(pi: ExtensionAPI) {
-
-	pi.registerCommand("distill", {
-		description: "Create a portable session distillation for fresh context bootstrap",
-		handler: async (_args, ctx) => {
-			// Gather mechanical context the LLM will need
-			const cwd = ctx.cwd;
-			const repoName = basename(cwd);
-
-			// Git status
-			let branch = "unknown";
-			let recentCommits = "";
-			let uncommitted = "";
-			try {
-				const branchResult = await pi.exec("git", ["branch", "--show-current"], { timeout: 5_000, cwd });
-				branch = branchResult.stdout.trim() || "HEAD detached";
-			} catch { /* ignore */ }
-			try {
-				const logResult = await pi.exec(
-					"git", ["log", "--oneline", "-10", "--no-decorate"],
-					{ timeout: 5_000, cwd },
-				);
-				recentCommits = logResult.stdout.trim();
-			} catch { /* ignore */ }
-			try {
-				const statusResult = await pi.exec("git", ["status", "--porcelain"], { timeout: 5_000, cwd });
-				uncommitted = statusResult.stdout.trim() || "(clean)";
-			} catch { /* ignore */ }
-
-			// Ensure distillation directory exists
-			const distillDir = join(cwd, ".pi", "distillations");
-			mkdirSync(distillDir, { recursive: true });
-
-			// Generate a timestamp-based filename
-			const now = new Date();
-			const ts = now.toISOString().replace(/[:.]/g, "-").slice(0, 19);
-
-			// Build the prompt for the LLM to do the actual summarization
-			const prompt = [
-				"Analyze the full conversation context and create a session distillation.",
-				"",
-				"**Repository context (already gathered):**",
-				`- Working directory: ${cwd}`,
-				`- Repository: ${repoName}`,
-				`- Branch: ${branch}`,
-				`- Recent commits:`,
-				"```",
-				recentCommits || "(no commits)",
-				"```",
-				`- Uncommitted changes:`,
-				"```",
-				uncommitted,
-				"```",
-				"",
-				"**Instructions:**",
-				"",
-				`Write a distillation file to \`${distillDir}/${ts}-<slug>.md\` where <slug> is a 2-3 word kebab-case description of the session topic.`,
-				"",
-				"Use this structure:",
-				"",
-				"```markdown",
-				"# Session Distillation: <brief-title>",
-				"",
-				"Generated: <timestamp>",
-				`Working Directory: ${cwd}`,
-				`Repository: ${repoName}`,
-				"",
-				"## Session Overview",
-				"<2-3 sentence summary of what was accomplished>",
-				"",
-				"## Technical State",
-				"### Repository Status",
-				`- Branch: ${branch}`,
-				"- Recent commits: <summarize>",
-				"- Uncommitted changes: <summarize>",
-				"",
-				"### Key Changes This Session",
-				"<bulleted list of significant modifications>",
-				"",
-				"## Decisions Made",
-				"<numbered list with brief rationale>",
-				"",
-				"## Pending Items",
-				"### Incomplete Work",
-				"### Known Issues",
-				"### Planned Next Steps",
-				"",
-				"## Critical Context",
-				"<information that would be difficult to reconstruct>",
-				"",
-				"## File Reference",
-				"Key files for continuation:",
-				"- <path>: <purpose>",
-				"```",
-				"",
-				"After writing the file, output a handoff block like:",
-				"",
-				"```",
-				"Distillation saved to: <path>",
-				"",
-				"To continue in a fresh session, copy this prompt:",
-				"---",
-				"Continue from distillation: <path>",
-				"Read the distillation file and confirm you understand the context before proceeding.",
-				"---",
-				"```",
-			].join("\n");
-
-			pi.sendUserMessage(prompt, { deliverAs: "followUp" });
-		},
-	});
-}