supipowers 1.5.2 → 2.0.0

package/src/commands/release.ts

@@ -1,11 +1,21 @@
+import path from "node:path";
 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, ReviewReport, ResolvedModel } from "../types.js";
+import type { ReleaseChannel, ReleaseTarget, 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 { resolvePackageManager } from "../workspace/package-manager.js";
+import { resolveRepoRoot } from "../workspace/repo-root.js";
+import { parseTargetArg, resolveRequestedWorkspaceTarget, sortWorkspaceTargetOptions, selectWorkspaceTarget, tokenizeCliArgs, type WorkspaceTargetOption } from "../workspace/selector.js";
+import {
+  isWorkspaceTargetLocked,
+  releaseWorkspaceTargetLock,
+  tryAcquireWorkspaceTargetLock,
+} from "../workspace/locks.js";
+import { discoverReleaseTargets, getPublishableReleaseTargets } from "../release/targets.js";
 import {
   parseConventionalCommits,
   buildChangelogMarkdown,
@@ -15,6 +25,8 @@ import {
 import {
   getCurrentVersion,
   getPublishedPackagePaths,
+  getLatestReleaseTag,
+  getReleaseTagFormat,
   suggestBump,
   bumpVersion,
   isVersionReleased,
@@ -27,7 +39,15 @@ 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 { runWithOutputValidation, parseStructuredOutput } from "../ai/structured-output.js";
+import { renderSchemaText } from "../ai/schema-text.js";
+import {
+  ReleaseNotePolishOutputSchema,
+  ReleaseDocFixOutputSchema,
+  renderPolishedChangelog,
+  type ReleaseNotePolishOutput,
+  type ReleaseDocFixOutput,
+} from "../release/contracts.js";
 import {
   checkDocDrift,
   buildFixPrompt,
@@ -50,6 +70,71 @@ const BUMP_OPTIONS = [
   "major — breaking changes",
 ];
 
+interface ParsedReleaseArgs {
+  skipPolish: boolean;
+  isDryRun: boolean;
+  requestedTarget: string | null;
+}
+
+export interface ReleaseTargetOption extends WorkspaceTargetOption<ReleaseTarget> {
+  lastTag: string | null;
+  summary: string;
+}
+
+
+export function parseReleaseArgs(args?: string): ParsedReleaseArgs {
+  const tokens = tokenizeCliArgs(args);
+
+  return {
+    skipPolish: tokens.includes("--raw"),
+    isDryRun: tokens.includes("--dry-run"),
+    requestedTarget: parseTargetArg(args),
+  };
+}
+
+export function createReleaseProgressKeys(runId: string): { statusKey: string; widgetKey: string } {
+  return {
+    statusKey: `supi-release:${runId}`,
+    widgetKey: `supi-release:${runId}`,
+  };
+}
+
+export function resolveRequestedReleaseTarget(
+  targets: ReleaseTarget[],
+  requestedTarget: string | null,
+): ReleaseTarget | null {
+  return resolveRequestedWorkspaceTarget(targets, requestedTarget);
+}
+
+export function sortReleaseTargetOptions(options: ReleaseTargetOption[]): ReleaseTargetOption[] {
+  return sortWorkspaceTargetOptions(options) as ReleaseTargetOption[];
+}
+
+export function buildReleaseTargetOptionLabel(option: ReleaseTargetOption): string {
+  const releaseState = option.lastTag ?? "unreleased";
+  const changeState = option.changed
+    ? `changed — ${option.summary}`
+    : "unchanged — no publishable changes";
+
+  return `${option.target.name} — ${option.target.relativeDir} — ${releaseState} — ${changeState}`;
+}
+
+function createReleaseRunId(): string {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+export function tryAcquireReleaseTargetLock(targetId: string): boolean {
+  return tryAcquireWorkspaceTargetLock("release", targetId);
+}
+
+export function releaseReleaseTargetLock(targetId: string): void {
+  releaseWorkspaceTargetLock("release", targetId);
+}
+
+export function isReleaseTargetLocked(targetId: string): boolean {
+  return isWorkspaceTargetLocked("release", targetId);
+}
+
 /**
  * Returns true when re-running supi:release should skip the confirmation
  * dialog and proceed directly to execution.
@@ -211,12 +296,13 @@ export const RELEASE_STEPS = [
 
 type ReleaseStepKey = (typeof RELEASE_STEPS)[number]["key"];
 
-function createReleaseProgress(ctx: any) {
+function createReleaseProgress(ctx: any, runId: string) {
+  const progressKeys = createReleaseProgressKeys(runId);
   const progress = createWorkflowProgress(ctx.ui, {
     title: "supi:release",
-    statusKey: "supi-release",
+    statusKey: progressKeys.statusKey,
     statusLabel: "Releasing...",
-    widgetKey: "supi-release",
+    widgetKey: progressKeys.widgetKey,
     clearStatusKeys: ["supi-model"],
     steps: [...RELEASE_STEPS],
   });
@@ -254,6 +340,36 @@ function createReleaseProgress(ctx: any) {
   };
 }
 
+function buildPendingReleaseTargetOptions(targets: ReleaseTarget[]): ReleaseTargetOption[] {
+  return sortReleaseTargetOptions(
+    targets.map((target) => ({
+      target,
+      changed: false,
+      lastTag: null,
+      summary: "change analysis pending",
+    })),
+  );
+}
+
+export async function selectReleaseTarget(
+  ctx: any,
+  options: ReleaseTargetOption[],
+  requestedTarget: string | null,
+): Promise<ReleaseTarget | null> {
+  return selectWorkspaceTarget(
+    ctx,
+    options.map((option) => ({
+      ...option,
+      label: buildReleaseTargetOptionLabel(option),
+    })),
+    requestedTarget,
+    {
+      title: "Release target",
+      helpText: "Pick a publishable package to release. Target choice is runtime-only and is not persisted in config.",
+    },
+  );
+}
+
 /**
  * Register the command for autocomplete and /help listing.
  * Actual execution goes through handleRelease via the TUI dispatch.
@@ -283,19 +399,54 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
     return;
   }
 
-  const progress = createReleaseProgress(ctx);
-
   void (async () => {
+    let progress: ReturnType<typeof createReleaseProgress> | null = null;
+    let lockedTargetId: string | null = null;
     try {
-      const skipPolish = args?.includes("--raw") ?? false;
-      const isDryRun = args?.includes("--dry-run") ?? false;
-      const config = loadConfig(platform.paths, ctx.cwd);
+      const { skipPolish, isDryRun, requestedTarget } = parseReleaseArgs(args);
+      const repoRoot = await resolveRepoRoot(platform, ctx.cwd);
+      const packageManager = resolvePackageManager(repoRoot);
+      const publishableTargets = getPublishableReleaseTargets(
+        discoverReleaseTargets(repoRoot, packageManager.id),
+      );
+      if (publishableTargets.length === 0) {
+        notifyError(ctx, "No publishable release targets found", "Create a non-private package.json with name and version before running /supi:release.");
+        return;
+      }
+
+      const selectedTarget = await selectReleaseTarget(
+        ctx,
+        buildPendingReleaseTargetOptions(publishableTargets),
+        requestedTarget,
+      );
+      if (requestedTarget && !selectedTarget) {
+        notifyError(ctx, "Release target not found", requestedTarget);
+        return;
+      }
+      if (!selectedTarget) {
+        return;
+      }
+      if (!tryAcquireReleaseTargetLock(selectedTarget.id)) {
+        notifyError(
+          ctx,
+          "Release already in progress",
+          `${selectedTarget.name} is already being released in this session. Wait for that run to finish before retrying.`,
+        );
+        return;
+      }
+      lockedTargetId = selectedTarget.id;
+
+      progress = createReleaseProgress(ctx, createReleaseRunId());
+      progress.detail(`Target: ${selectedTarget.name} (${selectedTarget.relativeDir})`);
+
+      const config = loadConfig(platform.paths, repoRoot);
       const tagFormat = config.release.tagFormat;
+      const effectiveTagFormat = getReleaseTagFormat(selectedTarget, tagFormat);
       let didStash = false;
 
       // ── 1. Quality checks (headless) ────────────────────────────────────
       progress.activate("checks", "Running quality gates");
-      const checksReport = await runHeadlessChecks(platform, ctx, config, resolved);
+      const checksReport = await runHeadlessChecks(platform, repoRoot, config, resolved, selectedTarget);
       if (checksReport) {
         const { summary, overallStatus } = checksReport;
         const detail = `${summary.passed} passed, ${summary.failed} failed, ${summary.blocked} blocked`;
@@ -325,7 +476,7 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
 
       // ── 2. Doc-drift pre-check ──────────────────────────────────────────
       progress.activate("doc-drift", "Checking documentation drift");
-      const driftResult = await checkDocDrift(platform, ctx.cwd);
+      const driftResult = await checkDocDrift(platform, repoRoot);
       if (driftResult?.drifted) {
         progress.complete("doc-drift", "Drift detected");
         const driftAction = await ctx.ui.select(
@@ -342,20 +493,30 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
           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 driftHead = await getHeadCommit(platform, repoRoot);
+          const driftState = loadDriftState(platform.paths, repoRoot);
+          saveDriftState(platform.paths, repoRoot, { ...driftState, lastCommit: driftHead, lastRunAt: new Date().toISOString() });
 
-          const fixResult = await runStructuredAgentSession(
+          const fixResult = await runWithOutputValidation<ReleaseDocFixOutput>(
             platform.createAgentSession.bind(platform),
-            { cwd: ctx.cwd, prompt: fixPrompt },
+            {
+              cwd: repoRoot,
+              prompt: fixPrompt,
+              schema: renderSchemaText(ReleaseDocFixOutputSchema),
+              parse: (raw) => parseStructuredOutput<ReleaseDocFixOutput>(raw, ReleaseDocFixOutputSchema),
+              reliability: { paths: platform.paths, cwd: repoRoot, command: "release", operation: "doc-fix" },
+            },
           );
-          if (fixResult.status === "ok") {
-            progress.complete("doc-drift", "Fixed");
-            notifySuccess(ctx, "Documentation updated");
+          if (fixResult.status === "ok" && fixResult.output.status === "ok") {
+            progress.complete("doc-drift", `Fixed — ${fixResult.output.edits.length} file(s)`);
+            notifySuccess(ctx, "Documentation updated", fixResult.output.summary);
           } else {
-            progress.fail("doc-drift", fixResult.error ?? "Agent session error");
-            notifyError(ctx, "Doc update failed", fixResult.error ?? "Agent session error");
+            const detail =
+              fixResult.status === "blocked"
+                ? fixResult.error
+                : `Doc fixer blocked: ${fixResult.output.summary}`;
+            progress.fail("doc-drift", detail);
+            notifyError(ctx, "Doc update failed", detail);
             progress.dispose();
             return;
           }
@@ -368,7 +529,7 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
 
       // ── 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);
+      const treeStatus = await getWorkingTreeStatus(platform.exec.bind(platform), repoRoot);
       if (treeStatus.dirty) {
         progress.complete("working-tree", `${treeStatus.files.length} files changed`);
         const filePreview = treeStatus.files.slice(0, 8).join(", ");
@@ -396,7 +557,7 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
             notifyError(ctx, "Commit failed or cancelled", "Aborting release.");
             return;
           }
-          const afterStatus = await getWorkingTreeStatus(platform.exec.bind(platform), ctx.cwd);
+          const afterStatus = await getWorkingTreeStatus(platform.exec.bind(platform), repoRoot);
           if (afterStatus.dirty) {
             notifyError(ctx, "Still uncommitted changes", "Not all changes were committed. Aborting release.");
             return;
@@ -404,7 +565,7 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
           progress.complete("working-tree", "Committed");
         } else if (action.startsWith("stash")) {
           progress.activate("working-tree", "Stashing changes");
-          const stashResult = await platform.exec("git", ["stash", "push", "-m", "supi:release auto-stash"], { cwd: ctx.cwd });
+          const stashResult = await platform.exec("git", ["stash", "push", "-m", "supi:release auto-stash"], { cwd: repoRoot });
           if (stashResult.code !== 0) {
             progress.fail("working-tree", stashResult.stderr || "stash failed");
             progress.dispose();
@@ -421,7 +582,7 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
       // ── 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);
+      const detectedChannels = await detectChannels(platform.exec.bind(platform), repoRoot, 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",
@@ -441,7 +602,7 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
 
       if (channels.length === 0) {
         progress.complete("channels", "Awaiting selection");
-        channels = await setupChannels(platform, ctx, detectedChannels);
+        channels = await setupChannels(platform, ctx, repoRoot, detectedChannels);
         if (channels.length === 0) {
           progress.dispose();
           return;
@@ -451,38 +612,38 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
 
       // ── 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 lastTag = await getLatestReleaseTag(
+        platform.exec.bind(platform),
+        selectedTarget,
+        tagFormat,
+      );
+      const currentVersion = getCurrentVersion(selectedTarget);
       const resumableLocalRelease = await findResumableLocalRelease(
         platform.exec.bind(platform),
-        ctx.cwd,
+        selectedTarget,
         currentVersion,
         tagFormat,
       );
       const localTagExists = await isVersionReleased(
         platform.exec.bind(platform),
-        ctx.cwd,
+        selectedTarget,
         currentVersion,
         tagFormat,
       );
       const remoteTagExists = localTagExists
-        ? await isTagOnRemote(platform.exec.bind(platform), ctx.cwd, currentVersion, tagFormat)
+        ? await isTagOnRemote(platform.exec.bind(platform), selectedTarget, currentVersion, tagFormat)
         : false;
 
       const sinceArg = lastTag ? `${lastTag}..HEAD` : "HEAD~50..HEAD";
-      const releaseScope = getPublishedPackagePaths(ctx.cwd);
-      const gitLogArgs = releaseScope
-        ? ["log", sinceArg, "--format=%x1e%H%x1f%s", "--name-only"]
-        : ["log", sinceArg, "--oneline"];
+      const releaseScope = getPublishedPackagePaths(selectedTarget);
+      const gitLogArgs = ["log", sinceArg, "--format=%x1e%H%x1f%s", "--name-only"];
       let gitLogOutput: string;
       try {
-        const result = await platform.exec("git", gitLogArgs, { cwd: ctx.cwd });
+        const result = await platform.exec("git", gitLogArgs, { cwd: repoRoot });
         if (result.code !== 0) {
           gitLogOutput = "";
-        } else if (releaseScope) {
-          gitLogOutput = filterOnelineGitLogToPaths(result.stdout, releaseScope);
         } else {
-          gitLogOutput = result.stdout;
+          gitLogOutput = filterOnelineGitLogToPaths(result.stdout, releaseScope);
         }
       } catch {
         gitLogOutput = "";
@@ -535,14 +696,14 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
         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");
+          progress.skip("version", `${formatTag(currentVersion, effectiveTagFormat)} (already set, not yet released)`);
+          notifyInfo(ctx, `Using ${formatTag(currentVersion, effectiveTagFormat)}`, "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");
+          progress.skip("version", `${formatTag(currentVersion, effectiveTagFormat)} (tag exists locally, not pushed)`);
+          notifyInfo(ctx, `Resuming ${formatTag(currentVersion, effectiveTagFormat)}`, "Tag exists locally but not on remote — will push");
         } else {
           progress.activate("version", "Awaiting version selection");
           const suggested = suggestBump(commits);
@@ -564,7 +725,7 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
       }
       // ── 8. Build changelog ──────────────────────────────────────────────
       progress.activate("changelog", "Generating changelog");
-      const rawChangelog = buildChangelogMarkdown(commits, nextVersion, tagFormat);
+      const rawChangelog = buildChangelogMarkdown(commits, nextVersion, effectiveTagFormat);
       progress.complete("changelog", `${commitCount} entries`);
 
       // ── 9. Polish release notes (default, skip with --raw) ──────────────
@@ -574,19 +735,27 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
         changelog = rawChangelog;
       } else {
         progress.activate("polish", "Polishing release notes");
-        const polishPrompt = buildPolishPrompt({ changelog: rawChangelog, version: nextVersion, tagFormat });
-        const polishResult = await runStructuredAgentSession(
+        const polishPrompt = buildPolishPrompt({ changelog: rawChangelog, version: nextVersion, tagFormat: effectiveTagFormat });
+        const polishResult = await runWithOutputValidation<ReleaseNotePolishOutput>(
           platform.createAgentSession.bind(platform),
-          { cwd: ctx.cwd, prompt: polishPrompt },
+          {
+            cwd: repoRoot,
+            prompt: polishPrompt,
+            schema: renderSchemaText(ReleaseNotePolishOutputSchema),
+            parse: (raw) => parseStructuredOutput<ReleaseNotePolishOutput>(raw, ReleaseNotePolishOutputSchema),
+            reliability: { paths: platform.paths, cwd: repoRoot, command: "release", operation: "note-polish" },
+          },
         );
         if (polishResult.status === "ok") {
-          changelog = polishResult.finalText;
-          progress.complete("polish", "Polished");
+          changelog = renderPolishedChangelog(polishResult.output);
+          progress.complete("polish", polishResult.output.status === "empty" ? "No notable changes" : "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 ?? "");
+          // Contract validation failed — halt truthfully rather than ship
+          // an unreviewed or ambiguous changelog.
+          progress.fail("polish", polishResult.error);
+          notifyError(ctx, "Release-note polish failed validation", polishResult.error);
+          progress.dispose();
+          return;
         }
       }
 
@@ -597,15 +766,15 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
       if (isResume) {
         notifyInfo(
           ctx,
-          `Resuming release ${formatTag(nextVersion, tagFormat)}`,
+          `Resuming release ${formatTag(nextVersion, effectiveTagFormat)}`,
           "Version staged and channels configured — proceeding without confirmation",
         );
       } else {
-        const confirmLabel = isDryRun ? `[DRY RUN] Ship ${formatTag(nextVersion, tagFormat)}?` : `Ship ${formatTag(nextVersion, tagFormat)}?`;
+        const confirmLabel = isDryRun ? `[DRY RUN] Ship ${formatTag(nextVersion, effectiveTagFormat)}?` : `Ship ${formatTag(nextVersion, effectiveTagFormat)}?`;
         // When skipBump=true, currentVersion === nextVersion — avoid the
         // misleading "0.5.0 → 0.5.0" display.
         const versionLine = skipBump
-          ? `${formatTag(nextVersion, tagFormat)} (staged, not yet released)`
+          ? `${formatTag(nextVersion, effectiveTagFormat)} (staged, not yet released)`
           : `${currentVersion} \u2192 ${nextVersion}`;
         const confirmDetail = [
           versionLine,
@@ -631,14 +800,15 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
       try {
         let result = await executeRelease({
           exec: platform.exec.bind(platform),
-          cwd: ctx.cwd,
+          cwd: repoRoot,
+          target: selectedTarget,
           version: nextVersion,
           changelog,
           channels,
           dryRun: isDryRun,
           skipBump,
           skipTag,
-          tagFormat,
+          tagFormat: effectiveTagFormat,
           customChannels,
           onProgress: progress.executorProgress(),
         });
@@ -649,14 +819,15 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
             progress.activate("execute", `Retrying with GitHub account ${switchedTo}`);
             result = await executeRelease({
               exec: platform.exec.bind(platform),
-              cwd: ctx.cwd,
+              cwd: repoRoot,
+              target: selectedTarget,
               version: nextVersion,
               changelog,
               channels,
               dryRun: false,
               skipBump: true,
               skipTag: true,
-              tagFormat,
+              tagFormat: effectiveTagFormat,
               customChannels,
               onProgress: progress.executorProgress(),
             });
@@ -696,14 +867,14 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
           const prefix = isDryRun ? "[DRY RUN] " : "";
           notifySuccess(
             ctx,
-            `${prefix}Released ${formatTag(nextVersion, tagFormat)}`,
+            `${prefix}Released ${formatTag(nextVersion, effectiveTagFormat)}`,
             `Tag: ${result.tagCreated ? "✓" : "✗"} | Push: ${result.pushed ? "✓" : "✗"} | ${channelSummary}`,
           );
         } else {
           const detail = result.error
             ? result.error
             : `Tag: ${result.tagCreated ? "✓" : "✗"} | Push: ${result.pushed ? "✓" : "✗"}`;
-          notifyError(ctx, `Release ${formatTag(nextVersion, tagFormat)} failed`, detail);
+          notifyError(ctx, `Release ${formatTag(nextVersion, effectiveTagFormat)} failed`, detail);
         }
       } catch (err) {
         progress.fail("execute", err instanceof Error ? err.message : "Unknown error");
@@ -716,16 +887,19 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
         );
       } finally {
         if (didStash) {
-          const popResult = await platform.exec("git", ["stash", "pop"], { cwd: ctx.cwd });
+          const popResult = await platform.exec("git", ["stash", "pop"], { cwd: repoRoot });
           if (popResult.code !== 0) {
             notifyError(ctx, "Stash pop failed", "Run 'git stash pop' manually to recover your changes");
           }
         }
       }
     } catch (err) {
-      progress.dispose();
+      progress?.dispose();
       notifyError(ctx, "Release error", err instanceof Error ? err.message : String(err));
     } finally {
+      if (lockedTargetId) {
+        releaseReleaseTargetLock(lockedTargetId);
+      }
       await modelCleanup();
     }
   })();
@@ -739,9 +913,10 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
  */
 async function runHeadlessChecks(
   platform: Platform,
-  ctx: any,
+  repoRoot: string,
   config: ReturnType<typeof loadConfig>,
   resolved: ResolvedModel,
+  selectedTarget: ReleaseTarget,
 ): Promise<ReviewReport | null> {
   const enabledGates = Object.entries(config.quality.gates)
     .filter(([, gate]) => gate?.enabled === true);
@@ -750,9 +925,24 @@ async function runHeadlessChecks(
     return null;
   }
 
+  const repoWideTarget = {
+    id: "repo-root",
+    name: path.basename(repoRoot) || "repo-root",
+    kind: "root" as const,
+    repoRoot,
+    packageDir: repoRoot,
+    manifestPath: path.join(repoRoot, "package.json"),
+    relativeDir: ".",
+    version: selectedTarget.version,
+    private: false,
+    packageManager: selectedTarget.packageManager,
+  };
+
   return runQualityGates({
     platform,
-    cwd: ctx.cwd,
+    cwd: repoRoot,
+    target: repoWideTarget,
+    workspaceTargets: [repoWideTarget],
     gates: config.quality.gates,
     filters: {},
     reviewModel: resolved,
@@ -760,18 +950,11 @@ async function runHeadlessChecks(
   });
 }
 
-async function getLastTag(platform: Platform, cwd: string): Promise<string | null> {
-  try {
-    const result = await platform.exec("git", ["describe", "--tags", "--abbrev=0"], { cwd });
-    return result.code === 0 ? result.stdout.trim() : null;
-  } catch {
-    return null;
-  }
-}
 
 async function setupChannels(
   platform: Platform,
   ctx: any,
+  configCwd: string,
   detected: ChannelStatus[],
 ): Promise<ReleaseChannel[]> {
   const availableChannels = detected.filter((channel) => channel.available);
@@ -825,7 +1008,7 @@ async function setupChannels(
   }
 
   // Persist to config
-  updateConfig(platform.paths, ctx.cwd, { release: { channels: selected } });
+  updateConfig(platform.paths, configCwd, { release: { channels: selected } });
   ctx.ui.notify(`Release channels set to: ${selected.join(", ")}`, "info");
 
   return selected;