omegon 0.6.3 → 0.6.4

package/extensions/design-tree/index.ts

@@ -17,18 +17,18 @@
  *   ## Overview | ## Research | ## Decisions | ## Open Questions | ## Implementation Notes
  */
 
-import type { ExtensionAPI, ExtensionContext } from "@cwilson613/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@styrene-lab/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
 import { StringEnum } from "../lib/typebox-helpers.ts";
-import { Text } from "@cwilson613/pi-tui";
+import { Text } from "@styrene-lab/pi-tui";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { execFileSync } from "node:child_process";
 import { shouldRefreshDesignTreeForPath } from "../dashboard/file-watch.ts";
-import { sharedState } from "../shared-state.ts";
+import { sharedState } from "../lib/shared-state.ts";
 
 import { emitDesignTreeState } from "./dashboard-state.ts";
-import { sciCall, sciLoading, sciOk, sciErr, sciExpanded, sciBanner } from "../sci-ui.ts";
+import { sciCall, sciLoading, sciOk, sciErr, sciExpanded, sciBanner } from "../lib/sci-ui.ts";
 import { SciDesignCard, buildCardDetails } from "./design-card.ts";
 import type { DesignCardDetails } from "./design-card.ts";
 import { emitConstraintCandidates, emitDecisionCandidates } from "./lifecycle-emitter.ts";
