supipowers 1.2.6 → 1.5.0

package/src/release/channels/gitlab.ts

@@ -0,0 +1,35 @@
+// src/release/channels/gitlab.ts — Built-in GitLab release channel
+import type { ChannelHandler, ChannelPublishContext, ChannelStatus, ExecFn } from "./types.js";
+
+export const gitlab: ChannelHandler = {
+  id: "gitlab",
+  label: "GitLab Releases",
+
+  async detect(exec: ExecFn, cwd: string): Promise<ChannelStatus> {
+    try {
+      const result = await exec("glab", ["auth", "status"], { cwd });
+      if (result.code === 0) {
+        return { channel: "gitlab", available: true, detail: "Authenticated with GitLab CLI" };
+      }
+      return { channel: "gitlab", available: false, detail: "GitLab CLI not authenticated (run: glab auth login)" };
+    } catch {
+      return { channel: "gitlab", available: false, detail: "GitLab CLI not installed (install: https://gitlab.com/gitlab-org/cli)" };
+    }
+  },
+
+  async publish(exec: ExecFn, ctx: ChannelPublishContext): Promise<{ success: boolean; error?: string }> {
+    try {
+      const result = await exec(
+        "glab",
+        ["release", "create", ctx.tag, "--notes", ctx.changelog],
+        { cwd: ctx.cwd },
+      );
+      if (result.code !== 0) {
+        return { success: false, error: result.stderr || result.stdout || `glab release create exited with code ${result.code}` };
+      }
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  },
+};

package/src/release/channels/registry.ts

@@ -0,0 +1,52 @@
+// src/release/channels/registry.ts — Channel handler resolution and discovery
+import type { CustomChannelConfig } from "../../types.js";
+import type { ChannelHandler, ChannelStatus, ExecFn } from "./types.js";
+import { github } from "./github.js";
+import { gitlab } from "./gitlab.js";
+import { gitea } from "./gitea.js";
+import { createCustomHandler } from "./custom.js";
+
+const BUILTIN_CHANNELS: ChannelHandler[] = [github, gitlab, gitea];
+
+const BUILTIN_MAP = new Map(BUILTIN_CHANNELS.map((h) => [h.id, h]));
+
+/**
+ * Resolve a channel ID to a handler. Custom channel configs override built-in
+ * handlers when the IDs match. Returns null for unknown IDs with no custom config.
+ */
+export function resolveChannelHandler(
+  id: string,
+  customChannels: Record<string, CustomChannelConfig>,
+): ChannelHandler | null {
+  if (id in customChannels) {
+    return createCustomHandler(id, customChannels[id]);
+  }
+  return BUILTIN_MAP.get(id) ?? null;
+}
+
+/**
+ * Detect availability of all built-in channels plus any custom channels.
+ * Returns a status entry for each, ordered built-ins first, then custom.
+ */
+export async function getAllAvailableChannels(
+  exec: ExecFn,
+  cwd: string,
+  customChannels: Record<string, CustomChannelConfig>,
+): Promise<ChannelStatus[]> {
+  const handlers: ChannelHandler[] = [];
+
+  for (const builtin of BUILTIN_CHANNELS) {
+    const handler = resolveChannelHandler(builtin.id, customChannels);
+    if (handler) {
+      handlers.push(handler);
+    }
+  }
+
+  for (const [id, config] of Object.entries(customChannels)) {
+    if (!BUILTIN_MAP.has(id)) {
+      handlers.push(createCustomHandler(id, config));
+    }
+  }
+
+  return Promise.all(handlers.map((handler) => handler.detect(exec, cwd)));
+}

package/src/release/channels/types.ts

@@ -0,0 +1,27 @@
+// src/release/channels/types.ts — Shared types for release channel handlers
+
+export type ExecFn = (
+  cmd: string,
+  args: string[],
+  opts?: { cwd?: string; env?: Record<string, string> },
+) => Promise<{ stdout: string; stderr: string; code: number }>;
+
+export interface ChannelStatus {
+  channel: string;
+  available: boolean;
+  detail: string;
+}
+
+export interface ChannelPublishContext {
+  version: string;
+  tag: string;
+  changelog: string;
+  cwd: string;
+}
+
+export interface ChannelHandler {
+  id: string;
+  label: string;
+  detect(exec: ExecFn, cwd: string): Promise<ChannelStatus>;
+  publish(exec: ExecFn, ctx: ChannelPublishContext): Promise<{ success: boolean; error?: string }>;
+}

package/src/release/detector.ts

@@ -1,69 +1,16 @@
 // src/release/detector.ts — Detect which release channels are available
-
-import type { ReleaseChannel } from "../types.js";
-
-type ExecFn = (
-  cmd: string,
-  args: string[],
-  opts?: { cwd?: string },
-) => Promise<{ stdout: string; stderr: string; code: number }>;
-
-export interface ChannelStatus {
-  channel: ReleaseChannel;
-  available: boolean;
-  detail: string;
-}
-
-async function checkGitHub(exec: ExecFn, cwd: string): Promise<ChannelStatus> {
-  try {
-    const result = await exec("gh", ["auth", "status"], { cwd });
-    if (result.code === 0) {
-      return { channel: "github", available: true, detail: "Authenticated with GitHub CLI" };
-    }
-    return {
-      channel: "github",
-      available: false,
-      detail: "GitHub CLI not authenticated (run: gh auth login)",
-    };
-  } catch {
-    return {
-      channel: "github",
-      available: false,
-      detail: "GitHub CLI not authenticated (run: gh auth login)",
-    };
-  }
-}
-
-async function checkNpm(exec: ExecFn, cwd: string): Promise<ChannelStatus> {
-  try {
-    const result = await exec("npm", ["whoami"], { cwd });
-    if (result.code === 0) {
-      return {
-        channel: "npm",
-        available: true,
-        detail: `Logged in as ${result.stdout.trim()}`,
-      };
-    }
-    return {
-      channel: "npm",
-      available: false,
-      detail: "npm not authenticated (run: npm login)",
-    };
-  } catch {
-    return {
-      channel: "npm",
-      available: false,
-      detail: "npm not authenticated (run: npm login)",
-    };
-  }
-}
+import type { CustomChannelConfig } from "../types.js";
+import type { ChannelStatus, ExecFn } from "./channels/types.js";
+import { getAllAvailableChannels } from "./channels/registry.js";
 
 /**
  * Detect which release channels are available in the current environment.
- * Both checks run concurrently and independently — a failure in one does not
- * affect the other.
+ * Checks all built-in channels plus any user-defined custom channels.
  */
-export async function detectChannels(exec: ExecFn, cwd: string): Promise<ChannelStatus[]> {
-  const [github, npm] = await Promise.all([checkGitHub(exec, cwd), checkNpm(exec, cwd)]);
-  return [github, npm];
+export async function detectChannels(
+  exec: ExecFn,
+  cwd: string,
+  customChannels: Record<string, CustomChannelConfig> = {},
+): Promise<ChannelStatus[]> {
+  return getAllAvailableChannels(exec, cwd, customChannels);
 }

package/src/release/executor.ts

@@ -1,14 +1,11 @@
 // 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 { ReleaseChannel, ReleaseResult } from "../types.js";
+import type { CustomChannelConfig, ReleaseChannel, ReleaseResult } from "../types.js";
 import { commitStaged } from "../git/commit.js";
-
-type ExecFn = (
-  cmd: string,
-  args: string[],
-  opts?: { cwd?: string },
-) => Promise<{ stdout: string; stderr: string; code: number }>;
+import { formatTag } from "./version.js";
+import { resolveChannelHandler } from "./channels/registry.js";
+import type { ExecFn } from "./channels/types.js";
 
 /** Callback to report step progress during release execution. */
 export type ReleaseProgressFn = (step: string, status: "active" | "done" | "error", detail?: string) => void;
@@ -20,9 +17,12 @@ export interface ExecuteReleaseOptions {
   changelog: string;
   channels: ReleaseChannel[];
   dryRun: boolean;
+  tagFormat: string;
+  /** User-defined custom channel configurations */
+  customChannels?: Record<string, CustomChannelConfig>;
   /** Skip the package.json version write (version was already set locally). */
   skipBump?: boolean;
-  /** Skip creating the git tag (it already exists locally). */
+  /** Reuse/update the local git tag after the rebase step instead of creating a new one. */
   skipTag?: boolean;
   /** Optional callback for step-by-step progress reporting. */
   onProgress?: ReleaseProgressFn;
@@ -39,18 +39,21 @@ export interface ExecuteReleaseOptions {
  *   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, skipBump, skipTag, onProgress } = opts;
+  const { exec, cwd, 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}`;
 
   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 git commit -m "chore(release): v${version}"`);
+    console.log(`[dry-run] Would git commit -m "chore(release): ${tagName}"`);
+    console.log(`[dry-run] Would git pull --rebase origin`);
     if (skipTag) {
-      console.log(`[dry-run] Would skip git tag (already exists locally)`);
+      console.log(`[dry-run] Would refresh existing git tag ${tagName} to the rebased HEAD`);
     } else {
-      console.log(`[dry-run] Would git tag -a v${version}`);
+      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) {
@@ -107,7 +110,7 @@ export async function executeRelease(opts: ExecuteReleaseOptions): Promise<Relea
     }
     progress("git-add", "done");
 
-    const commitMessage = `chore(release): v${version}`;
+    const commitMessage = `chore(release): ${formatTag(version, tagFormat)}`;
     progress("git-commit", "active", commitMessage);
     const commitResult = await commitStaged(exec, cwd, commitMessage);
     if (!commitResult.success) {
@@ -117,26 +120,36 @@ export async function executeRelease(opts: ExecuteReleaseOptions): Promise<Relea
     progress("git-commit", "done");
   }
 
-  if (skipTag) {
-    progress("git-tag", "done", "Already exists");
-  } else {
-    progress("git-tag", "active", `v${version}`);
-    const tagMessage = `Release v${version}\n\n${changelog}`;
-    const gitTag = await exec("git", ["tag", "-a", `v${version}`, "-m", tagMessage], { cwd });
-    if (gitTag.code !== 0) {
-      const detail = gitTag.stderr || gitTag.stdout || `exit code ${gitTag.code}`;
-      progress("git-tag", "error", detail);
-      return { version, tagCreated: false, pushed: false, channels: [], error: `git tag: ${detail}` };
-    }
-    progress("git-tag", "done");
+  progress("git-pull", "active", "Pulling latest from origin");
+  const gitPull = await exec("git", ["pull", "--rebase", "origin"], { cwd });
+  if (gitPull.code !== 0) {
+    const detail = gitPull.stderr || gitPull.stdout || `exit code ${gitPull.code}`;
+    progress("git-pull", "error", detail);
+    return { version, tagCreated: Boolean(skipTag), pushed: false, channels: [], error: `git pull: ${detail}` };
   }
+  progress("git-pull", "done");
+
+  progress("git-tag", "active", skipTag ? `Refreshing ${tagName}` : tagName);
+  const gitTag = await exec(
+    "git",
+    skipTag
+      ? ["tag", "-a", "-f", tagName, "-m", tagMessage]
+      : ["tag", "-a", tagName, "-m", tagMessage],
+    { cwd },
+  );
+  if (gitTag.code !== 0) {
+    const detail = gitTag.stderr || gitTag.stdout || `exit code ${gitTag.code}`;
+    progress("git-tag", "error", detail);
+    return { version, tagCreated: Boolean(skipTag), pushed: false, channels: [], error: `git tag: ${detail}` };
+  }
+  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) {
     const detail = gitPush.stderr || gitPush.stdout || `exit code ${gitPush.code}`;
     progress("git-push", "error", detail);
-    // Tag was created locally but push failed
+    // Tag was created or refreshed locally but push failed
     return { version, tagCreated: true, pushed: false, channels: [], error: `git push: ${detail}` };
   }
   progress("git-push", "done");
@@ -146,31 +159,28 @@ export async function executeRelease(opts: ExecuteReleaseOptions): Promise<Relea
 
   for (const channel of channels) {
     progress(`publish-${channel}`, "active", `Publishing to ${channel}`);
-    try {
-      let result: { code: number; stdout: string; stderr: string };
-      if (channel === "github") {
-        result = await exec(
-          "gh",
-          ["release", "create", `v${version}`, "--title", `v${version}`, "--notes", changelog],
-          { cwd },
-        );
-      } else {
-        // "npm"
-        result = await exec("npm", ["publish"], { cwd });
-      }
-
-      if (result.code !== 0) {
-        const err = result.stderr || result.stdout || `${channel} publish exited with code ${result.code}`;
-        progress(`publish-${channel}`, "error", err);
-        channelResults.push({ channel, success: false, error: err });
-      } else {
-        progress(`publish-${channel}`, "done");
-        channelResults.push({ channel, success: true });
-      }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      progress(`publish-${channel}`, "error", msg);
-      channelResults.push({ channel, success: false, error: msg });
+
+    const handler = resolveChannelHandler(channel, customChannels);
+    if (!handler) {
+      const err = `Unknown channel '${channel}' — no built-in handler and no custom config found`;
+      progress(`publish-${channel}`, "error", err);
+      channelResults.push({ channel, success: false, error: err });
+      continue;
+    }
+
+    const result = await handler.publish(exec, {
+      version,
+      tag: formatTag(version, tagFormat),
+      changelog,
+      cwd,
+    });
+
+    if (result.success) {
+      progress(`publish-${channel}`, "done");
+      channelResults.push({ channel, success: true });
+    } else {
+      progress(`publish-${channel}`, "error", result.error);
+      channelResults.push({ channel, success: false, error: result.error });
     }
   }
 

package/src/release/prompt.ts

@@ -1,22 +1,19 @@
-import type { ReleaseChannel } from "../types.js";
+import { formatTag } from "./version.js";
 
 export interface BuildPolishPromptOpts {
   changelog: string;
   version: string;
-  currentVersion: string;
-  channels: ReleaseChannel[];
-  commands: string[];
+  tagFormat?: string;
 }
 
 /**
- * Build a steer prompt that instructs the LLM to polish the pre-built changelog,
- * present it to the user for confirmation, then run the release commands on approval.
+ * Build a prompt for a headless agent session that polishes raw changelog
+ * text into clear, user-facing release notes.
+ *
+ * The agent returns only the polished markdown — no commands, no confirmation.
  */
 export function buildPolishPrompt(opts: BuildPolishPromptOpts): string {
-  const { changelog, version, currentVersion, channels, commands } = opts;
-
-  const channelList = channels.map((c) => `- ${c}`).join("\n");
-  const commandList = commands.map((c) => `- \`${c}\``).join("\n");
+  const { changelog, version } = opts;
 
   const changelogSection =
     changelog.trim().length > 0
@@ -24,48 +21,51 @@ export function buildPolishPrompt(opts: BuildPolishPromptOpts): string {
       : "_No notable changes in this release._";
 
   return [
-    "# Release Polish & Confirmation",
-    "",
-    `You are preparing a release of **${version}** (from ${currentVersion}).`,
+    "# Polish Release Notes",
     "",
-    "## Target Channels",
+    `You are polishing changelog notes for **${formatTag(version, opts.tagFormat ?? "v${version}")}**.`,
     "",
-    channelList,
+    "## Raw Changelog",
     "",
-    "## Pre-built Changelog",
+    changelogSection,
     "",
-    "The following changelog was generated from commits. It is raw and may contain",
-    "terse commit-message language.",
+    "## Instructions",
     "",
-    changelogSection,
+    "Rewrite the raw changelog above into clear, user-facing release notes.",
     "",
-    "## Your Task",
+    "### Content rules",
     "",
-    "1. **Polish** the changelog above into clear, user-facing language:",
-    "   - Rewrite terse commit descriptions into plain English a user would understand.",
-    "   - Group closely related changes together under the same bullet.",
-    "   - Remove noise (chores, reformats, typo fixes) unless they fix a user-visible bug.",
-    "   - Do **not** change version numbers.",
-    "   - Do **not** skip or reorder the section headings (Breaking Changes, Features, Fixes, Improvements, Maintenance, Other).",
-    "   - Do **not** invent changes that are not in the raw changelog.",
+    "| Rule | Details |",
+    "|------|---------|",
+    "| Plain English | Rewrite terse commit descriptions so a user understands the impact |",
+    "| Group related | Merge closely related changes into a single bullet |",
+    "| Remove noise | Drop chores, reformats, typo fixes — unless they fix a user-visible bug |",
+    "| No invented changes | Every bullet must trace back to the raw changelog |",
+    "| Preserve headings | Keep section order: Breaking Changes, Features, Fixes, Improvements, Maintenance, Other. Omit empty sections |",
+    "| Preserve versions | Do **not** change version numbers |",
     "",
-    "2. **Present** the polished changelog to the user in a readable format.",
+    "### Superseded changes",
     "",
-    "3. **Ask** the user for confirmation:",
-    '   > "Does this look good? Type **yes** to proceed with the release, or **no** to abort."',
+    "Drop entries whose effect is entirely negated or replaced by a later entry in the same release.",
     "",
-    "## On Approval",
+    "Detect these patterns:",
+    "- **Replaced**: feature A is added, then later replaced by feature B → keep only B.",
+    "- **Reverted**: a change is introduced and then reverted → drop both.",
+    "- **Evolved**: an item is added, then renamed/rewritten → keep only the final form.",
     "",
-    "If the user confirms, run the following commands **in order** without modification:",
+    "The changelog describes the **net state** of the release — what a user upgrading from the previous version actually gets — not the development history that produced it.",
     "",
-    commandList,
+    "```",
+    "before (wrong):",
+    "- Added caching layer for API responses",
+    "- Replaced caching layer with Redis-backed store",
     "",
-    "Do **not** skip any command. Do **not** modify the commands.",
-    "Report the result of each command as it completes.",
+    "after (correct):",
+    "- Added Redis-backed caching for API responses",
+    "```",
     "",
-    "## On Rejection",
+    "## Output",
     "",
-    "If the user rejects, abort the release immediately.",
-    "Inform the user: _Release aborted. No changes were made._",
+    "Return **only** the polished markdown changelog. No preamble, no explanation, no code fences wrapping the whole output.",
   ].join("\n");
 }

package/src/release/version.ts

@@ -8,6 +8,14 @@ type ExecFn = (
   opts?: { cwd?: string },
 ) => Promise<{ stdout: string; stderr: string; code: number }>;
 
+/**
+ * Replace `${version}` in a tag format template with the actual version string.
+ * If the template contains no placeholder, it is returned as-is.
+ */
+export function formatTag(version: string, tagFormat: string): string {
+  return tagFormat.replace("${version}", version);
+}
+
 /**
  * Suggest a semver bump type based on categorized commits.
  * Breaking changes win over features; features win over everything else.
@@ -59,22 +67,133 @@ export function getCurrentVersion(cwd: string): string {
   }
 }
 
+interface ParsedReleaseTag {
+  tag: string;
+  version: string;
+}
+
+const SEMVER_CAPTURE = "([0-9]+\\.[0-9]+\\.[0-9]+(?:-[0-9A-Za-z.-]+)?)";
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function extractVersionFromTag(tag: string, tagFormat: string): string | null {
+  if (!tagFormat.includes("${version}")) {
+    return null;
+  }
+
+  const pattern = `^${escapeRegExp(tagFormat).replace(escapeRegExp("${version}"), SEMVER_CAPTURE)}$`;
+  const match = tag.match(new RegExp(pattern));
+  return match?.[1] ?? null;
+}
+
+function parseReleaseTag(tag: string, tagFormat: string): ParsedReleaseTag | null {
+  const version = extractVersionFromTag(tag, tagFormat) ?? extractVersionFromTag(tag, LEGACY_RELEASE_TAG_FORMAT);
+  return version ? { tag, version } : null;
+}
+
+function compareSemver(left: string, right: string): number {
+  const [leftCore] = left.split("-");
+  const [rightCore] = right.split("-");
+  const leftParts = leftCore.split(".").map(Number);
+  const rightParts = rightCore.split(".").map(Number);
+
+  for (let index = 0; index < 3; index += 1) {
+    const delta = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+    if (delta !== 0) {
+      return delta;
+    }
+  }
+
+  if (left === right) {
+    return 0;
+  }
+
+  return left.includes("-") ? -1 : 1;
+}
+
+async function isTagAtHead(exec: ExecFn, cwd: string, tag: string): Promise<boolean> {
+  const [tagCommit, headCommit] = await Promise.all([
+    exec("git", ["rev-list", "-n", "1", tag], { cwd }),
+    exec("git", ["rev-parse", "HEAD"], { cwd }),
+  ]);
+
+  return tagCommit.code === 0
+    && headCommit.code === 0
+    && tagCommit.stdout.trim() !== ""
+    && tagCommit.stdout.trim() === headCommit.stdout.trim();
+}
+
+export async function findResumableLocalRelease(
+  exec: ExecFn,
+  cwd: string,
+  currentVersion: string,
+  tagFormat: string,
+): Promise<{ version: string; tag: string } | null> {
+  try {
+    const localTags = await exec("git", ["tag", "--merged", "HEAD"], { cwd });
+    if (localTags.code !== 0) {
+      return null;
+    }
+
+    const candidates = localTags.stdout
+      .split(/\r?\n/)
+      .map((tag) => tag.trim())
+      .filter(Boolean)
+      .map((tag) => parseReleaseTag(tag, tagFormat))
+      .filter((candidate): candidate is ParsedReleaseTag => Boolean(candidate))
+      .filter((candidate) => compareSemver(candidate.version, currentVersion) > 0)
+      .sort((left, right) => compareSemver(right.version, left.version));
+
+    for (const candidate of candidates) {
+      const remoteTag = await exec("git", ["ls-remote", "--tags", "origin", candidate.tag], { cwd });
+      if (remoteTag.code !== 0 || remoteTag.stdout.trim() !== "") {
+        continue;
+      }
+
+      if (await isTagAtHead(exec, cwd, candidate.tag)) {
+        return { version: candidate.version, tag: candidate.tag };
+      }
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+
+const LEGACY_RELEASE_TAG_FORMAT = "v${version}";
+
+function getReleaseTagCandidates(version: string, tagFormat: string): string[] {
+  return [...new Set([formatTag(version, tagFormat), formatTag(version, LEGACY_RELEASE_TAG_FORMAT)])];
+}
+
+async function hasMatchingReleaseTag(
+  exec: ExecFn,
+  cwd: string,
+  args: string[],
+  version: string,
+  tagFormat: string,
+): Promise<boolean> {
+  const result = await exec("git", [...args, ...getReleaseTagCandidates(version, tagFormat)], { cwd });
+  return result.code === 0 && result.stdout.trim().length > 0;
+}
 
 /**
  * Check whether a tag for the given version already exists locally.
- * Returns `true` when `v{version}` is a known git tag — meaning this
- * version has already been released and a bump is needed.
+ * Returns `true` when either the current-format tag or the legacy `v{version}`
+ * tag is already known locally, which means this version was already released.
  */
 export async function isVersionReleased(
   exec: ExecFn,
   cwd: string,
   version: string,
+  tagFormat: string,
 ): Promise<boolean> {
   try {
-    const tag = version.startsWith("v") ? version : `v${version}`;
-    const result = await exec("git", ["tag", "-l", tag], { cwd });
-    // git tag -l prints matching tags, one per line. Non-empty = exists.
-    return result.code === 0 && result.stdout.trim().length > 0;
+    return await hasMatchingReleaseTag(exec, cwd, ["tag", "-l"], version, tagFormat);
   } catch {
     return false;
   }
@@ -82,17 +201,17 @@ export async function isVersionReleased(
 
 /**
  * Check whether a tag for the given version exists on the remote (origin).
- * Returns true when `v{version}` is found via `git ls-remote --tags origin`.
+ * Returns true when either the current-format tag or the legacy `v{version}`
+ * tag is found via `git ls-remote --tags origin`.
  */
 export async function isTagOnRemote(
   exec: ExecFn,
   cwd: string,
   version: string,
+  tagFormat: string,
 ): Promise<boolean> {
   try {
-    const tag = version.startsWith("v") ? version : `v${version}`;
-    const result = await exec("git", ["ls-remote", "--tags", "origin", tag], { cwd });
-    return result.code === 0 && result.stdout.trim().length > 0;
+    return await hasMatchingReleaseTag(exec, cwd, ["ls-remote", "--tags", "origin"], version, tagFormat);
   } catch {
     return false;
   }