supipowers 1.2.6 → 1.5.0

package/src/commands/release.ts

@@ -2,16 +2,34 @@ import type { Platform } from "../platform/types.js";
 import { modelRegistry } from "../config/model-registry-instance.js";
 import { resolveModelForAction, createModelBridge, applyModelOverride } from "../config/model-resolver.js";
 import { loadModelConfig } from "../config/model-config.js";
-import type { ReleaseChannel, BumpType } from "../types.js";
+import type { ReleaseChannel, BumpType, ReviewReport, ResolvedModel } from "../types.js";
 import { loadConfig, updateConfig } from "../config/loader.js";
 import { detectChannels } from "../release/detector.js";
+import type { ChannelStatus } from "../release/channels/types.js";
 import { parseConventionalCommits, buildChangelogMarkdown, summarizeChanges } from "../release/changelog.js";
-import { getCurrentVersion, suggestBump, bumpVersion, isVersionReleased, isTagOnRemote } from "../release/version.js";
+import {
+  getCurrentVersion,
+  suggestBump,
+  bumpVersion,
+  isVersionReleased,
+  isTagOnRemote,
+  findResumableLocalRelease,
+  formatTag,
+} from "../release/version.js";
 import { executeRelease, type ReleaseProgressFn } from "../release/executor.js";
 import { buildPolishPrompt } from "../release/prompt.js";
 import { notifyInfo, notifySuccess, notifyError } from "../notifications/renderer.js";
 import { analyzeAndCommit } from "../git/commit.js";
 import { getWorkingTreeStatus } from "../git/status.js";
