supipowers 1.5.3 → 2.0.0

package/src/quality/schemas.ts

@@ -9,18 +9,53 @@ export const LspDiagnosticsGateConfigSchema = Type.Object(
   { additionalProperties: false },
 );
 
+export const CommandGateRunTargetSchema = Type.Union([
+  Type.Object(
+    {
+      scope: Type.Literal("all-targets"),
+    },
+    { additionalProperties: false },
+  ),
+  Type.Object(
+    {
+      scope: Type.Literal("root"),
+    },
+    { additionalProperties: false },
+  ),
+  Type.Object(
+    {
+      scope: Type.Literal("all-workspaces"),
+    },
+    { additionalProperties: false },
+  ),
+  Type.Object(
+    {
+      scope: Type.Literal("workspace"),
+      relativeDir: Type.String({ minLength: 1 }),
+    },
+    { additionalProperties: false },
+  ),
+]);
+
+export const CommandGateRunSchema = Type.Object(
+  {
+    command: Type.String({ minLength: 1 }),
+    target: CommandGateRunTargetSchema,
+  },
+  { additionalProperties: false },
+);
+
 export const CommandGateConfigSchema = Type.Union([
   Type.Object(
     {
       enabled: Type.Literal(false),
-      command: Type.Optional(Type.Union([Type.String(), Type.Null()])),
     },
     { additionalProperties: false },
   ),
   Type.Object(
     {
       enabled: Type.Literal(true),
-      command: Type.String({ minLength: 1 }),
+      runs: Type.Array(CommandGateRunSchema, { minItems: 1 }),
     },
     { additionalProperties: false },
   ),

package/src/quality/setup.ts

@@ -4,6 +4,7 @@ import type { Platform, PlatformContext } from "../platform/types.js";
 import type {
   ConfigScope,
   ProjectFacts,
+  ProjectFactsTarget,
   QualityGatesConfig,
   SetupGatesResult,
   SetupProposal,
@@ -11,8 +12,10 @@ import type {
 import type { InspectionLoadResult } from "../config/schema.js";
 import { validateQualityGates } from "../config/schema.js";
 import { writeQualityGatesConfig } from "../config/loader.js";
+import { resolvePackageManager } from "../workspace/package-manager.js";
+import { discoverWorkspaceTargets } from "../workspace/targets.js";
 import { CANONICAL_GATE_ORDER } from "./registry.js";
-import { detectReviewGates } from "./review-gates.js";
+import { collectReviewGateNotes, detectReviewGates } from "./review-gates.js";
 import { suggestQualityGatesWithAi } from "./ai-setup.js";
 
 export type GateSetupMode = "deterministic" | "ai-assisted";
@@ -63,17 +66,70 @@ function detectLockfiles(cwd: string): string[] {
     .filter((file) => fs.existsSync(path.join(cwd, file)));
 }
 
+function normalizeScriptCommand(command: string | undefined): string | null {
+  const trimmed = command?.trim();
+  return trimmed ? trimmed : null;
+}
+
+function collectProjectTargets(cwd: string): ProjectFactsTarget[] {
+  const packageManager = resolvePackageManager(cwd).id;
+  const targets = discoverWorkspaceTargets(cwd, packageManager);
+  if (targets.length === 0) {
+    return [
+      {
+        name: path.basename(cwd) || "root",
+        kind: "root",
+        relativeDir: ".",
+        packageScripts: readPackageScripts(cwd),
+      },
+    ];
+  }
+
+  return targets.map((target) => ({
+    name: target.name,
+    kind: target.kind,
+    relativeDir: target.relativeDir,
+    packageScripts: readPackageScripts(target.packageDir),
+  }));
+}
+
+function collectSharedPackageScripts(targets: ProjectFactsTarget[]): Record<string, string> {
+  if (targets.length === 0) {
+    return {};
+  }
+
+  const shared = { ...targets[0].packageScripts };
+  for (const scriptName of Object.keys(shared)) {
+    const command = normalizeScriptCommand(shared[scriptName]);
+    if (!command) {
+      delete shared[scriptName];
+      continue;
+    }
+
+    const matchesEveryTarget = targets.slice(1).every(
+      (target) => normalizeScriptCommand(target.packageScripts[scriptName]) === command,
+    );
+    if (!matchesEveryTarget) {
+      delete shared[scriptName];
+    }
+  }
+
+  return shared;
+}
+
 export function collectProjectFacts(
   cwd: string,
   inspection: InspectionLoadResult,
   activeTools: string[],
 ): ProjectFacts {
+  const targets = collectProjectTargets(cwd);
   return {
     cwd,
-    packageScripts: readPackageScripts(cwd),
+    packageScripts: collectSharedPackageScripts(targets),
     lockfiles: detectLockfiles(cwd),
     activeTools,
     existingGates: inspection.effectiveConfig?.quality.gates ?? {},
+    targets,
   };
 }
 
@@ -87,17 +143,34 @@ export function formatGateProposal(proposal: SetupProposal): string {
   const entries = CANONICAL_GATE_ORDER
     .filter((gateId) => proposal.gates[gateId] !== undefined)
     .map((gateId) => [gateId, proposal.gates[gateId]] as const);
+  const sections: string[] = [];
+
   if (entries.length === 0) {
-    return "No gates suggested.";
+    sections.push("No gates suggested.");
+  } else {
+    sections.push(
+      entries
+        .map(([gateId, config]) => `${gateId}: ${JSON.stringify(config)}`)
+        .join("\n"),
+    );
+  }
+
+  if (proposal.notes && proposal.notes.length > 0) {
+    sections.push([
+      "Notes:",
+      ...proposal.notes.map((note) => `- ${note}`),
+    ].join("\n"));
   }
 
-  return entries
-    .map(([gateId, config]) => `${gateId}: ${JSON.stringify(config)}`)
-    .join("\n");
+  return sections.join("\n\n");
 }
 
 export function buildDeterministicSuggestion(projectFacts: ProjectFacts): SetupProposal {
-  return { gates: detectReviewGates(projectFacts) };
+  const notes = collectReviewGateNotes(projectFacts);
+  return {
+    gates: detectReviewGates(projectFacts),
+    ...(notes.length > 0 ? { notes } : {}),
+  };
 }
 
 export async function setupGates(
@@ -122,6 +195,7 @@ export async function setupGates(
         projectFacts,
         proposal,
       }),
+      ...(proposal.notes && proposal.notes.length > 0 ? { notes: proposal.notes } : {}),
     };
     options.onProgress?.({ type: "ai-analysis-completed" });
   }
@@ -141,29 +215,32 @@ export async function setupGates(
   };
 }
 
-function parseRevisedProposal(raw: string): SetupProposal {
+function parseRevisedProposal(raw: string): QualityGatesConfig {
   const parsed = JSON.parse(raw) as QualityGatesConfig;
   const validation = validateQualityGates(parsed);
   if (!validation.valid) {
     throw new Error(validation.errors.join("\n"));
   }
 
-  return { gates: parsed };
+  return parsed;
 }
 
 function labelForScope(scope: ConfigScope): string {
-  return scope === "project"
-    ? "Project (.omp/supipowers/config.json)"
-    : "Global (~/.omp/supipowers/config.json)";
+  switch (scope) {
+    case "global":
+      return "Global (~/.omp/supipowers/config.json)";
+    case "root":
+      return "Repository (.omp/supipowers/config.json)";
+  }
 }
 
 async function selectSaveScope(ctx: PlatformContext): Promise<ConfigScope | null> {
   const choice = await ctx.ui.select(
     "Save quality gates to",
-    [labelForScope("project"), labelForScope("global"), "Cancel"],
+    [labelForScope("root"), labelForScope("global"), "Cancel"],
     {
       initialIndex: 0,
-      helpText: "Choose whether review gates apply only to this project or all projects.",
+      helpText: "Choose whether review gates apply only to this repository or all repositories.",
     },
   );
 
@@ -171,7 +248,7 @@ async function selectSaveScope(ctx: PlatformContext): Promise<ConfigScope | null
     return null;
   }
 
-  return choice === labelForScope("global") ? "global" : "project";
+  return choice === labelForScope("global") ? "global" : "root";
 }
 
 function buildProposalHelpText(proposal: SetupProposal, options?: GateSetupDialogOptions): string {
@@ -209,7 +286,10 @@ export async function interactivelySaveGateSetup(
       }
 
       try {
-        proposal = parseRevisedProposal(revised);
+        proposal = {
+          ...proposal,
+          gates: parseRevisedProposal(revised),
+        };
       } catch (error) {
         ctx.ui.notify((error as Error).message, "error");
       }

package/src/release/changelog.ts

@@ -57,7 +57,7 @@ function parseGitLogWithFiles(gitLog: string): GitCommitWithFiles[] {
 
 function isPathInReleaseScope(filePath: string, releaseScope: string[]): boolean {
   const normalizedFile = normalizeReleasePath(filePath);
-  return releaseScope.some((scopePath) => normalizedFile === scopePath || normalizedFile.startsWith(`${scopePath}/`));
+  return releaseScope.some((scopePath) => scopePath === "." || normalizedFile === scopePath || normalizedFile.startsWith(`${scopePath}/`));
 }
 
 /**

package/src/release/channels/custom.ts

@@ -1,5 +1,6 @@
 // src/release/channels/custom.ts — Wraps user-defined custom channel config into a ChannelHandler
 import type { CustomChannelConfig } from "../../types.js";
+import { execShellCommand } from "../../utils/shell.js";
 import type { ChannelHandler, ChannelPublishContext, ChannelStatus, ExecFn } from "./types.js";
 
 
@@ -13,7 +14,7 @@ export function createCustomHandler(id: string, config: CustomChannelConfig): Ch
         return { channel: id, available: true, detail: "No detect command configured — assumed available" };
       }
       try {
-        const result = await exec("sh", ["-c", config.detectCommand], { cwd });
+        const result = await execShellCommand(exec, config.detectCommand, { cwd });
         if (result.code === 0) {
           return { channel: id, available: true, detail: `Detect command succeeded` };
         }
@@ -27,9 +28,18 @@ export function createCustomHandler(id: string, config: CustomChannelConfig): Ch
       try {
         // `${tag}`/`${version}`/`${changelog}` stay in the shell template, but
         // their values cross the shell boundary via environment variables.
-        const result = await exec("sh", ["-c", config.publishCommand], {
+        const result = await execShellCommand(exec, config.publishCommand, {
           cwd: ctx.cwd,
-          env: { tag: ctx.tag, version: ctx.version, changelog: ctx.changelog },
+          env: {
+            tag: ctx.tag,
+            version: ctx.version,
+            changelog: ctx.changelog,
+            targetName: ctx.targetName,
+            targetId: ctx.targetId,
+            targetPath: ctx.targetPath,
+            manifestPath: ctx.manifestPath,
+            packageManager: ctx.packageManager,
+          },
         });
         if (result.code !== 0) {
           return { success: false, error: result.stderr || result.stdout || `Custom channel '${id}' exited with code ${result.code}` };

package/src/release/channels/types.ts

@@ -17,6 +17,11 @@ export interface ChannelPublishContext {
   tag: string;
   changelog: string;
   cwd: string;
+  targetName: string;
+  targetId: string;
+  targetPath: string;
+  manifestPath: string;
+  packageManager: string;
 }
 
 export interface ChannelHandler {

package/src/release/contracts.ts

@@ -0,0 +1,90 @@
+// src/release/contracts.ts
+//
+// Schema-backed contracts for AI-assisted release subflows. The release
+// command has two AI sessions that must not degrade into free-form text:
+//
+//   1. Release-note polish — the model rewrites the raw changelog into
+//      user-facing release notes. Returns a structured artifact rather
+//      than arbitrary markdown so the caller can reason about title,
+//      body, and highlights independently.
+//   2. Release doc-fix — when doc-drift is detected before a release,
+//      the fixer agent applies documentation edits and reports back a
+//      structured summary of what it changed (or declares `blocked`).
+//
+// Both schemas flow through runWithOutputValidation so the retry loop
+// hands validation errors back to the model rather than letting the
+// release command publish on malformed output.
+
+import { Type, type Static } from "@sinclair/typebox";
+
+// ── Release-note polish ───────────────────────────────────────
+
+export const RELEASE_NOTE_STATUSES = ["ok", "empty"] as const;
+export type ReleaseNoteStatus = (typeof RELEASE_NOTE_STATUSES)[number];
+
+export const ReleaseNotePolishOutputSchema = Type.Object(
+  {
+    title: Type.String({ minLength: 1 }),
+    body: Type.String(),
+    highlights: Type.Array(Type.String({ minLength: 1 })),
+    status: Type.Union(RELEASE_NOTE_STATUSES.map((value) => Type.Literal(value))),
+  },
+  { additionalProperties: false },
+);
+
+export type ReleaseNotePolishOutput = Static<typeof ReleaseNotePolishOutputSchema>;
+
+// ── Release doc-fix ───────────────────────────────────────────
+
+export const RELEASE_DOC_FIX_STATUSES = ["ok", "blocked"] as const;
+export type ReleaseDocFixStatus = (typeof RELEASE_DOC_FIX_STATUSES)[number];
+
+export const ReleaseDocFixEditSchema = Type.Object(
+  {
+    file: Type.String({ minLength: 1 }),
+    instructions: Type.String({ minLength: 1 }),
+  },
+  { additionalProperties: false },
+);
+
+export const ReleaseDocFixOutputSchema = Type.Object(
+  {
+    edits: Type.Array(ReleaseDocFixEditSchema),
+    summary: Type.String({ minLength: 1 }),
+    status: Type.Union(RELEASE_DOC_FIX_STATUSES.map((value) => Type.Literal(value))),
+  },
+  { additionalProperties: false },
+);
+
+export type ReleaseDocFixEdit = Static<typeof ReleaseDocFixEditSchema>;
+export type ReleaseDocFixOutput = Static<typeof ReleaseDocFixOutputSchema>;
+
+/**
+ * Render a polished release-note artifact as markdown suitable for
+ * surface to the user and execution by the release pipeline. Produces a
+ * level-2 title, optional highlight bullets, and the grouped body.
+ */
+export function renderPolishedChangelog(output: ReleaseNotePolishOutput): string {
+  if (output.status === "empty") {
+    return output.body.trim().length > 0
+      ? output.body.trim()
+      : "_No notable changes in this release._";
+  }
+
+  const parts: string[] = [];
+  parts.push(`## ${output.title}`);
+  if (output.highlights.length > 0) {
+    parts.push("");
+    parts.push("### Highlights");
+    parts.push("");
+    for (const h of output.highlights) {
+      parts.push(`- ${h}`);
+    }
+  }
+  const body = output.body.trim();
+  if (body.length > 0) {
+    parts.push("");
+    parts.push(body);
+  }
+  return parts.join("\n");
+}

package/src/release/executor.ts

@@ -1,18 +1,26 @@
 // src/release/executor.ts — Release execution: build, version bump, git ops, channel publishing
 import * as fs from "node:fs";
-import * as path from "node:path";
-import type { CustomChannelConfig, ReleaseChannel, ReleaseResult } from "../types.js";
+import type {
+  CustomChannelConfig,
+  ReleaseChannel,
+  ReleaseResult,
+  ReleaseTarget,
+} from "../types.js";
 import { commitStaged } from "../git/commit.js";
 import { formatTag } from "./version.js";
 import { resolveChannelHandler } from "./channels/registry.js";
 import type { ExecFn } from "./channels/types.js";
+import { getRunScriptCommand } from "../workspace/package-manager.js";
 
 /** Callback to report step progress during release execution. */
 export type ReleaseProgressFn = (step: string, status: "active" | "done" | "error", detail?: string) => void;
 
 export interface ExecuteReleaseOptions {
   exec: ExecFn;
+  /** Repository root — git and channel publish steps run here. */
   cwd: string;
+  /** Selected release target whose manifest/build should be mutated. */
+  target: ReleaseTarget;
   version: string;
   changelog: string;
   channels: ReleaseChannel[];
@@ -20,7 +28,7 @@ export interface ExecuteReleaseOptions {
   tagFormat: string;
   /** User-defined custom channel configurations */
   customChannels?: Record<string, CustomChannelConfig>;
-  /** Skip the package.json version write (version was already set locally). */
+  /** Skip the target manifest version write (version was already set locally). */
   skipBump?: boolean;
   /** Reuse/update the local git tag after the rebase step instead of creating a new one. */
   skipTag?: boolean;
@@ -28,26 +36,79 @@ export interface ExecuteReleaseOptions {
   onProgress?: ReleaseProgressFn;
 }
 
+interface TargetManifest {
+  scripts?: Record<string, string>;
+  version?: string;
+}
+
+function getTargetManifestGitPath(target: ReleaseTarget): string {
+  return target.relativeDir === "."
+    ? "package.json"
+    : `${target.relativeDir}/package.json`;
+}
+
+function readTargetManifest(target: ReleaseTarget): TargetManifest {
+  return JSON.parse(fs.readFileSync(target.manifestPath, "utf-8")) as TargetManifest;
+}
+
+const PUSH_RETRY_LIMIT = 1;
+
+export function isNonFastForwardPushError(detail: string | undefined): boolean {
+  if (!detail) {
+    return false;
+  }
+
+  const normalized = detail.toLowerCase();
+  return normalized.includes("non-fast-forward") || normalized.includes("fetch first");
+}
+
+async function refreshReleaseTag(
+  exec: ExecFn,
+  cwd: string,
+  tagName: string,
+  tagMessage: string,
+  progress: ReleaseProgressFn,
+ ): Promise<{ success: true } | { success: false; error: string }> {
+  progress("git-tag", "active", `Refreshing ${tagName}`);
+  const gitTag = await exec("git", ["tag", "-a", "-f", tagName, "-m", tagMessage], { cwd });
+  if (gitTag.code !== 0) {
+    const detail = gitTag.stderr || gitTag.stdout || `exit code ${gitTag.code}`;
+    progress("git-tag", "error", detail);
+    return { success: false, error: `git tag: ${detail}` };
+  }
+
+  progress("git-tag", "done", "Refreshed existing tag");
+  return { success: true };
+}
+
 /**
- * Execute a full release: optional build, package.json version bump, git
+ * Execute a full release: optional build, target manifest version bump, git
  * commit+tag+push, then per-channel publishing.
- *
- * - Build and git steps are fatal (throw or return early on non-zero exit).
- * - Channel failures are non-fatal; each is tried independently and errors
- *   are recorded in the result.
- * - In dry-run mode no exec calls are made; the result reflects what would
- *   happen (all flags true) so callers can preview without side-effects.
  */
 export async function executeRelease(opts: ExecuteReleaseOptions): Promise<ReleaseResult> {
-  const { exec, cwd, version, changelog, channels, dryRun, tagFormat, skipBump, skipTag, onProgress, customChannels = {} } = opts;
+  const {
+    exec,
+    cwd,
+    target,
+    version,
+    changelog,
+    channels,
+    dryRun,
+    tagFormat,
+    skipBump,
+    skipTag,
+    onProgress,
+    customChannels = {},
+  } = opts;
   const progress = onProgress ?? (() => {});
   const tagName = formatTag(version, tagFormat);
   const tagMessage = `Release ${tagName}\n\n${changelog}`;
+  const stagedPaths = [getTargetManifestGitPath(target)];
 
   if (dryRun) {
-    console.log(`[dry-run] Would build (if scripts.build exists)`);
-    console.log(`[dry-run] Would bump version to ${version}`);
-    console.log(`[dry-run] Would git add -A`);
+    console.log(`[dry-run] Would build ${target.name} in ${target.packageDir} (if scripts.build exists)`);
+    console.log(`[dry-run] Would bump ${stagedPaths[0]} to ${version}`);
+    console.log(`[dry-run] Would git add -- ${stagedPaths.join(" ")}`);
     console.log(`[dry-run] Would git commit -m "chore(release): ${tagName}"`);
     console.log(`[dry-run] Would git pull --rebase origin`);
     if (skipTag) {
@@ -56,8 +117,8 @@ export async function executeRelease(opts: ExecuteReleaseOptions): Promise<Relea
       console.log(`[dry-run] Would git tag -a ${tagName}`);
     }
     console.log(`[dry-run] Would git push origin HEAD --follow-tags`);
-    for (const ch of channels) {
-      console.log(`[dry-run] Would publish to channel: ${ch}`);
+    for (const channel of channels) {
+      console.log(`[dry-run] Would publish to channel: ${channel}`);
     }
     return {
       version,
@@ -67,15 +128,12 @@ export async function executeRelease(opts: ExecuteReleaseOptions): Promise<Relea
     };
   }
 
-  // ── 1. Optional build ─────────────────────────────────────────────────────
-  const pkgPath = path.join(cwd, "package.json");
-  const pkgRaw = fs.readFileSync(pkgPath, "utf-8");
-  const pkg = JSON.parse(pkgRaw) as Record<string, unknown>;
+  const manifest = readTargetManifest(target);
 
-  const scripts = pkg["scripts"] as Record<string, string> | undefined;
-  if (scripts?.["build"]) {
-    progress("build", "active", "Running build script");
-    const buildResult = await exec("bun", ["run", "build"], { cwd });
+  if (manifest.scripts?.build) {
+    progress("build", "active", `Running build script for ${target.name}`);
+    const buildCommand = getRunScriptCommand(target.packageManager, "build");
+    const buildResult = await exec(buildCommand.command, buildCommand.args, { cwd: target.packageDir });
     if (buildResult.code !== 0) {
       progress("build", "error", buildResult.stderr || "Non-zero exit");
       throw new Error(`Build failed: ${buildResult.stderr || "non-zero exit"}`);
@@ -83,26 +141,21 @@ export async function executeRelease(opts: ExecuteReleaseOptions): Promise<Relea
     progress("build", "done");
   }
 
-  // ── 2. Bump version in package.json ──────────────────────────────────────
   if (skipBump) {
     progress("version-bump", "done", "Already set");
   } else {
-    progress("version-bump", "active", `Bumping to ${version}`);
-    pkg["version"] = version;
-    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+    progress("version-bump", "active", `Bumping ${stagedPaths[0]} to ${version}`);
+    manifest.version = version;
+    fs.writeFileSync(target.manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
     progress("version-bump", "done");
   }
 
-  // ── 3–6. Git operations ──────────────────────────────────────────────────
-
-  // When skipBump is true the version was already committed locally —
-  // there's nothing to stage or commit, so skip straight to tag+push.
   if (skipBump) {
     progress("git-add", "done", "Skipped (no changes)");
     progress("git-commit", "done", "Skipped (already committed)");
   } else {
-    progress("git-add", "active", "git add -A");
-    const gitAdd = await exec("git", ["add", "-A"], { cwd });
+    progress("git-add", "active", `git add -- ${stagedPaths.join(" ")}`);
+    const gitAdd = await exec("git", ["add", "--", ...stagedPaths], { cwd });
     if (gitAdd.code !== 0) {
       const detail = gitAdd.stderr || gitAdd.stdout || `exit code ${gitAdd.code}`;
       progress("git-add", "error", detail);
@@ -110,7 +163,7 @@ export async function executeRelease(opts: ExecuteReleaseOptions): Promise<Relea
     }
     progress("git-add", "done");
 
-    const commitMessage = `chore(release): ${formatTag(version, tagFormat)}`;
+    const commitMessage = `chore(release): ${tagName}`;
     progress("git-commit", "active", commitMessage);
     const commitResult = await commitStaged(exec, cwd, commitMessage);
     if (!commitResult.success) {
@@ -144,19 +197,38 @@ export async function executeRelease(opts: ExecuteReleaseOptions): Promise<Relea
   }
   progress("git-tag", "done", skipTag ? "Refreshed existing tag" : undefined);
 
-  progress("git-push", "active", "Pushing to origin");
-  const gitPush = await exec("git", ["push", "origin", "HEAD", "--follow-tags"], { cwd });
-  if (gitPush.code !== 0) {
+  let pushAttempt = 0;
+  while (true) {
+    progress("git-push", "active", pushAttempt === 0 ? "Pushing to origin" : "Retrying push after rebase");
+    const gitPush = await exec("git", ["push", "origin", "HEAD", "--follow-tags"], { cwd });
+    if (gitPush.code === 0) {
+      progress("git-push", "done");
+      break;
+    }
+
     const detail = gitPush.stderr || gitPush.stdout || `exit code ${gitPush.code}`;
-    progress("git-push", "error", detail);
-    // Tag was created or refreshed locally but push failed
-    return { version, tagCreated: true, pushed: false, channels: [], error: `git push: ${detail}` };
+    if (pushAttempt >= PUSH_RETRY_LIMIT || !isNonFastForwardPushError(detail)) {
+      progress("git-push", "error", detail);
+      return { version, tagCreated: true, pushed: false, channels: [], error: `git push: ${detail}` };
+    }
+
+    pushAttempt += 1;
+    progress("git-pull", "active", "Push rejected — rebasing before retry");
+    const retryPull = await exec("git", ["pull", "--rebase", "origin"], { cwd });
+    if (retryPull.code !== 0) {
+      const retryDetail = retryPull.stderr || retryPull.stdout || `exit code ${retryPull.code}`;
+      progress("git-pull", "error", retryDetail);
+      return { version, tagCreated: true, pushed: false, channels: [], error: `git pull: ${retryDetail}` };
+    }
+    progress("git-pull", "done", "Rebased after push rejection");
+
+    const refreshTag = await refreshReleaseTag(exec, cwd, tagName, tagMessage, progress);
+    if (!refreshTag.success) {
+      return { version, tagCreated: true, pushed: false, channels: [], error: refreshTag.error };
+    }
   }
-  progress("git-push", "done");
 
-  // ── 7. Channel publishing ─────────────────────────────────────────────────
   const channelResults: ReleaseResult["channels"] = [];
-
   for (const channel of channels) {
     progress(`publish-${channel}`, "active", `Publishing to ${channel}`);
 
@@ -170,9 +242,14 @@ export async function executeRelease(opts: ExecuteReleaseOptions): Promise<Relea
 
     const result = await handler.publish(exec, {
       version,
-      tag: formatTag(version, tagFormat),
+      tag: tagName,
       changelog,
       cwd,
+      targetName: target.name,
+      targetId: target.id,
+      targetPath: target.relativeDir,
+      manifestPath: target.manifestPath,
+      packageManager: target.packageManager,
     });
 
     if (result.success) {