@@ -338,7 +338,7 @@ export default function designTreeExtension(pi: ExtensionAPI): void {
 							boundToOpenSpec: binding.bound,
 							// Normalized binding status from canonical resolver
 							bindingStatus: lifecycleSummary?.bindingStatus ?? (binding.bound ? "bound" : "unbound"),
-							canImplement: node.status === "decided",
+							canImplement: node.status === "decided" || node.status === "resolved",
 							isImplementationPhase: node.status === "implementing" || node.status === "implemented",
 							reopenSignalTarget: binding.changeName ?? node.openspec_change ?? node.id,
 							// Canonical lifecycle fields from resolveLifecycleSummary when available
@@ -435,7 +435,7 @@ export default function designTreeExtension(pi: ExtensionAPI): void {
 					// AND design-phase OpenSpec change is archived.
 					const readyNodes = Array.from(tree.nodes.values())
 						.filter((n) => {
-							if (n.status !== "decided") return false;
+							if (n.status !== "decided" && n.status !== "resolved") return false;
 							// Hard gate: design spec must be archived
 							const specBinding = resolveDesignSpecBinding(ctx.cwd, n.id);
 							if (!specBinding.archived) return false;
@@ -668,7 +668,7 @@ export default function designTreeExtension(pi: ExtensionAPI): void {
 			"set focus, or bridge to OpenSpec for implementation.\n\n" +
 			"Actions:\n" +
 			"- create: Create a new design node (id, title required; parent, status, tags, overview optional)\n" +
-			"- set_status: Change node status (seed/exploring/decided/blocked/deferred)\n" +
+			"- set_status: Change node status (seed/exploring/resolved/decided/blocked/deferred)\n" +
 			"- add_question: Add an open question to a node\n" +
 			"- remove_question: Remove an open question by text\n" +
 			"- add_research: Add a research entry (heading + content)\n" +
@@ -686,7 +686,7 @@ export default function designTreeExtension(pi: ExtensionAPI): void {
 			"Mutate the design tree — create nodes, set status, add research/decisions/questions, branch, implement",
 		promptGuidelines: [
 			"Use 'create' to start a new design exploration. Status defaults to 'seed'.",
-			"Use 'set_status' to transition nodes: seed → exploring → decided. Use 'blocked' or 'deferred' as needed.",
+			"Use 'set_status' to transition nodes: seed → exploring → resolved → decided. Use 'resolved' when design questions are answered but the formal lifecycle gate hasn't cleared. Use 'blocked' or 'deferred' as needed.",
 			"Use 'add_question' when discussion reveals unknowns. Use 'remove_question' when questions are answered.",
 			"Use 'add_research' to record findings with a heading and content.",
 			"Use 'add_decision' to crystallize choices with title, status (exploring/decided/rejected), and rationale.",
@@ -799,21 +799,31 @@ export default function designTreeExtension(pi: ExtensionAPI): void {
 					const oldStatus = node.status;
 
 					// Hard gate: set_status(decided) requires archived design spec.
+					// Exception: bug/chore/task nodes with no open questions can skip
+					// the design-phase ceremony — the decision IS the diagnosis.
 					if (newStatus === "decided") {
-						const designSpec = resolveDesignSpecBinding(ctx.cwd, node.id);
-						if (designSpec.missing) {
-							return {
-								content: [{ type: "text", text: `Cannot mark '${node.title}' decided: scaffold design spec first via set_status(exploring).` }],
-								details: { id: node.id, blockedBy: "design-openspec-missing" },
-								isError: true,
-							};
-						}
-						if (designSpec.active && !designSpec.archived) {
-							return {
-								content: [{ type: "text", text: `Cannot mark '${node.title}' decided: run /assess design then archive the design change before marking decided.` }],
-								details: { id: node.id, blockedBy: "design-openspec-not-archived" },
-								isError: true,
-							};
+						const lightweightTypes = new Set(["bug", "chore", "task"]);
+						const isLightweight = node.issue_type && lightweightTypes.has(node.issue_type);
+						const hasOpenQuestions = (node.open_questions?.length ?? 0) > 0;
+
+						// Lightweight nodes: allow decided if no open questions remain,
+						// regardless of design-phase spec state.
+						if (!(isLightweight && !hasOpenQuestions)) {
+							const designSpec = resolveDesignSpecBinding(ctx.cwd, node.id);
+							if (designSpec.missing) {
+								return {
+									content: [{ type: "text", text: `Cannot mark '${node.title}' decided: scaffold design spec first via set_status(exploring).` }],
+									details: { id: node.id, blockedBy: "design-openspec-missing" },
+									isError: true,
+								};
+							}
+							if (designSpec.active && !designSpec.archived) {
+								return {
+									content: [{ type: "text", text: `Cannot mark '${node.title}' decided: run \`/assess design ${node.id}\` then archive the design change before marking decided.` }],
+									details: { id: node.id, blockedBy: "design-openspec-not-archived" },
+									isError: true,
+								};
+							}
 						}
 					}
 
@@ -1125,12 +1135,12 @@ export default function designTreeExtension(pi: ExtensionAPI): void {
 					if (!node) {
 						return { content: [{ type: "text", text: `Node '${params.node_id}' not found` }], details: {}, isError: true };
 					}
-					if (node.status !== "decided") {
+					if (node.status !== "decided" && node.status !== "resolved") {
 						return {
 							content: [{
 								type: "text",
-								text: `Node '${node.title}' is '${node.status}', not 'decided'. ` +
-									`Resolve open questions and set status to 'decided' before implementing.`,
+								text: `Node '${node.title}' is '${node.status}', not 'decided' or 'resolved'. ` +
+									`Resolve open questions and set status to 'decided' (or 'resolved') before implementing.`,
 							}],
 							details: {},
 							isError: true,
@@ -1138,21 +1148,31 @@ export default function designTreeExtension(pi: ExtensionAPI): void {
 					}
 
 					// Hard gate: design-phase spec must be archived before implementation.
+					// Exception: bug/chore/task nodes that are already decided with no
+					// open questions can proceed directly — they don't need a design-phase
+					// spec because the decision is the bug diagnosis itself.
 					{
-						const designSpec = resolveDesignSpecBinding(ctx.cwd, node.id);
-						if (designSpec.missing) {
-							return {
-								content: [{ type: "text", text: "Scaffold design spec first via set_status(exploring)" }],
-								details: { id: node.id, blockedBy: "design-openspec-missing" },
-								isError: true,
-							};
-						}
-						if (designSpec.active && !designSpec.archived) {
-							return {
-								content: [{ type: "text", text: `Cannot implement '${node.title}': archive the design change first (/opsx:archive on the design change).` }],
-								details: { id: node.id, blockedBy: "design-openspec-not-archived" },
-								isError: true,
-							};
+						const lightweightTypes = new Set(["bug", "chore", "task"]);
+						const isLightweight = node.issue_type && lightweightTypes.has(node.issue_type);
+						const hasOpenQuestions = (node.open_questions?.length ?? 0) > 0;
+						const skipDesignGate = isLightweight && !hasOpenQuestions && (node.status === "decided" || node.status === "resolved");
+
+						if (!skipDesignGate) {
+							const designSpec = resolveDesignSpecBinding(ctx.cwd, node.id);
+							if (designSpec.missing) {
+								return {
+									content: [{ type: "text", text: "Scaffold design spec first via set_status(exploring)" }],
+									details: { id: node.id, blockedBy: "design-openspec-missing" },
+									isError: true,
+								};
+							}
+							if (designSpec.active && !designSpec.archived) {
+								return {
+									content: [{ type: "text", text: `Cannot implement '${node.title}': archive the design change first (\`/opsx:archive\` on the design change).` }],
+									details: { id: node.id, blockedBy: "design-openspec-not-archived" },
+									isError: true,
+								};
+							}
 						}
 					}
 
@@ -1367,7 +1387,7 @@ export default function designTreeExtension(pi: ExtensionAPI): void {
 						return;
 					}
 					const total = tree.nodes.size;
-					const decided = Array.from(tree.nodes.values()).filter((n) => n.status === "decided").length;
+					const decided = Array.from(tree.nodes.values()).filter((n) => n.status === "decided" || n.status === "resolved").length;
 					const exploring = Array.from(tree.nodes.values()).filter(
 						(n) => n.status === "exploring" || n.status === "seed",
 					).length;
@@ -1658,9 +1678,9 @@ export default function designTreeExtension(pi: ExtensionAPI): void {
 						ctx.ui.notify(`Node '${id}' not found`, "error");
 						return;
 					}
-					if (node.status !== "decided") {
+					if (node.status !== "decided" && node.status !== "resolved") {
 						ctx.ui.notify(
-							`'${node.title}' is '${node.status}', not 'decided'. Resolve questions first.`,
+							`'${node.title}' is '${node.status}', not 'decided'/'resolved'. Resolve questions first.`,
 							"warning",
 						);
 						return;
@@ -1765,7 +1785,7 @@ export default function designTreeExtension(pi: ExtensionAPI): void {
 
 		const implemented = Array.from(tree.nodes.values()).filter((n) => n.status === "implemented").length;
 		const implementing = Array.from(tree.nodes.values()).filter((n) => n.status === "implementing").length;
-		const decided = Array.from(tree.nodes.values()).filter((n) => n.status === "decided").length;
+		const decided = Array.from(tree.nodes.values()).filter((n) => n.status === "decided" || n.status === "resolved").length;
 		const exploring = Array.from(tree.nodes.values()).filter(
 			(n) => n.status === "exploring" || n.status === "seed",
 		).length;
@@ -1956,7 +1976,7 @@ export default function designTreeExtension(pi: ExtensionAPI): void {
 			if (status === "implemented" || status === "deferred") {
 				toMigrate.push(entry);
 			} else {
-				// seed, exploring, decided, blocked — leave in docs/
+				// seed, exploring, resolved, decided, blocked — leave in docs/
 				activeExplorations.push(entry);
 			}
 		}

package/extensions/design-tree/types.ts

@@ -4,13 +4,14 @@
 
 // ─── Node Status ─────────────────────────────────────────────────────────────
 
-export type NodeStatus = "seed" | "exploring" | "decided" | "implementing" | "implemented" | "blocked" | "deferred";
+export type NodeStatus = "seed" | "exploring" | "resolved" | "decided" | "implementing" | "implemented" | "blocked" | "deferred";
 
-export const VALID_STATUSES: NodeStatus[] = ["seed", "exploring", "decided", "implementing", "implemented", "blocked", "deferred"];
+export const VALID_STATUSES: NodeStatus[] = ["seed", "exploring", "resolved", "decided", "implementing", "implemented", "blocked", "deferred"];
 
 export const STATUS_ICONS: Record<NodeStatus, string> = {
 	seed: "◌",
 	exploring: "◐",
+	resolved: "◉",
 	decided: "●",
 	implementing: "⚙",
 	implemented: "✓",
@@ -21,6 +22,7 @@ export const STATUS_ICONS: Record<NodeStatus, string> = {
 export const STATUS_COLORS: Record<NodeStatus, string> = {
 	seed: "muted",
 	exploring: "accent",
+	resolved: "success",
 	decided: "success",
 	implementing: "accent",
 	implemented: "success",

package/extensions/distill.ts

@@ -11,7 +11,7 @@
 
 import { existsSync, mkdirSync } from "node:fs";
 import { join, basename } from "node:path";
-import type { ExtensionAPI } from "@cwilson613/pi-coding-agent";
+import type { ExtensionAPI } from "@styrene-lab/pi-coding-agent";
 
 export default function distillExtension(pi: ExtensionAPI) {
 

package/extensions/effort/index.ts

@@ -16,24 +16,28 @@
  *   /effort uncap     — Remove ceiling lock
  */
 
-import type { ExtensionAPI, ExtensionContext } from "@cwilson613/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@styrene-lab/pi-coding-agent";
 import { readFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 
 import type { EffortLevel, EffortState, EffortModelTier, ThinkingLevel } from "./types.ts";
 import { EFFORT_NAMES } from "./types.ts";
 import { tierConfig, parseTierName, DEFAULT_EFFORT_LEVEL, TIER_NAMES } from "./tiers.ts";
-import { sharedState, DASHBOARD_UPDATE_EVENT } from "../shared-state.ts";
+import { sharedState, DASHBOARD_UPDATE_EVENT } from "../lib/shared-state.ts";
 import {
   resolveTier,
   getTierDisplayLabel,
   getDefaultPolicy,
+  getViableModels,
+  buildProviderSummary,
+  matchTierUniversal as matchTierUniversalExport,
   clampThinkingLevel,
   type ModelTier,
   type RegistryModel,
 } from "../lib/model-routing.ts";
 import { readLastUsedModel, writeLastUsedModel } from "../lib/model-preferences.ts";
 import { readOperatorProfile, loadOperatorRuntimeState, toCapabilityProfile, toCapabilityRuntimeState } from "../lib/operator-profile.ts";
+import { PROVIDER_ENV_VARS, getProviderRemediationHint } from "../lib/provider-env.ts";
 
 // ─── Constants ───────────────────────────────────────────────
 
@@ -72,7 +76,7 @@ async function switchDriverModel(
   driver: EffortModelTier,
 ): Promise<{ model: RegistryModel; maxThinking?: ThinkingLevel } | null> {
   // Snapshot the registry once; both resolveTier and the model lookup use it
-  const all = ctx.modelRegistry.getAll() as unknown as RegistryModel[];
+  const all = getViableModels(ctx.modelRegistry);
   // Build O(1) index over the same snapshot — no second linear scan (C3)
   const byKey = new Map(all.map((m) => [`${m.provider}/${m.id}`, m]));
   const { policy, profile, runtimeState } = getResolverInputs(ctx);
@@ -113,7 +117,7 @@ function resolveExtractionTier(
   ctx: ExtensionContext,
 ): { displayTier: string; resolvedModelId?: string } {
   const { policy, profile, runtimeState } = getResolverInputs(ctx);
-  const all = ctx.modelRegistry.getAll() as unknown as RegistryModel[];
+  const all = getViableModels(ctx.modelRegistry);
 
   // Determine effective tier: upgrade local→retribution when policy prefers cheap cloud
   const effectiveTier: ModelTier =
@@ -247,7 +251,25 @@ export default function (pi: ExtensionAPI) {
     // current startup model rather than warning about an unusable session when
     // a working driver is already present.
     const restoredModel = await restoreLastUsedModel(pi, ctx);
-    const switchedDriver = restoredModel ? null : await switchDriverModel(pi, ctx, state.driver);
+    let switchedDriver = restoredModel ? null : await switchDriverModel(pi, ctx, state.driver);
+
+    // Degradation cascade: if the preferred tier failed, try adjacent tiers
+    // before settling on whatever pi defaulted to (which may be deprecated).
+    // Order: victory→gloriana→retribution, gloriana→victory, retribution→victory.
+    if (!restoredModel && !switchedDriver) {
+      const DEGRADATION_CASCADE: Record<string, ModelTier[]> = {
+        victory: ["gloriana", "retribution"],
+        gloriana: ["victory"],
+        retribution: ["victory"],
+        local: [],
+      };
+      const fallbacks = DEGRADATION_CASCADE[state.driver] ?? [];
+      for (const fallbackTier of fallbacks) {
+        switchedDriver = await switchDriverModel(pi, ctx, fallbackTier);
+        if (switchedDriver) break;
+      }
+    }
+
     const retainedModel = !restoredModel && !switchedDriver && ctx.model ? ctx.model : null;
 
     // Set thinking level, respecting candidate ceilings when the effort-driven
@@ -259,8 +281,11 @@ export default function (pi: ExtensionAPI) {
         : state.thinking;
     pi.setThinkingLevel(effectiveThinking as any);
 
-    // Notify operator
+    // 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.
     const icon = TIER_ICONS[state.level];
+    const hasModel = !!(restoredModel || switchedDriver || retainedModel);
     const modelNote = restoredModel
       ? ` → restored ${restoredModel.provider}/${restoredModel.id}`
       : switchedDriver
@@ -268,10 +293,112 @@ export default function (pi: ExtensionAPI) {
         : retainedModel
           ? ` → kept ${retainedModel.provider}/${retainedModel.id} (preferred ${state.driver} unavailable)`
           : " (driver model unavailable)";
-    ctx.ui.notify(
-      `${icon} Effort: ${state.name} (${state.driver}/${effectiveThinking})${modelNote}`,
-      restoredModel || switchedDriver || retainedModel ? "info" : "warning",
-    );
+    if (hasModel || !sharedState.bootstrapPending) {
+      ctx.ui.notify(
+        `${icon} Effort: ${state.name} (${state.driver}/${effectiveThinking})${modelNote}`,
+        hasModel ? "info" : "warning",
+      );
+    }
+
+    // Provider summary — show what tiers are available
+    try {
+      const allModels = ctx.modelRegistry.getAll() as unknown as RegistryModel[];
+      const viable = getViableModels(ctx.modelRegistry);
+      const policy = sharedState.routingPolicy ?? getDefaultPolicy();
+      const summary = buildProviderSummary(allModels, viable, policy);
+
+      if (summary.level === 0 && !sharedState.bootstrapPending) {
+        ctx.ui.notify("⚠ No providers configured. Run /bootstrap or /providers for setup hints.", "warning");
+      } else if (summary.level < 3) {
+        const parts: string[] = [];
+        for (const t of summary.tiers) {
+          const icon = t.status === "operational" ? "●" : t.status === "degraded" ? "◐" : "○";
+          const detail = t.topCandidate ? ` ${t.topCandidate.provider}/${t.topCandidate.modelId}` : "";
+          parts.push(`${icon} ${getTierDisplayLabel(t.tier)}${detail}`);
+        }
+        ctx.ui.notify(`Routing: ${parts.join("  ")}`, "info");
+      }
+      // level 3 (all operational) = silent — no need to clutter startup
+    } catch {
+      // Non-critical — don't break startup
+    }
+  });
+
+  // ── /providers command ──
+
+  pi.registerCommand("providers", {
+    description: "Show provider auth status and tier routing summary",
+    handler: async (_args, ctx) => {
+      const allModels = ctx.modelRegistry.getAll() as unknown as RegistryModel[];
+      const viable = getViableModels(ctx.modelRegistry);
+      const policy = sharedState.routingPolicy ?? getDefaultPolicy();
+      const summary = buildProviderSummary(allModels, viable, policy);
+
+      const lines: string[] = [];
+
+      // Auth status
+      if (summary.authProviders.length > 0) {
+        lines.push(`**Auth configured:** ${summary.authProviders.join(", ")}`);
+      }
+      if (summary.unauthProviders.length > 0) {
+        const top = summary.unauthProviders.slice(0, 8);
+        const more = summary.unauthProviders.length > 8 ? ` (+${summary.unauthProviders.length - 8} more)` : "";
+        lines.push(`**No auth:** ${top.join(", ")}${more}`);
+      }
+      lines.push("");
+
+      // Tier table
+      lines.push("| Tier | Status | Provider | Model |");
+      lines.push("|------|--------|----------|-------|");
+      for (const t of summary.tiers) {
+        const icon = t.status === "operational" ? "●" : t.status === "degraded" ? "◐" : "○";
+        const status = `${icon} ${t.status}`;
+        const provider = t.topCandidate?.provider ?? "—";
+        const model = t.topCandidate?.modelId ?? "—";
+        lines.push(`| ${getTierDisplayLabel(t.tier)} | ${status} | ${provider} | ${model} |`);
+      }
+      lines.push("");
+
+      // Candidate detail
+      for (const t of summary.tiers) {
+        if (t.candidateCount > 1) {
+          const matches = matchTierUniversalExport(viable, t.tier);
+          const candidateList = matches.slice(0, 5).map((m) => `${m.model.provider}/${m.model.id}`).join(", ");
+          const more = matches.length > 5 ? ` (+${matches.length - 5} more)` : "";
+          lines.push(`**${getTierDisplayLabel(t.tier)} candidates:** ${candidateList}${more}`);
+        }
+      }
+
+      // Remediation hints for unconfigured providers that could improve coverage
+      const impairedTiers = summary.tiers.filter(t => t.status === "unavailable" || t.status === "degraded");
+      if (impairedTiers.length > 0 && summary.unauthProviders.length > 0) {
+        const hintLines: string[] = [];
+        const shown = new Set<string>();
+        for (const provider of summary.unauthProviders) {
+          if (shown.size >= 5) break;
+          const hint = getProviderRemediationHint(provider);
+          if (hint && !shown.has(provider)) {
+            shown.add(provider);
+            const entry = PROVIDER_ENV_VARS[provider];
+            const desc = entry?.description ?? provider;
+            hintLines.push(`  ${provider} (${desc}): ${hint}`);
+          }
+        }
+        if (hintLines.length > 0) {
+          lines.push("**To configure providers:**");
+          lines.push(...hintLines);
+          lines.push("");
+        }
+      }
+
+      lines.push(`**Headline:** ${summary.headline}`);
+
+      pi.sendMessage({
+        customType: "provider-summary",
+        content: lines.join("\n"),
+        display: true,
+      });
+    },
   });
 
   // ── /effort command ──