omegon-pi 0.13.0 → 0.13.1

package/data/route-matrix.json

@@ -0,0 +1,112 @@
+{
+  "$schema": "./route-matrix.schema.json",
+  "lastReviewed": "2026-03-20",
+  "version": 1,
+  "routes": [
+    {
+      "provider": "anthropic",
+      "modelIdPattern": "claude-opus-*",
+      "contextCeiling": 1000000,
+      "tier": "gloriana",
+      "breakpointZones": [
+        { "threshold": 200000, "note": "Requests over 200k tokens work without beta headers since late 2025" }
+      ]
+    },
+    {
+      "provider": "anthropic",
+      "modelIdPattern": "claude-sonnet-*",
+      "contextCeiling": 1000000,
+      "tier": "victory",
+      "breakpointZones": [
+        { "threshold": 200000, "note": "Same 200k operational boundary as Opus" }
+      ]
+    },
+    {
+      "provider": "anthropic",
+      "modelIdPattern": "claude-haiku-*",
+      "contextCeiling": 200000,
+      "tier": "retribution",
+      "breakpointZones": []
+    },
+    {
+      "provider": "openai",
+      "modelIdPattern": "gpt-5.4",
+      "contextCeiling": 272000,
+      "tier": "gloriana",
+      "breakpointZones": [
+        { "threshold": 272000, "note": "Full-session pricing changes above 272k" }
+      ]
+    },
+    {
+      "provider": "openai",
+      "modelIdPattern": "gpt-5.4-pro*",
+      "contextCeiling": 1050000,
+      "tier": "gloriana",
+      "breakpointZones": []
+    },
+    {
+      "provider": "openai",
+      "modelIdPattern": "gpt-5.4-mini*",
+      "contextCeiling": 400000,
+      "tier": "victory",
+      "breakpointZones": []
+    },
+    {
+      "provider": "openai",
+      "modelIdPattern": "gpt-5.3*",
+      "contextCeiling": 272000,
+      "tier": "victory",
+      "breakpointZones": []
+    },
+    {
+      "provider": "openai",
+      "modelIdPattern": "gpt-5.2*",
+      "contextCeiling": 272000,
+      "tier": "victory",
+      "breakpointZones": []
+    },
+    {
+      "provider": "openai",
+      "modelIdPattern": "gpt-5.1*",
+      "contextCeiling": 200000,
+      "tier": "retribution",
+      "breakpointZones": []
+    },
+    {
+      "provider": "github-copilot",
+      "modelIdPattern": "claude-*",
+      "contextCeiling": 128000,
+      "tier": "victory",
+      "breakpointZones": [],
+      "note": "Copilot caps Claude routes at 128k regardless of underlying model capability"
+    },
+    {
+      "provider": "github-copilot",
+      "modelIdPattern": "gpt-5.4*",
+      "contextCeiling": 400000,
+      "tier": "gloriana",
+      "breakpointZones": []
+    },
+    {
+      "provider": "local",
+      "modelIdPattern": "nemotron-nano*",
+      "contextCeiling": 1048576,
+      "tier": "retribution",
+      "breakpointZones": []
+    },
+    {
+      "provider": "local",
+      "modelIdPattern": "devstral-small*",
+      "contextCeiling": 393216,
+      "tier": "retribution",
+      "breakpointZones": []
+    },
+    {
+      "provider": "local",
+      "modelIdPattern": "qwen3:30b*",
+      "contextCeiling": 262144,
+      "tier": "retribution",
+      "breakpointZones": []
+    }
+  ]
+}

package/extensions/cleave/index.ts

@@ -92,7 +92,7 @@ import {
 	mergeBranch,
 	pruneWorktreeDirs,
 } from "./worktree.ts";
-import { inspectGitState } from "../lib/git-state.ts";
+import { inspectGitState, parseGitmodules } from "../lib/git-state.ts";
 
 // ─── Dashboard state emitter ────────────────────────────────────────────────
 
@@ -329,6 +329,26 @@ async function checkpointRelatedChanges(
 		throw new Error("Checkpoint cancelled before commit approval.");
 	}
 	const commitMessage = response && response.length > 0 ? response : suggested;