+import { runStructuredAgentSession } from "../quality/ai-session.js";
+import {
+  checkDocDrift,
+  buildFixPrompt,
+} from "../docs/drift.js";
+import { runQualityGates } from "../quality/runner.js";
+import { REVIEW_GATE_REGISTRY } from "../quality/review-gates.js";
+import { GATE_DISPLAY_NAMES } from "../quality/registry.js";
+import { createWorkflowProgress } from "../platform/progress.js";
 
 modelRegistry.register({
   id: "release",
@@ -20,10 +38,6 @@ modelRegistry.register({
   harnessRoleHint: "slow",
 });
 
-const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-const STATUS_KEY = "supi-release";
-const WIDGET_KEY = "supi-release";
-
 const BUMP_OPTIONS = [
   "patch — bug fixes only",
   "minor — new features, backwards compatible",
@@ -37,8 +51,7 @@ const BUMP_OPTIONS = [
  * This is the resume path: the version in package.json hasn't been tagged yet
  * AND all channels are already configured — the user staged the release
  * deliberately when they bumped the version, so no new decisions are needed.
- * Dry-run is excluded because it is exploratory by intent; the user explicitly
- * wants to preview and confirm before anything happens.
+ * Dry-run is excluded because it is exploratory by intent.
  */
 export function isInProgressRelease(opts: {
   skipBump: boolean;
@@ -48,131 +61,189 @@ export function isInProgressRelease(opts: {
   return opts.skipBump && opts.channelsWerePreConfigured && !opts.isDryRun;
 }
 
-// ── Release progress tracker ────────────────────────────────────
+export function findInvalidReleaseChannels(
+  channels: ReleaseChannel[],
+  detected: ChannelStatus[],
+): string[] {
+  const detectedById = new Map(detected.map((status) => [status.channel, status]));
+
+  return channels.flatMap((channel) => {
+    const status = detectedById.get(channel);
+    if (!status) {
+      return [`${channel}: unknown channel`];
+    }
+    if (!status.available) {
+      return [`${channel}: unavailable (${status.detail})`];
+    }
+    return [];
+  });
+}
 
-interface ReleaseStep {
-  label: string;
-  status: "pending" | "active" | "done" | "error" | "skipped";
-  detail?: string;
+export function buildSelectableReleaseChannelOptions(detected: ChannelStatus[]): string[] {
+  return detected
+    .filter((channel) => channel.available)
+    .map((channel) => `${channel.channel} — ${channel.detail}`);
 }
 
-function createReleaseProgress(ctx: any) {
-  const steps: ReleaseStep[] = [
-    { label: "Check working tree", status: "pending" },
-    { label: "Detect channels", status: "pending" },
-    { label: "Analyze commits", status: "pending" },
-    { label: "Select version", status: "pending" },
-    { label: "Build changelog", status: "pending" },
-    { label: "Execute release", status: "pending" },
-    { label: "Publish channels", status: "pending" },
-  ];
-
-  let frame = 0;
-  let statusDetail = "";
-  let timer: ReturnType<typeof setInterval> | null = null;
-
-  function icon(step: ReleaseStep): string {
-    switch (step.status) {
-      case "done":    return "✓";
-      case "active":  return SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
-      case "error":   return "✗";
-      case "skipped": return "–";
-      default:        return "○";
-    }
+interface GitHubAuthAccount {
+  host: string;
+  user: string;
+  active: boolean;
+}
+
+export function isGitHubPermissionDeniedError(detail: string | undefined): boolean {
+  if (!detail) {
+    return false;
   }
 
-  function renderWidget(): string[] {
-    const lines: string[] = ["┌─ supi:release ─────────────────────┐"];
-    for (const step of steps) {
-      const mark = icon(step);
-      const detail = step.detail ? ` (${step.detail})` : "";
-      lines.push(`│ ${mark} ${step.label}${detail}`);
+  const normalized = detail.toLowerCase();
+  return normalized.includes("github.com")
+    && normalized.includes("403")
+    && (normalized.includes("permission to") || normalized.includes("denied to"));
+}
+
+export function parseGithubAuthStatusAccounts(output: string, host = "github.com"): GitHubAuthAccount[] {
+  const accounts: GitHubAuthAccount[] = [];
+  let currentAccount: GitHubAuthAccount | null = null;
+
+  for (const rawLine of output.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) {
+      continue;
     }
-    lines.push("└─────────────────────────────────────┘");
-    return lines;
-  }
 
-  function refresh() {
-    frame++;
-    ctx.ui.setWidget?.(WIDGET_KEY, renderWidget());
-    if (statusDetail) {
-      ctx.ui.setStatus?.(STATUS_KEY, `${SPINNER_FRAMES[frame % SPINNER_FRAMES.length]} ${statusDetail}`);
+    const accountMatch = line.match(/^✓ Logged in to (\S+) account ([^(]+?) \(/);
+    if (accountMatch) {
+      currentAccount = {
+        host: accountMatch[1] ?? "",
+        user: (accountMatch[2] ?? "").trim(),
+        active: false,
+      };
+      if (currentAccount.host === host) {
+        accounts.push(currentAccount);
+      } else {
+        currentAccount = null;
+      }
+      continue;
     }
-  }
 
-  function startTimer() {
-    if (!timer) {
-      timer = setInterval(refresh, 80);
+    if (currentAccount && line.startsWith("- Active account:")) {
+      currentAccount.active = line.endsWith("true");
     }
   }
 
-  function stopTimer() {
-    if (timer) {
-      clearInterval(timer);
-      timer = null;
-    }
+  return accounts;
+}
+
+export async function maybeSwitchGithubAccountForReleaseFailure(
+  platform: Pick<Platform, "exec">,
+  ctx: { cwd: string; ui: { select: (title: string, options: string[], opts?: { helpText?: string }) => Promise<string | null>; notify?: (message: string, type?: string) => void } },
+  detail: string | undefined,
+): Promise<string | null> {
+  if (!isGitHubPermissionDeniedError(detail)) {
+    return null;
   }
 
-  return {
-    activate(stepIndex: number, detail?: string) {
-      const step = steps[stepIndex];
-      if (step) {
-        step.status = "active";
-        step.detail = detail;
-      }
-      statusDetail = detail ?? step?.label ?? "";
-      startTimer();
-      refresh();
-    },
+  const statusResult = await platform.exec("gh", ["auth", "status", "--hostname", "github.com"], { cwd: ctx.cwd });
+  if (statusResult.code !== 0) {
+    return null;
+  }
 
-    complete(stepIndex: number, detail?: string) {
-      const step = steps[stepIndex];
-      if (step) {
-        step.status = "done";
-        if (detail !== undefined) step.detail = detail;
-      }
-      refresh();
-    },
+  const accounts = parseGithubAuthStatusAccounts(`${statusResult.stdout}\n${statusResult.stderr}`);
+  if (accounts.length < 2) {
+    return null;
+  }
 
-    fail(stepIndex: number, detail?: string) {
-      const step = steps[stepIndex];
-      if (step) {
-        step.status = "error";
-        if (detail !== undefined) step.detail = detail;
-      }
-      refresh();
-    },
+  const deniedUser = detail?.match(/denied to\s+([A-Za-z0-9-]+)/i)?.[1] ?? null;
+  const options = accounts.map((account) => {
+    const suffix: string[] = [];
+    if (account.active) suffix.push("current");
+    if (deniedUser && account.user === deniedUser) suffix.push("denied here");
+    return suffix.length > 0 ? `${account.user} — ${suffix.join(", ")}` : account.user;
+  });
 
-    skip(stepIndex: number, detail?: string) {
-      const step = steps[stepIndex];
-      if (step) {
-        step.status = "skipped";
-        if (detail !== undefined) step.detail = detail;
-      }
-      refresh();
+  const choice = await ctx.ui.select(
+    "GitHub account mismatch detected",
+    options,
+    {
+      helpText: deniedUser
+        ? `GitHub denied the current release with account ${deniedUser}. Choose another authenticated GitHub account to retry the release.`
+        : "GitHub denied the current release. Choose another authenticated GitHub account to retry.",
     },
+  );
+  if (!choice) {
+    return null;
+  }
+
+  const selectedUser = choice.split(" — ")[0] ?? choice;
+  const switchResult = await platform.exec(
+    "gh",
+    ["auth", "switch", "--hostname", "github.com", "--user", selectedUser],
+    { cwd: ctx.cwd },
+  );
+  if (switchResult.code !== 0) {
+    ctx.ui.notify?.(`GitHub account switch failed: ${switchResult.stderr || switchResult.stdout || "unknown error"}`, "error");
+    return null;
+  }
+
+  return selectedUser;
+}
 
+
+export const RELEASE_STEPS = [
+  { key: "checks", label: "Quality checks" },
+  { key: "doc-drift", label: "Check documentation drift" },
+  { key: "working-tree", label: "Check working tree" },
+  { key: "channels", label: "Detect channels" },
+  { key: "commits", label: "Analyze commits" },
+  { key: "version", label: "Select version" },
+  { key: "changelog", label: "Build changelog" },
+  { key: "polish", label: "Polish release notes" },
+  { key: "execute", label: "Execute release" },
+  { key: "publish", label: "Publish channels" },
+] as const;
+
+type ReleaseStepKey = (typeof RELEASE_STEPS)[number]["key"];
+
+function createReleaseProgress(ctx: any) {
+  const progress = createWorkflowProgress(ctx.ui, {
+    title: "supi:release",
+    statusKey: "supi-release",
+    statusLabel: "Releasing...",
+    widgetKey: "supi-release",
+    clearStatusKeys: ["supi-model"],
+    steps: [...RELEASE_STEPS],
+  });
+
+  return {
+    activate(key: ReleaseStepKey, detail?: string) {
+      progress.activate(key, detail);
+    },
+    complete(key: ReleaseStepKey, detail?: string) {
+      progress.complete(key, detail);
+    },
+    fail(key: ReleaseStepKey, detail?: string) {
+      progress.fail(key, detail);
+    },
+    skip(key: ReleaseStepKey, detail?: string) {
+      progress.skip(key, detail);
+    },
+    detail(text: string) {
+      progress.detail(text);
+    },
     /** Build an onProgress callback for executeRelease. */
     executorProgress(): ReleaseProgressFn {
       return (step, status, detail) => {
-        // Map executor steps to sub-detail on "Execute release" (index 5)
-        // or "Publish channels" (index 6)
         const isPublish = step.startsWith("publish-");
-        const idx = isPublish ? 6 : 5;
-        if (status === "active") this.activate(idx, detail);
+        const key: ReleaseStepKey = isPublish ? "publish" : "execute";
+        if (status === "active") this.activate(key, detail);
         else if (status === "done") {
-          // Don't mark the overall step done from individual sub-steps
-          const s = steps[idx];
-          if (s) { s.detail = detail; }
-          refresh();
-        } else if (status === "error") this.fail(idx, detail);
+          progress.detail(detail ?? "");
+        } else if (status === "error") this.fail(key, detail);
       };
     },
-
     dispose() {
-      stopTimer();
-      ctx.ui.setStatus?.(STATUS_KEY, undefined);
-      ctx.ui.setWidget?.(WIDGET_KEY, undefined);
+      progress.dispose();
     },
   };
 }
@@ -199,7 +270,7 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
   const modelCfg = loadModelConfig(platform.paths, ctx.cwd);
   const bridge = createModelBridge(platform);
   const resolved = resolveModelForAction("release", modelRegistry, modelCfg, bridge);
-  await applyModelOverride(platform, ctx, "release", resolved);
+  const modelCleanup = await applyModelOverride(platform, ctx, "release", resolved);
 
   if (!ctx.hasUI) {
     ctx.ui.notify("Release requires interactive mode", "warning");
@@ -210,16 +281,90 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
 
   void (async () => {
     try {
-      const isPolish = args?.includes("--polish") ?? false;
+      const skipPolish = args?.includes("--raw") ?? false;
       const isDryRun = args?.includes("--dry-run") ?? false;
       const config = loadConfig(platform.paths, ctx.cwd);
-
-      // 0. Check for uncommitted changes
-      progress.activate(0, "Checking working tree");
+      const tagFormat = config.release.tagFormat;
       let didStash = false;
+
+      // ── 1. Quality checks (headless) ────────────────────────────────────
+      progress.activate("checks", "Running quality gates");
+      const checksReport = await runHeadlessChecks(platform, ctx, config, resolved);
+      if (checksReport) {
+        const { summary, overallStatus } = checksReport;
+        const detail = `${summary.passed} passed, ${summary.failed} failed, ${summary.blocked} blocked`;
+        if (overallStatus === "passed") {
+          progress.complete("checks", detail);
+        } else {
+          progress.fail("checks", detail);
+          const failedNames = checksReport.gates
+            .filter((g) => g.status === "failed" || g.status === "blocked")
+            .map((g) => GATE_DISPLAY_NAMES[g.gate] ?? g.gate);
+          const continueChoice = await ctx.ui.select(
+            `Quality checks ${overallStatus}: ${failedNames.join(", ")}`,
+            [
+              "Continue — release despite failures",
+              "Abort — fix issues first",
+            ],
+            { helpText: detail },
+          );
+          if (!continueChoice || continueChoice.startsWith("Abort")) {
+            progress.dispose();
+            return;
+          }
+        }
+      } else {
+        progress.skip("checks", "No gates configured");
+      }
+
+      // ── 2. Doc-drift pre-check ──────────────────────────────────────────
+      progress.activate("doc-drift", "Checking documentation drift");
+      const driftResult = await checkDocDrift(platform, ctx.cwd);
+      if (driftResult?.drifted) {
+        progress.complete("doc-drift", "Drift detected");
+        const driftAction = await ctx.ui.select(
+          "Documentation drift detected before release",
+          [
+            "Update docs — fix documentation before continuing",
+            "Continue — release without updating docs",
+          ],
+          { helpText: driftResult.summary },
+        );
+
+        if (driftAction?.startsWith("Update docs")) {
+          progress.activate("doc-drift", "Fixing documentation");
+          notifyInfo(ctx, "Updating documentation", driftResult.summary);
+          const fixPrompt = buildFixPrompt(driftResult.findings);
+          const { loadState: loadDriftState, saveState: saveDriftState, getHeadCommit } = await import("../docs/drift.js");
+          const driftHead = await getHeadCommit(platform, ctx.cwd);
+          const driftState = loadDriftState(platform.paths, ctx.cwd);
+          saveDriftState(platform.paths, ctx.cwd, { ...driftState, lastCommit: driftHead, lastRunAt: new Date().toISOString() });
+
+          const fixResult = await runStructuredAgentSession(
+            platform.createAgentSession.bind(platform),
+            { cwd: ctx.cwd, prompt: fixPrompt },
+          );
+          if (fixResult.status === "ok") {
+            progress.complete("doc-drift", "Fixed");
+            notifySuccess(ctx, "Documentation updated");
+          } else {
+            progress.fail("doc-drift", fixResult.error ?? "Agent session error");
+            notifyError(ctx, "Doc update failed", fixResult.error ?? "Agent session error");
+            progress.dispose();
+            return;
+          }
+        } else {
+          progress.skip("doc-drift", "Skipped by user");
+        }
+      } else {
+        progress.complete("doc-drift", "No drift");
+      }
+
+      // ── 3. Check for uncommitted changes after preflight side effects ─────
+      progress.activate("working-tree", "Checking working tree");
       const treeStatus = await getWorkingTreeStatus(platform.exec.bind(platform), ctx.cwd);
       if (treeStatus.dirty) {
-        progress.complete(0, `${treeStatus.files.length} files changed`);
+        progress.complete("working-tree", `${treeStatus.files.length} files changed`);
         const filePreview = treeStatus.files.slice(0, 8).join(", ");
         const extra = treeStatus.files.length > 8 ? ` (+${treeStatus.files.length - 8} more)` : "";
 
@@ -227,8 +372,8 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
           `Uncommitted changes detected (${treeStatus.files.length} files)`,
           [
             "commit — commit changes with AI-generated message",
-            "stash \u2014 stash changes and continue",
-            "abort \u2014 cancel release",
+            "stash — stash changes and continue",
+            "abort — cancel release",
           ],
           { helpText: `Files: ${filePreview}${extra}` },
         );
@@ -239,72 +384,85 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
         }
 
         if (action.startsWith("commit")) {
-          // commit.ts has its own progress widget; dispose ours temporarily
           progress.dispose();
           const commitResult = await analyzeAndCommit(platform, ctx);
           if (!commitResult) {
             notifyError(ctx, "Commit failed or cancelled", "Aborting release.");
             return;
           }
-          // Verify tree is now clean
           const afterStatus = await getWorkingTreeStatus(platform.exec.bind(platform), ctx.cwd);
           if (afterStatus.dirty) {
             notifyError(ctx, "Still uncommitted changes", "Not all changes were committed. Aborting release.");
             return;
           }
-          // Re-create progress after commit's widget has disposed
-          // (reactivate shows state from where we left off)
-          progress.complete(0, "Committed");
+          progress.complete("working-tree", "Committed");
         } else if (action.startsWith("stash")) {
-          progress.activate(0, "Stashing changes");
+          progress.activate("working-tree", "Stashing changes");
           const stashResult = await platform.exec("git", ["stash", "push", "-m", "supi:release auto-stash"], { cwd: ctx.cwd });
           if (stashResult.code !== 0) {
-            progress.fail(0, stashResult.stderr || "stash failed");
+            progress.fail("working-tree", stashResult.stderr || "stash failed");
             progress.dispose();
             notifyError(ctx, "git stash failed", stashResult.stderr || "Non-zero exit");
             return;
           }
           didStash = true;
-          progress.complete(0, "Stashed");
+          progress.complete("working-tree", "Stashed");
         }
       } else {
-        progress.complete(0, "Clean");
+        progress.complete("working-tree", "Clean");
       }
 
-      // 1. Ensure channels are configured (or detect + ask)
-      progress.activate(1, "Detecting channels");
+      // ── 4. Ensure channels are configured (or detect + ask) ─────────────
+      progress.activate("channels", "Detecting channels");
+      const customChannels = config.release.customChannels ?? {};
+      const detectedChannels = await detectChannels(platform.exec.bind(platform), ctx.cwd, customChannels);
       let channels = config.release.channels;
       // Track whether channels were already set in config before any interactive
       // setup. This distinguishes "user already decided" from "just configured now",
       // which determines whether we can auto-continue without a confirmation prompt.
       const channelsWerePreConfigured = config.release.channels.length > 0;
 
+      if (channelsWerePreConfigured) {
+        const invalidChannels = findInvalidReleaseChannels(channels, detectedChannels);
+        if (invalidChannels.length > 0) {
+          const detail = invalidChannels.join("; ");
+          progress.fail("channels", detail);
+          notifyError(ctx, "Release channels invalid", detail);
+          progress.dispose();
+          return;
+        }
+      }
+
       if (channels.length === 0) {
-        progress.complete(1, "Awaiting selection");
-        channels = await setupChannels(platform, ctx);
+        progress.complete("channels", "Awaiting selection");
+        channels = await setupChannels(platform, ctx, detectedChannels);
         if (channels.length === 0) {
           progress.dispose();
           return;
         }
       }
-      progress.complete(1, channels.join(", "));
+      progress.complete("channels", channels.join(", "));
 
-      // 2. Get last tag + current version + check if bump is needed
-      progress.activate(2, "Parsing git history");
+      // ── 5. Get last tag + current version + check if bump is needed ─────
+      progress.activate("commits", "Parsing git history");
       const lastTag = await getLastTag(platform, ctx.cwd);
       const currentVersion = getCurrentVersion(ctx.cwd);
+      const resumableLocalRelease = await findResumableLocalRelease(
+        platform.exec.bind(platform),
+        ctx.cwd,
+        currentVersion,
+        tagFormat,
+      );
       const localTagExists = await isVersionReleased(
         platform.exec.bind(platform),
         ctx.cwd,
         currentVersion,
+        tagFormat,
       );
-      // Only check remote when local tag exists — avoids a network call when
-      // the version was never tagged at all.
       const remoteTagExists = localTagExists
-        ? await isTagOnRemote(platform.exec.bind(platform), ctx.cwd, currentVersion)
+        ? await isTagOnRemote(platform.exec.bind(platform), ctx.cwd, currentVersion, tagFormat)
         : false;
 
-      // 3. Parse commits since last tag
       const sinceArg = lastTag ? `${lastTag}..HEAD` : "HEAD~50..HEAD";
       let gitLogOutput: string;
       try {
@@ -321,103 +479,122 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
       const commits = parseConventionalCommits(gitLogOutput);
       const summary = summarizeChanges(commits);
       const commitCount = commits.features.length + commits.fixes.length + commits.breaking.length + commits.improvements.length + commits.maintenance.length + commits.other.length;
-      progress.complete(2, `${commitCount} commits since ${lastTag ?? "start"}`);
-
-      // 4. Version resolution
-      //    Three states:
-      //    a) No local tag              → version is unreleased, skip bump
-      //    b) Local tag, not on remote  → incomplete release, skip bump + skip tag
-      //    c) Local + remote tag        → fully released, ask for bump
-      let nextVersion: string;
-      let skipBump: boolean;
+      progress.complete("commits", `${commitCount} commits since ${lastTag ?? "start"}`);
+
+      let nextVersion: string | null = null;
+      let skipBump: boolean | null = null;
       let skipTag = false;
 
-      if (!localTagExists && currentVersion !== "0.0.0") {
-        // (a) No tag at all — version in package.json is unreleased
-        nextVersion = currentVersion;
-        skipBump = true;
-        progress.skip(3, `v${currentVersion} (already set, not yet released)`);
-        notifyInfo(ctx, `Using v${currentVersion}`, "Version not yet released \u2014 skipping bump");
-      } else if (localTagExists && !remoteTagExists) {
-        // (b) Tag exists locally but never made it to origin — resume
-        nextVersion = currentVersion;
-        skipBump = true;
-        skipTag = true;
-        progress.skip(3, `v${currentVersion} (tag exists locally, not pushed)`);
-        notifyInfo(ctx, `Resuming v${currentVersion}`, "Tag exists locally but not on remote \u2014 will push");
-      } else {
-        // (c) Fully released — ask for bump
-        progress.activate(3, "Awaiting version selection");
-        const suggested = suggestBump(commits);
-        const bumpChoice = await ctx.ui.select(
-          `Version bump (${summary})`,
-          BUMP_OPTIONS,
-          { helpText: `Current: ${currentVersion} (released) | Suggested: ${suggested}` },
+      if (resumableLocalRelease) {
+        progress.activate("version", "Found local release tag");
+        const resumeChoice = await ctx.ui.select(
+          `Continue failed release ${resumableLocalRelease.tag}?`,
+          [
+            `Continue — resume ${resumableLocalRelease.tag}`,
+            "Ignore — choose version normally",
+          ],
+          {
+            helpText: [
+              `A newer local tag (${resumableLocalRelease.tag}) exists on the current HEAD but is not on origin.`,
+              `package.json still reports ${currentVersion}.`,
+              "No commits or worktree changes were detected after that local tag.",
+            ].join(" "),
+          },
         );
-        if (!bumpChoice) {
+        if (!resumeChoice) {
           progress.dispose();
           return;
         }
 
-        const bump = bumpChoice.split(" \u2014 ")[0] as BumpType;
-        nextVersion = bumpVersion(currentVersion, bump);
-        skipBump = false;
-        progress.complete(3, `${currentVersion} \u2192 ${nextVersion} (${bump})`);
+        if (resumeChoice.startsWith("Continue")) {
+          nextVersion = resumableLocalRelease.version;
+          skipBump = true;
+          skipTag = true;
+          progress.skip("version", `${resumableLocalRelease.tag} (local tag not deployed)`);
+          notifyInfo(
+            ctx,
+            `Resuming failed release ${resumableLocalRelease.tag}`,
+            "Local tag exists only on this machine — release will continue from that tagged commit.",
+          );
+        }
       }
 
-      // 5. Build changelog
-      progress.activate(4, "Generating changelog");
-      const changelog = buildChangelogMarkdown(commits, nextVersion);
-      progress.complete(4, `${commitCount} entries`);
-
-      // 6. Polish mode → steer prompt to LLM, then return
-      if (isPolish) {
-        progress.skip(5, "Polish mode");
-        progress.skip(6, "Polish mode");
-        progress.dispose();
-
-        const releaseCommands = buildReleaseCommands(nextVersion, channels);
-        const prompt = buildPolishPrompt({
-          changelog,
-          version: nextVersion,
-          currentVersion,
-          channels,
-          commands: releaseCommands,
-        });
-
-        notifyInfo(ctx, "Release polish mode", `LLM will polish notes for v${nextVersion}`);
+      if (nextVersion === null || skipBump === null) {
+        if (!localTagExists && currentVersion !== "0.0.0") {
+          nextVersion = currentVersion;
+          skipBump = true;
+          progress.skip("version", `${formatTag(currentVersion, tagFormat)} (already set, not yet released)`);
+          notifyInfo(ctx, `Using ${formatTag(currentVersion, tagFormat)}`, "Version not yet released — skipping bump");
+        } else if (localTagExists && !remoteTagExists) {
+          nextVersion = currentVersion;
+          skipBump = true;
+          skipTag = true;
+          progress.skip("version", `${formatTag(currentVersion, tagFormat)} (tag exists locally, not pushed)`);
+          notifyInfo(ctx, `Resuming ${formatTag(currentVersion, tagFormat)}`, "Tag exists locally but not on remote — will push");
+        } else {
+          progress.activate("version", "Awaiting version selection");
+          const suggested = suggestBump(commits);
+          const bumpChoice = await ctx.ui.select(
+            `Version bump (${summary})`,
+            BUMP_OPTIONS,
+            { helpText: `Current: ${currentVersion} (released) | Suggested: ${suggested}` },
+          );
+          if (!bumpChoice) {
+            progress.dispose();
+            return;
+          }
 
-        platform.sendMessage(
-          {
-            customType: "supi-release-polish",
-            content: [{ type: "text", text: prompt }],
-            display: "none",
-          },
-          { deliverAs: "steer", triggerTurn: true },
+          const bump = bumpChoice.split(" — ")[0] as BumpType;
+          nextVersion = bumpVersion(currentVersion, bump);
+          skipBump = false;
+          progress.complete("version", `${currentVersion} → ${nextVersion} (${bump})`);
+        }
+      }
+      // ── 8. Build changelog ──────────────────────────────────────────────
+      progress.activate("changelog", "Generating changelog");
+      const rawChangelog = buildChangelogMarkdown(commits, nextVersion, tagFormat);
+      progress.complete("changelog", `${commitCount} entries`);
+
+      // ── 9. Polish release notes (default, skip with --raw) ──────────────
+      let changelog: string;
+      if (skipPolish) {
+        progress.skip("polish", "Skipped (--raw)");
+        changelog = rawChangelog;
+      } else {
+        progress.activate("polish", "Polishing release notes");
+        const polishPrompt = buildPolishPrompt({ changelog: rawChangelog, version: nextVersion, tagFormat });
+        const polishResult = await runStructuredAgentSession(
+          platform.createAgentSession.bind(platform),
+          { cwd: ctx.cwd, prompt: polishPrompt },
         );
-        return;
+        if (polishResult.status === "ok") {
+          changelog = polishResult.finalText;
+          progress.complete("polish", "Polished");
+        } else {
+          // Polish failed — fall back to raw changelog, don't block the release
+          changelog = rawChangelog;
+          progress.fail("polish", polishResult.error ?? "Agent error — using raw changelog");
+          notifyInfo(ctx, "Polish failed — using raw changelog", polishResult.error ?? "");
+        }
       }
 
-      // 7. Confirm via UI — skipped when resuming a staged unreleased release.
-      //    When skipBump is true the user already decided on the version; when
-      //    channels were pre-configured there's nothing left to decide. Asking
-      //    again is friction without benefit. Dry-run always asks because the
-      //    user explicitly opted into preview mode.
+      // ── 10. Confirm via UI ──────────────────────────────────────────────
+      //    Skipped when resuming a staged unreleased release.
       const isResume = isInProgressRelease({ skipBump, channelsWerePreConfigured, isDryRun });
 
       if (isResume) {
         notifyInfo(
           ctx,
-          `Resuming release v${nextVersion}`,
+          `Resuming release ${formatTag(nextVersion, tagFormat)}`,
           "Version staged and channels configured — proceeding without confirmation",
         );
       } else {
-        const confirmLabel = isDryRun ? `[DRY RUN] Ship v${nextVersion}?` : `Ship v${nextVersion}?`;
+        const confirmLabel = isDryRun ? `[DRY RUN] Ship ${formatTag(nextVersion, tagFormat)}?` : `Ship ${formatTag(nextVersion, tagFormat)}?`;
         // When skipBump=true, currentVersion === nextVersion — avoid the
         // misleading "0.5.0 → 0.5.0" display.
         const versionLine = skipBump
-          ? `v${nextVersion} (staged, not yet released)`
-          : `${currentVersion} → ${nextVersion}`;
+          ? `${formatTag(nextVersion, tagFormat)} (staged, not yet released)`
+          : `${currentVersion} \u2192 ${nextVersion}`;
         const confirmDetail = [
           versionLine,
           `Channels: ${channels.join(", ")}`,
@@ -428,7 +605,7 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
 
         const confirmed = ctx.ui.confirm
           ? await ctx.ui.confirm(confirmLabel, confirmDetail)
-          : (await ctx.ui.select(confirmLabel, ["Yes \u2014 publish", "No \u2014 abort"])) === "Yes \u2014 publish";
+          : (await ctx.ui.select(confirmLabel, ["Yes — publish", "No — abort"])) === "Yes — publish";
 
         if (!confirmed) {
           progress.dispose();
@@ -437,10 +614,10 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
         }
       }
 
-      // 8. Execute release
-      progress.activate(5, "Starting release execution");
+      // ── 11. Execute release ─────────────────────────────────────────────
+      progress.activate("execute", "Starting release execution");
       try {
-        const result = await executeRelease({
+        let result = await executeRelease({
           exec: platform.exec.bind(platform),
           cwd: ctx.cwd,
           version: nextVersion,
@@ -449,38 +626,56 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
           dryRun: isDryRun,
           skipBump,
           skipTag,
+          tagFormat,
+          customChannels,
           onProgress: progress.executorProgress(),
         });
 
-        // Mark execution steps based on result
+        if (!isDryRun && result.error && !result.pushed) {
+          const switchedTo = await maybeSwitchGithubAccountForReleaseFailure(platform, ctx, result.error);
+          if (switchedTo) {
+            progress.activate("execute", `Retrying with GitHub account ${switchedTo}`);
+            result = await executeRelease({
+              exec: platform.exec.bind(platform),
+              cwd: ctx.cwd,
+              version: nextVersion,
+              changelog,
+              channels,
+              dryRun: false,
+              skipBump: true,
+              skipTag: true,
+              tagFormat,
+              customChannels,
+              onProgress: progress.executorProgress(),
+            });
+          }
+        }
+
         if (result.tagCreated && result.pushed) {
-          progress.complete(5, "Tag + push complete");
+          progress.complete("execute", "Tag + push complete");
         } else if (result.error) {
-          progress.fail(5, result.error);
+          progress.fail("execute", result.error);
         } else {
-          progress.fail(5, `Tag: ${result.tagCreated ? "✓" : "✗"} | Push: ${result.pushed ? "✓" : "✗"}`);
+          progress.fail("execute", `Tag: ${result.tagCreated ? "✓" : "✗"} | Push: ${result.pushed ? "✓" : "✗"}`);
         }
 
-        // Mark channel publishing
         if (result.channels.length > 0) {
           const allOk = result.channels.every((c) => c.success);
           if (allOk) {
-            progress.complete(6, result.channels.map((c) => c.channel).join(", "));
+            progress.complete("publish", result.channels.map((c) => c.channel).join(", "));
           } else {
             const failedChannels = result.channels.filter((c) => !c.success);
-            progress.fail(6, failedChannels.map((c) => `${c.channel}: ${c.error ?? "failed"}`).join("; "));
+            progress.fail("publish", failedChannels.map((c) => `${c.channel}: ${c.error ?? "failed"}`).join("; "));
           }
         } else if (result.error) {
-          progress.skip(6, "Skipped (release failed)");
+          progress.skip("publish", "Skipped (release failed)");
         } else {
-          progress.complete(6, "No channels");
+          progress.complete("publish", "No channels");
         }
 
-        // Give the user a moment to see the final widget state
         await new Promise((r) => setTimeout(r, 1500));
         progress.dispose();
 
-        // Final notification
         const channelSummary = result.channels
           .map((c) => `${c.channel}: ${c.success ? "✓" : `✗ ${c.error ?? "failed"}`}`)
           .join(", ");
@@ -489,18 +684,17 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
           const prefix = isDryRun ? "[DRY RUN] " : "";
           notifySuccess(
             ctx,
-            `${prefix}Released v${nextVersion}`,
+            `${prefix}Released ${formatTag(nextVersion, tagFormat)}`,
             `Tag: ${result.tagCreated ? "✓" : "✗"} | Push: ${result.pushed ? "✓" : "✗"} | ${channelSummary}`,
           );
         } else {
-          // Include the error detail so the user knows WHY it failed
           const detail = result.error
             ? result.error
             : `Tag: ${result.tagCreated ? "✓" : "✗"} | Push: ${result.pushed ? "✓" : "✗"}`;
-          notifyError(ctx, `Release v${nextVersion} failed`, detail);
+          notifyError(ctx, `Release ${formatTag(nextVersion, tagFormat)} failed`, detail);
         }
       } catch (err) {
-        progress.fail(5, err instanceof Error ? err.message : "Unknown error");
+        progress.fail("execute", err instanceof Error ? err.message : "Unknown error");
         await new Promise((r) => setTimeout(r, 1500));
         progress.dispose();
         notifyError(
@@ -519,10 +713,41 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
     } catch (err) {
       progress.dispose();
       notifyError(ctx, "Release error", err instanceof Error ? err.message : String(err));
+    } finally {
+      await modelCleanup();
     }
   })();
 }
 
+/**
+ * Run quality gates headlessly — no UI widget of its own, results reported
+ * back to the release progress widget.
+ *
+ * Returns null when no gates are configured (caller should skip the step).
+ */
+async function runHeadlessChecks(
+  platform: Platform,
+  ctx: any,
+  config: ReturnType<typeof loadConfig>,
+  resolved: ResolvedModel,
+): Promise<ReviewReport | null> {
+  const enabledGates = Object.entries(config.quality.gates)
+    .filter(([, gate]) => gate?.enabled === true);
+
+  if (enabledGates.length === 0) {
+    return null;
+  }
+
+  return runQualityGates({
+    platform,
+    cwd: ctx.cwd,
+    gates: config.quality.gates,
+    filters: {},
+    reviewModel: resolved,
+    gateRegistry: REVIEW_GATE_REGISTRY,
+  });
+}
+
 async function getLastTag(platform: Platform, cwd: string): Promise<string | null> {
   try {
     const result = await platform.exec("git", ["describe", "--tags", "--abbrev=0"], { cwd });
@@ -532,60 +757,64 @@ async function getLastTag(platform: Platform, cwd: string): Promise<string | nul
   }
 }
 
-async function setupChannels(platform: Platform, ctx: any): Promise<ReleaseChannel[]> {
-  const detected = await detectChannels(platform.exec.bind(platform), ctx.cwd);
-  const available = detected.filter((d) => d.available);
-
-  // Build options — offer "both" when both channels are available
-  const options: string[] = [];
-  if (available.length === 2) {
-    options.push(`both — GitHub + npm (${available.map((d) => d.detail).join(", ")})`);
+async function setupChannels(
+  platform: Platform,
+  ctx: any,
+  detected: ChannelStatus[],
+): Promise<ReleaseChannel[]> {
+  const availableChannels = detected.filter((channel) => channel.available);
+  const unavailableChannels = detected.filter((channel) => !channel.available);
+  const unavailableSummary = unavailableChannels
+    .map((channel) => `${channel.channel}: ${channel.detail}`)
+    .join("; ");
+
+  if (availableChannels.length === 0) {
+    const detail = unavailableSummary || "No release channels are currently available.";
+    ctx.ui.notify(`No release channels are currently available. ${detail}`, "warning");
+    return [];
   }
-  for (const d of detected) {
-    options.push(`${d.channel} — ${d.available ? d.detail : `unavailable (${d.detail})`}`);
-  }
-  options.push("skip — configure later");
-
-  const choice = await ctx.ui.select(
-    "Release Setup — Select publish channels",
-    options,
-    { helpText: "Which channels should releases be published to?" },
-  );
 
-  if (!choice || choice.startsWith("skip")) return [];
+  const channelOptions = buildSelectableReleaseChannelOptions(detected);
+  const helpText = unavailableSummary
+    ? `Select channels one at a time. Pick Done when finished. Unavailable: ${unavailableSummary}`
+    : "Select channels one at a time. Pick Done when finished.";
+
+  // Loop-based multi-select: user picks channels one at a time, "Done" to finish
+  const selected: ReleaseChannel[] = [];
+
+  while (true) {
+    const remaining = channelOptions.filter(
+      (option) => !selected.includes(option.split(" — ")[0]),
+    );
+    const options = [
+      ...remaining,
+      ...(selected.length > 0 ? [`Done — selected: ${selected.join(", ")}`] : []),
+      "skip — configure later",
+    ];
+
+    const choice = await ctx.ui.select(
+      selected.length === 0
+        ? "Release Setup — Select publish channels"
+        : `Selected: ${selected.join(", ")} — add more or Done`,
+      options,
+      { helpText },
+    );
+
+    if (!choice || choice.startsWith("skip")) {
+      if (selected.length > 0) break; // keep what was selected
+      return [];
+    }
+    if (choice.startsWith("Done")) break;
 
-  let channels: ReleaseChannel[];
-  if (choice.startsWith("both")) {
-    channels = available.map((d) => d.channel);
-  } else {
-    channels = [choice.split(" — ")[0] as ReleaseChannel];
+    const channelId = choice.split(" — ")[0];
+    if (!selected.includes(channelId)) {
+      selected.push(channelId);
+    }
   }
 
   // Persist to config
-  updateConfig(platform.paths, ctx.cwd, { release: { channels } });
-  ctx.ui.notify(`Release channels set to: ${channels.join(", ")}`, "info");
-
-  return channels;
-}
-
-function buildReleaseCommands(
-  version: string,
-  channels: ReleaseChannel[],
-): string[] {
-  const commands: string[] = [
-    `git add -A`,
-    `git commit -m "chore(release): v${version}"`,
-    `git tag -a v${version} -m "Release v${version}"`,
-    `git push origin HEAD --follow-tags`,
-  ];
-
-  for (const channel of channels) {
-    if (channel === "github") {
-      commands.push(`gh release create v${version} --title "v${version}" --notes "...changelog..."`);
-    } else if (channel === "npm") {
-      commands.push(`npm publish`);
-    }
-  }
+  updateConfig(platform.paths, ctx.cwd, { release: { channels: selected } });
+  ctx.ui.notify(`Release channels set to: ${selected.join(", ")}`, "info");
 
-  return commands;
+  return selected;
 }