omegon 0.8.1 → 0.8.3

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

@@ -347,6 +347,50 @@ async function checkpointRelatedChanges(
 	}
 }
 
+/**
+ * Maximum number of interactive preflight attempts before bailing.
+ * Prevents infinite loops when the agent repeatedly picks actions
+ * that don't resolve the dirty tree.
+ */
+const MAX_PREFLIGHT_ATTEMPTS = 3;
+
+/**
+ * Verify the tree is clean after an action. If only volatile files remain,
+ * auto-stash them. Returns true if the tree is resolved, false if dirty
+ * files remain.
+ */
+async function verifyCleanAfterAction(
+	pi: ExtensionAPI,
+	repoPath: string,
+	changeName: string | null,
+	openspecContext: OpenSpecContext | null,
+	onUpdate?: AgentToolUpdateCallback<Record<string, unknown>>,
+): Promise<{ clean: boolean; classification: WorkspaceDirtyTreeClassification | null }> {
+	const postStatus = await pi.exec("git", ["status", "--porcelain"], {
+		cwd: repoPath,
+		timeout: 5_000,
+	});
+	const postState = inspectGitState(postStatus.stdout);
+	if (postState.entries.length === 0) return { clean: true, classification: null };
+
+	const postClassification = classifyPreflightDirtyPaths(
+		postState.entries.map((e) => e.path),
+		{ changeName, openspecContext },
+	);
+
+	// If only volatile files remain, auto-stash and treat as clean.
+	if (postState.nonVolatile.length === 0 && postClassification.volatile.length > 0) {
+		await stashPaths(pi, repoPath, "cleave-preflight-volatile", postClassification.volatile);
+		onUpdate?.({
+			content: [{ type: "text", text: "Remaining volatile artifacts stashed automatically — tree is clean." }],
+			details: { phase: "preflight", autoResolved: "volatile_only_stash" },
+		});
+		return { clean: true, classification: null };
+	}
+
+	return { clean: false, classification: postClassification };
+}
+
 export async function runDirtyTreePreflight(pi: ExtensionAPI, options: DirtyTreePreflightOptions): Promise<"continue" | "skip_cleave" | "cancelled"> {
 	const status = await pi.exec("git", ["status", "--porcelain"], {
 		cwd: options.repoPath,
@@ -369,12 +413,11 @@ export async function runDirtyTreePreflight(pi: ExtensionAPI, options: DirtyTree
 		changeName,
 		openspecContext,
 	});
-	// Compute initial checkpoint plan for the summary display only.
-	// The plan is rebuilt from currentClassification inside the loop on each attempt (C4).
 	const initialCheckpointPlan = buildCheckpointPlan(classification, { changeName, openspecContext });
 	const summary = formatDirtyTreeSummary(classification, initialCheckpointPlan.message);
 	options.onUpdate?.({ content: [{ type: "text", text: summary }], details: { phase: "preflight" } });
 
+	// Auto-resolve: volatile-only dirty tree — stash and continue without prompting.
 	if (gitState.nonVolatile.length === 0) {
 		if (classification.volatile.length > 0) {
 			await stashPaths(pi, options.repoPath, "cleave-preflight-volatile", classification.volatile);
@@ -392,86 +435,88 @@ export async function runDirtyTreePreflight(pi: ExtensionAPI, options: DirtyTree
 		throw new Error(summary + "\n\nInteractive input is unavailable, so cleave cannot resolve the dirty tree automatically.");
 	}
 
-	// Mutable classification — refreshed after each checkpoint attempt (C1/W1).
+	// Mutable classification — refreshed after each action attempt.
 	let currentClassification = classification;
+	let attempts = 0;
+
+	while (attempts < MAX_PREFLIGHT_ATTEMPTS) {
+		attempts++;
 
-	while (true) {
 		let answer: string | undefined;
 		if (hasSelect) {
-			// Preferred path: show a modal select with labelled options and descriptions.
 			const selected = await options.ui!.select!(
 				"Dirty tree detected — choose a preflight action to proceed:",
 				[...PREFLIGHT_ACTION_OPTIONS],
 			);
 			answer = parsePreflightAction(selected);
 		} else {
-			// Fallback: raw text input (headless / test environments).
 			answer = normalizePreflightInput(
 				await options.ui!.input!("Dirty tree action [checkpoint|stash-unrelated|stash-volatile|proceed-without-cleave|cancel]:"),
 			)?.toLowerCase();
 		}
+
 		try {
 			switch (answer) {
 				case "checkpoint": {
-					// Rebuild the checkpoint plan from the current (possibly refreshed) classification (C4).
 					const currentCheckpointPlan = buildCheckpointPlan(currentClassification, { changeName, openspecContext });
-					const committedFiles = new Set(currentClassification.checkpointFiles);
 					await checkpointRelatedChanges(pi, options.repoPath, currentClassification, currentCheckpointPlan.message, options.ui);
-					// Re-verify cleanliness after the checkpoint commit.
-					const postCheckpointStatus = await pi.exec("git", ["status", "--porcelain"], {
-						cwd: options.repoPath,
-						timeout: 5_000,
-					});
-					const postState = inspectGitState(postCheckpointStatus.stdout);
-					if (postState.entries.length === 0) {
-						// Tree is clean — checkpoint fully resolved the dirty tree.
-						return "continue";
-					}
 
-					// Re-derive classification from the post-checkpoint state (C1).
-					currentClassification = classifyPreflightDirtyPaths(
-						postState.entries.map((e) => e.path),
-						{ changeName, openspecContext },
+					const { clean, classification: postClassification } = await verifyCleanAfterAction(
+						pi, options.repoPath, changeName, openspecContext, options.onUpdate,
 					);
-
-					// C2: If only volatile files remain, auto-stash and continue.
-					if (postState.nonVolatile.length === 0 && currentClassification.volatile.length > 0) {
-						await stashPaths(pi, options.repoPath, "cleave-preflight-volatile", currentClassification.volatile);
-						options.onUpdate?.({
-							content: [{ type: "text", text: "Checkpoint succeeded. Remaining volatile artifacts stashed automatically — cleave continuing." }],
-							details: { phase: "preflight", autoResolved: "volatile_only_stash" },
-						});
-						return "continue";
-					}
-
-					// Remaining dirty files — emit precise diagnosis (W1: distinguish committed-but-still-dirty vs excluded-from-scope).
-					const remainingPaths = postState.entries.map((e) => e.path);
-					const diagnosisLines = [
-						"Checkpoint committed successfully, but dirty files remain — cleave cannot continue yet:",
-						...currentClassification.related.map((f) =>
-							committedFiles.has(f.path)
-								? `  • ${f.path}  [was committed but remains dirty — file may have been modified after staging or only partially staged]`
-								: `  • ${f.path}  [related but excluded from checkpoint scope — confidence too low to commit automatically]`
-						),
-						...currentClassification.unrelated.map((f) => `  • ${f.path}  [unrelated: ${f.reason}]`),
-						...currentClassification.unknown.map((f) => `  • ${f.path}  [unknown — not in change scope, was not checkpointed]`),
-						...currentClassification.volatile.map((f) => `  • ${f.path}  [volatile artifact — will be auto-stashed]`),
-						"",
-						"Choose another preflight action to resolve the remaining files.",
+					if (clean) return "continue";
+
+					// Dirty files remain after checkpoint — update classification and show diagnosis.
+					currentClassification = postClassification!;
+					const remainingPaths = [
+						...currentClassification.related,
+						...currentClassification.unrelated,
+						...currentClassification.unknown,
+						...currentClassification.volatile,
 					];
 					options.onUpdate?.({
-						content: [{ type: "text", text: diagnosisLines.join("\n") }],
-						details: { phase: "preflight", postCheckpointDirty: remainingPaths },
+						content: [{ type: "text", text:
+							"Checkpoint committed, but dirty files remain:\n" +
+							remainingPaths.map((f) => `  • ${f.path}  [${f.reason}]`).join("\n") +
+							"\n\nChoose another action to resolve.",
+						}],
+						details: { phase: "preflight", postCheckpointDirty: remainingPaths.map((f) => f.path) },
 					});
 					break;
 				}
-				case "stash-unrelated":
-					// C1: Use currentClassification (refreshed after checkpoint) not the stale original.
-					await stashPaths(pi, options.repoPath, "cleave-preflight-unrelated", [...currentClassification.unrelated, ...currentClassification.unknown]);
-					return "continue";
-				case "stash-volatile":
+				case "stash-unrelated": {
+					const toStash = [...currentClassification.unrelated, ...currentClassification.unknown];
+					if (toStash.length === 0) {
+						options.onUpdate?.({
+							content: [{ type: "text", text: "No unrelated or unknown files to stash. Choose a different action." }],
+							details: { phase: "preflight" },
+						});
+						break;
+					}
+					await stashPaths(pi, options.repoPath, "cleave-preflight-unrelated", toStash);
+					const { clean, classification: postClassification } = await verifyCleanAfterAction(
+						pi, options.repoPath, changeName, openspecContext, options.onUpdate,
+					);
+					if (clean) return "continue";
+					currentClassification = postClassification!;
+					break;
+				}
+				case "stash-volatile": {
+					if (currentClassification.volatile.length === 0) {
+						options.onUpdate?.({
+							content: [{ type: "text", text: "No volatile files to stash. Choose a different action." }],
+							details: { phase: "preflight" },
+						});
+						break;
+					}
 					await stashPaths(pi, options.repoPath, "cleave-preflight-volatile", currentClassification.volatile);
-					return "continue";
+					const { clean, classification: postClassification } = await verifyCleanAfterAction(
+						pi, options.repoPath, changeName, openspecContext, options.onUpdate,
+					);
+					if (clean) return "continue";
+					currentClassification = postClassification!;
+					break;
+				}
 				case "proceed-without-cleave":
 					return "skip_cleave";
 				case "cancel":
@@ -479,7 +524,7 @@ export async function runDirtyTreePreflight(pi: ExtensionAPI, options: DirtyTree
 					return "cancelled";
 				default:
 					options.onUpdate?.({
-						content: [{ type: "text", text: "Invalid preflight action. Choose checkpoint, stash-unrelated, stash-volatile, proceed-without-cleave, or cancel." }],
+						content: [{ type: "text", text: "Invalid action. Choose checkpoint, stash-unrelated, stash-volatile, proceed-without-cleave, or cancel." }],
 						details: { phase: "preflight" },
 					});
 			}
@@ -491,6 +536,19 @@ export async function runDirtyTreePreflight(pi: ExtensionAPI, options: DirtyTree
 			});
 		}
 	}
+
+	// Exhausted attempts — report remaining dirty files and bail.
+	const remaining = [
+		...currentClassification.related,
+		...currentClassification.unrelated,
+		...currentClassification.unknown,
+		...currentClassification.volatile,
+	];
+	throw new Error(
+		`Dirty tree not resolved after ${MAX_PREFLIGHT_ATTEMPTS} attempts. Remaining files:\n` +
+		remaining.map((f) => `  • ${f.path}`).join("\n") +
+		"\n\nResolve manually (git commit/stash/checkout) and retry /cleave.",
+	);
 }
 
 interface AssessExecutionContext {
@@ -1586,7 +1644,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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "omegon",
-	"version": "0.8.1",
+	"version": "0.8.3",
 	"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",

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