+	// Ensure submodule HEAD consistency before checkpoint.
+	// If a submodule has uncommitted internal changes, commit them inside the
+	// submodule first so the parent pointer captures the correct SHA.
+	const submodulePaths = parseGitmodules(repoPath);
+	const submoduleFiles = classification.checkpointFiles.filter((f) => submodulePaths.has(f));
+	for (const subPath of submoduleFiles) {
+		const { join: pathJoin } = await import("node:path");
+		const subFullPath = pathJoin(repoPath, subPath);
+		// Check if submodule has uncommitted changes
+		const subStatus = await pi.exec("git", ["status", "--porcelain"], { cwd: subFullPath, timeout: 5_000 });
+		if (subStatus.stdout.trim()) {
+			debug("cleave", `committing ${subStatus.stdout.trim().split("\n").length} dirty file(s) inside submodule '${subPath}' before checkpoint`);
+			await pi.exec("git", ["add", "-A"], { cwd: subFullPath, timeout: 10_000 });
+			await pi.exec("git", ["commit", "-m", `chore(cleave): checkpoint submodule before cleave`], {
+				cwd: subFullPath,
+				timeout: 10_000,
+			});
+		}
+	}
+
 	const addResult = await pi.exec("git", ["add", "--", ...classification.checkpointFiles], { cwd: repoPath, timeout: 15_000 });
 	if (addResult.code !== 0) {
 		throw new Error(
@@ -371,7 +391,8 @@ async function verifyCleanAfterAction(
 		cwd: repoPath,
 		timeout: 5_000,
 	});
-	const postState = inspectGitState(postStatus.stdout);
+	const submodulePaths = parseGitmodules(repoPath);
+	const postState = inspectGitState(postStatus.stdout, undefined, submodulePaths);
 	if (postState.entries.length === 0) return { clean: true, classification: null };
 
 	const postClassification = classifyPreflightDirtyPaths(
@@ -397,7 +418,9 @@ export async function runDirtyTreePreflight(pi: ExtensionAPI, options: DirtyTree
 		cwd: options.repoPath,
 		timeout: 5_000,
 	});
-	const gitState = inspectGitState(status.stdout);
+	// Detect submodules for classification
+	const submodulePaths = parseGitmodules(options.repoPath);
+	const gitState = inspectGitState(status.stdout, undefined, submodulePaths);
 	if (gitState.entries.length === 0) return "continue";
 
 	const openspecContext = options.openspecChangePath

package/extensions/cleave/worktree.ts

@@ -1,6 +1,14 @@
 /**
  * cleave/worktree — Git worktree operations for child isolation.
  *
+ * ⚠️  LEGACY — The primary cleave dispatch path uses the Rust orchestrator
+ * (core/crates/omegon/src/cleave/) which owns worktree creation, submodule
+ * initialization, and merge. This TS module is only reachable from the
+ * `/cleave resume` command for runs started under the old TS dispatcher.
+ *
+ * Submodule support is NOT implemented here — it lives in the Rust
+ * worktree.rs (submodule_init, commit_dirty_submodules, verify_scope_accessible).
+ *
  * Each child gets its own git worktree on a separate branch,
  * preventing file conflicts during parallel execution.
  * Completed branches are merged back to base after harvesting.

package/extensions/dashboard/footer.ts

@@ -572,6 +572,15 @@ export class DashboardFooter implements Component {
         parts.push(narrow ? thinkIcon : `${thinkIcon} ${theme.fg(thinkColor, this.cachedThinkingLevel)}`);
       }
 
+      // Context class badge (Squad/Maniple/Clan/Legion)
+      if (sharedState.activeContextClass && !narrow) {
+        const ctxClass = sharedState.activeContextClass;
+        const ctxColor: ThemeColor = ctxClass === "Legion" ? "accent"
+          : ctxClass === "Clan" ? "muted"
+          : "dim";
+        parts.push(theme.fg(ctxColor, ctxClass));
+      }
+
       if (this.cachedTokens.cost > 0 && !narrow) {
         parts.push(theme.fg("dim", `$${this.cachedTokens.cost.toFixed(3)}`));
       }

package/extensions/design-tree/tree.ts

@@ -5,6 +5,7 @@
  * on the filesystem and return plain data structures.
  */
 
+import * as childProcess from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type {
@@ -94,6 +95,39 @@ export function parseFrontmatter(content: string): Record<string, unknown> | nul
 	return result;
 }
 
+/**
+ * Capture the current jj working copy change ID if in a jj-managed repo.
+ *
+ * The change ID is a permanent identifier that survives rebase and squash.
+ * Unlike git SHAs which change on rewrite, a jj change ID stays the same
+ * no matter how the commit graph is reorganized. This makes it ideal for
+ * binding design tree nodes to their originating context.
+ *
+ * Returns undefined if jj is not available or not in a jj repo.
+ */
+export function captureJjChangeId(repoPath: string): string | undefined {
+	try {
+		// Walk up to find .jj
+		let dir = repoPath;
+		for (let i = 0; i < 10; i++) {
+			if (fs.existsSync(path.join(dir, ".jj"))) break;
+			const parent = path.dirname(dir);
+			if (parent === dir) return undefined;
+			dir = parent;
+		}
+		if (!fs.existsSync(path.join(dir, ".jj"))) return undefined;
+
+		const result = childProcess.execSync(
+			"jj log -r @ --no-graph -T 'change_id'",
+			{ cwd: dir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] },
+		);
+		const id = result.toString().trim();
+		return id || undefined;
+	} catch {
+		return undefined;
+	}
+}
+
 /** Quote a YAML value if it contains special characters */
 export function yamlQuote(value: string): string {
 	if (/[:#\[\]{}&*!|>'"%@`/]/.test(value) || value.startsWith("- ")) {
@@ -134,6 +168,9 @@ export function generateFrontmatter(node: Omit<DesignNode, "filePath" | "lastMod
 	if (node.openspec_change) {
 		fm += `openspec_change: ${node.openspec_change}\n`;
 	}
+	if (node.jj_change_id) {
+		fm += `jj_change_id: ${node.jj_change_id}\n`;
+	}
 	if (node.issue_type) {
 		fm += `issue_type: ${node.issue_type}\n`;
 	}
@@ -649,6 +686,7 @@ export function scanDesignDocs(docsDir: string): DesignTree {
 				branch: validatedBranch,
 				branches: (fm.branches as string[]) || [],
 				openspec_change: fm.openspec_change as string | undefined,
+				jj_change_id: fm.jj_change_id as string | undefined,
 				issue_type,
 				priority,
 				filePath,
@@ -797,6 +835,9 @@ export function createNode(
 		fs.mkdirSync(docsDir, { recursive: true });
 	}
 
+	// Capture jj change ID if in a jj-managed repo
+	const jjChangeId = captureJjChangeId(docsDir);
+
 	const node: Omit<DesignNode, "filePath" | "lastModified"> = {
 		id: opts.id,
 		title: opts.title,
@@ -808,6 +849,7 @@ export function createNode(
 		open_questions: [],
 		branch: undefined,
 		branches: [],
+		jj_change_id: jjChangeId,
 		issue_type: opts.issue_type,
 		priority: opts.priority,
 	};
@@ -855,8 +897,38 @@ export function setNodeStatus(node: DesignNode, newStatus: NodeStatus): DesignNo
 		/^(---\n[\s\S]*?\nstatus:\s*)\S+/m,
 		`$1${newStatus}`,
 	);
+
+	// Capture jj change ID on milestone transitions.
+	// The change ID is permanent — it survives rebase/squash and links
+	// this design decision to the exact point in the commit graph where
+	// it was made. Only update on transitions that represent real milestones.
+	const milestoneStatuses = ["decided", "implemented", "resolved"];
+	if (milestoneStatuses.includes(newStatus)) {
+		const changeId = captureJjChangeId(path.dirname(node.filePath));
+		if (changeId) {
+			if (content.includes("jj_change_id:")) {
+				content = content.replace(
+					/^(jj_change_id:\s*)\S+/m,
+					`$1${changeId}`,
+				);
+			} else {
+				// Insert before the closing ---
+				content = content.replace(
+					/^(---\n[\s\S]*?)(\n---)/m,
+					`$1\njj_change_id: ${changeId}$2`,
+				);
+			}
+		}
+	}
+
 	fs.writeFileSync(node.filePath, content);
-	return { ...node, status: newStatus };
+	return {
+		...node,
+		status: newStatus,
+		jj_change_id: milestoneStatuses.includes(newStatus)
+			? captureJjChangeId(path.dirname(node.filePath)) ?? node.jj_change_id
+			: node.jj_change_id,
+	};
 }
 
 /**

package/extensions/design-tree/types.ts

@@ -140,6 +140,9 @@ export interface DesignNode {
 	branches: string[];
 	/** OpenSpec change name linked to this node */
 	openspec_change?: string;
+	/** jj change ID — permanent identifier that survives rebase/squash.
+	 *  Captured when the node is created or transitions to a key status. */
+	jj_change_id?: string;
 	/** Issue type classification (epic/feature/task/bug/chore) */
 	issue_type?: IssueType;
 	/** Priority from 1 (critical) to 5 (trivial) */

package/extensions/effort/index.ts

@@ -286,6 +286,25 @@ export default function (pi: ExtensionAPI) {
         : state.thinking;
     pi.setThinkingLevel(effectiveThinking as any);
 
+    // ── Initialize context-class routing state ──
+    // Determine the context ceiling of the active model from the route matrix.
+    try {
+      const { initRoutingState } = await import("../lib/routing-state.ts");
+      const { buildRouteMatrixFromRegistry, findEnvelopeForModel } = await import("../lib/route-envelope.ts");
+      const activeModel = restoredModel ?? switchedDriver?.model ?? retainedModel;
+      if (activeModel) {
+        const viable = getViableModels(ctx.modelRegistry);
+        const envelopes = buildRouteMatrixFromRegistry(viable.map((m) => ({ id: m.id, provider: m.provider })));
+        const envelope = findEnvelopeForModel(activeModel.id, activeModel.provider, envelopes);
+        const ceiling = envelope?.contextCeiling ?? 1_000_000; // fallback to Legion
+        const routingCtx = initRoutingState(ceiling);
+        sharedState.routingContext = routingCtx;
+        sharedState.activeContextClass = routingCtx.activeContextClass;
+      }
+    } catch {
+      // Non-critical — context class display is informational
+    }
+
     // Notify operator — suppress the "no model" warning during first-run
     // (bootstrap handles consolidated guidance), but always show when a model
     // is resolved so the operator knows what's driving their session.

package/extensions/lib/context-class.ts

@@ -0,0 +1,90 @@
+/**
+ * Context class taxonomy — named context window categories.
+ *
+ * Three-axis model:
+ *   - Capability tier: local / retribution / victory / gloriana
+ *   - Thinking level: off / minimal / low / medium / high
+ *   - Context class: Squad / Maniple / Clan / Legion  ← this module
+ *
+ * Context classes abstract provider-specific token ceilings into
+ * operator-friendly categories. Internal routing still compares
+ * exact token counts; these classes are the policy and UX abstraction.
+ */
+
+// ─── Context Class Enum ──────────────────────────────────────
+
+export type ContextClass = "Squad" | "Maniple" | "Clan" | "Legion";
+
+/** Ordinal values for comparison. Higher = larger context. */
+const CLASS_ORD: Record<ContextClass, number> = {
+  Squad: 0,
+  Maniple: 1,
+  Clan: 2,
+  Legion: 3,
+};
+
+/**
+ * Token ceiling thresholds defining the upper bound of each class.
+ * A model with contextCeiling ≤ threshold belongs to that class.
+ * Legion has no upper bound.
+ */
+export const CONTEXT_THRESHOLDS: Array<{ class: ContextClass; maxTokens: number }> = [
+  { class: "Squad", maxTokens: 131_072 },    // 128k
+  { class: "Maniple", maxTokens: 278_528 },  // ~272k
+  { class: "Clan", maxTokens: 524_288 },     // ~512k (covers 400k models with headroom)
+  // Legion: everything above
+];
+
+/**
+ * Nominal token count for each class — used for display and floor defaults.
+ */
+export const CONTEXT_CLASS_TOKENS: Record<ContextClass, number> = {
+  Squad: 131_072,
+  Maniple: 278_528,
+  Clan: 409_600,
+  Legion: 1_048_576,
+};
+
+// ─── Classification ──────────────────────────────────────────
+
+/**
+ * Classify a raw token count into a context class.
+ * Uses ceiling thresholds — the token count is placed in the
+ * smallest class whose ceiling it fits under.
+ */
+export function classifyContextWindow(tokenCount: number): ContextClass {
+  for (const { class: cls, maxTokens } of CONTEXT_THRESHOLDS) {
+    if (tokenCount <= maxTokens) return cls;
+  }
+  return "Legion";
+}
+
+/**
+ * Operator-facing label for a context class.
+ */
+export function contextClassLabel(cls: ContextClass): string {
+  const tokens = CONTEXT_CLASS_TOKENS[cls];
+  const display = tokens >= 1_000_000
+    ? `${(tokens / 1_000_000).toFixed(0)}M`
+    : `${Math.round(tokens / 1024)}k`;
+  return `${cls} (${display})`;
+}
+
+/**
+ * Ordinal for comparison. Squad < Maniple < Clan < Legion.
+ */
+export function contextClassOrd(cls: ContextClass): number {
+  return CLASS_ORD[cls];
+}
+
+/**
+ * Compare two context classes. Returns negative if a < b, 0 if equal, positive if a > b.
+ */
+export function compareContextClass(a: ContextClass, b: ContextClass): number {
+  return CLASS_ORD[a] - CLASS_ORD[b];
+}
+
+/**
+ * All context classes in ascending order.
+ */
+export const CONTEXT_CLASSES: readonly ContextClass[] = ["Squad", "Maniple", "Clan", "Legion"];

package/extensions/lib/downgrade-policy.ts

@@ -0,0 +1,182 @@
+/**
+ * Downgrade policy — evaluates whether a model switch is safe.
+ *
+ * Decision flow:
+ *   1. Find compatible routes (ceiling ≥ floor, correct tier)
+ *      → auto-reroute to best compatible
+ *   2. Find compatible-with-compaction routes (compaction bridges the gap)
+ *      → auto-compact if no pinned floor crossed and policy allows
+ *   3. Otherwise → operator-confirm (degrading switch)
+ *
+ * Large multi-class drops (delta ≥ 2) always require operator confirmation.
+ * Pinned floors are never crossed without operator confirmation.
+ */
+
+import type { RoutingSessionState } from "./routing-state.ts";
+import { contextClassDelta } from "./routing-state.ts";
+import {
+  classifyRoute,
+  type RouteEnvelope,
+  type DowngradeClassification,
+} from "./route-envelope.ts";
+import { contextClassOrd, type ContextClass } from "./context-class.ts";
+import type { ProviderRoutingPolicy, ModelTier } from "./model-routing.ts";
+
+// ─── Types ───────────────────────────────────────────────────
+
+export type DowngradeRecommendation =
+  | "auto-reroute"
+  | "auto-compact"
+  | "operator-confirm"
+  | "no-viable-route";
+
+export interface DowngradeEvaluation {
+  recommendation: DowngradeRecommendation;
+  targetRoute?: RouteEnvelope;
+  compactionNeeded?: boolean;
+  contextClassDelta?: number;
+  reason: string;
+}
+
+// ─── Evaluation ──────────────────────────────────────────────
+
+/**
+ * Evaluate the best downgrade path given current state and available routes.
+ *
+ * @param state - Current routing session state
+ * @param candidates - Available route envelopes (filtered to authenticated providers)
+ * @param requiredTier - The tier the session requires
+ * @param policy - Provider routing policy for preference ordering
+ */
+export function evaluateDowngrade(
+  state: RoutingSessionState,
+  candidates: RouteEnvelope[],
+  requiredTier?: ModelTier,
+  policy?: ProviderRoutingPolicy,
+): DowngradeEvaluation {
+  if (candidates.length === 0) {
+    return {
+      recommendation: "no-viable-route",
+      reason: "No candidate routes available.",
+    };
+  }
+
+  // Classify each candidate
+  const classified = candidates.map((envelope) => ({
+    envelope,
+    classification: classifyRoute(
+      envelope,
+      state.requiredMinContextWindow,
+      requiredTier,
+      state.activeContextClass,
+    ),
+  }));
+
+  // Apply provider preference ordering
+  const ordered = policy
+    ? sortByProviderPreference(classified, policy)
+    : classified;
+
+  // 1. Find best compatible route
+  const compatible = ordered.filter((c) => c.classification === "compatible");
+  if (compatible.length > 0) {
+    const best = compatible[0];
+    const delta = contextClassDelta(state.activeContextClass, best.envelope.contextClass);
+
+    // Even compatible routes need confirmation if they're a large class drop
+    if (delta >= 2) {
+      return {
+        recommendation: "operator-confirm",
+        targetRoute: best.envelope,
+        contextClassDelta: delta,
+        reason: `Compatible route available but would drop ${delta} context class${delta > 1 ? "es" : ""} (${state.activeContextClass} → ${best.envelope.contextClass}). Operator confirmation required for large downgrades.`,
+      };
+    }
+
+    return {
+      recommendation: "auto-reroute",
+      targetRoute: best.envelope,
+      contextClassDelta: delta,
+      reason: `Compatible route: ${best.envelope.provider}/${best.envelope.modelIdPattern} (${best.envelope.contextClass}).`,
+    };
+  }
+
+  // 2. Find best compatible-with-compaction route
+  const compactable = ordered.filter((c) => c.classification === "compatible-with-compaction");
+  if (compactable.length > 0) {
+    const best = compactable[0];
+    const delta = contextClassDelta(state.activeContextClass, best.envelope.contextClass);
+
+    // Pinned floor check — never compact below pinned floor
+    if (state.pinnedFloor) {
+      const pinnedOrd = contextClassOrd(state.pinnedFloor);
+      const candidateOrd = contextClassOrd(best.envelope.contextClass);
+      if (candidateOrd < pinnedOrd) {
+        return {
+          recommendation: "operator-confirm",
+          targetRoute: best.envelope,
+          compactionNeeded: true,
+          contextClassDelta: delta,
+          reason: `Compaction would drop below pinned floor (${state.pinnedFloor}). Candidate: ${best.envelope.contextClass}. Operator confirmation required.`,
+        };
+      }
+    }
+
+    // Large class drops need confirmation even with compaction
+    if (delta >= 2) {
+      return {
+        recommendation: "operator-confirm",
+        targetRoute: best.envelope,
+        compactionNeeded: true,
+        contextClassDelta: delta,
+        reason: `Compaction needed with ${delta}-class drop (${state.activeContextClass} → ${best.envelope.contextClass}). Operator confirmation required.`,
+      };
+    }
+
+    return {
+      recommendation: "auto-compact",
+      targetRoute: best.envelope,
+      compactionNeeded: true,
+      contextClassDelta: delta,
+      reason: `Safe compaction available: ${best.envelope.provider}/${best.envelope.modelIdPattern} (${best.envelope.contextClass}).`,
+    };
+  }
+
+  // 3. Find best degrading route (needs operator confirmation)
+  const degrading = ordered.filter((c) => c.classification === "degrading");
+  if (degrading.length > 0) {
+    const best = degrading[0];
+    const delta = contextClassDelta(state.activeContextClass, best.envelope.contextClass);
+    return {
+      recommendation: "operator-confirm",
+      targetRoute: best.envelope,
+      compactionNeeded: true,
+      contextClassDelta: delta,
+      reason: `No safe route available. Best candidate: ${best.envelope.provider}/${best.envelope.modelIdPattern} (${best.envelope.contextClass}), ${delta}-class drop from ${state.activeContextClass}. Operator confirmation required.`,
+    };
+  }
+
+  // All routes ineligible
+  return {
+    recommendation: "no-viable-route",
+    reason: `All ${candidates.length} candidate routes are ineligible (tier/thinking mismatch or other policy constraint).`,
+  };
+}
+
+// ─── Helpers ─────────────────────────────────────────────────
+
+function sortByProviderPreference<T extends { envelope: RouteEnvelope }>(
+  items: T[],
+  policy: ProviderRoutingPolicy,
+): T[] {
+  const providerRank = new Map(
+    policy.providerOrder.map((p, i) => [p, i]),
+  );
+  return [...items].sort((a, b) => {
+    const aRank = providerRank.get(a.envelope.provider) ?? Number.MAX_SAFE_INTEGER;
+    const bRank = providerRank.get(b.envelope.provider) ?? Number.MAX_SAFE_INTEGER;
+    if (aRank !== bRank) return aRank - bRank;
+    // Within same provider, prefer larger context
+    return b.envelope.contextCeiling - a.envelope.contextCeiling;
+  });
+}