@treeseed/sdk 0.6.36 → 0.6.38

package/dist/operations/services/git-workflow.js

@@ -162,7 +162,7 @@ function remoteBranchExists(repoDir, branchName) {
   }
 }
 function fetchOrigin(repoDir) {
-  runGit(["fetch", "origin"], { cwd: repoDir });
+  runGit(["fetch", "origin"], { cwd: repoDir, capture: true });
 }
 function ensureLocalBranchTracking(repoDir, branchName) {
   if (branchExists(repoDir, branchName)) {
@@ -175,7 +175,7 @@ function ensureLocalBranchTracking(repoDir, branchName) {
   runGit(["checkout", "--orphan", branchName], { cwd: repoDir });
 }
 function checkoutBranch(repoDir, branchName) {
-  runGit(["checkout", branchName], { cwd: repoDir });
+  runGit(["checkout", branchName], { cwd: repoDir, capture: true });
 }
 function checkoutTaskBranchFromStaging(cwd, branchName, { createIfMissing = true, pushIfCreated = false } = {}) {
   const repoDir = assertCleanWorktree(cwd);
@@ -244,7 +244,7 @@ function syncBranchWithOrigin(repoDir, branchName) {
     checkoutBranch(repoDir, branchName);
   }
   if (remoteBranchExists(repoDir, branchName)) {
-    runGit(["merge", "--ff-only", `origin/${branchName}`], { cwd: repoDir });
+    runGit(["merge", "--ff-only", `origin/${branchName}`], { cwd: repoDir, capture: true });
   }
 }
 function checkoutDetachedOriginBranch(repoDir, branchName) {
@@ -420,8 +420,8 @@ function createDeprecatedTaskTag(repoDir, branchName, message) {
   return { tagName, head };
 }
 function waitForStagingAutomation(repoDir) {
-  if (process.env.TREESEED_STAGE_WAIT_MODE === "skip" || process.env.TREESEED_GITHUB_AUTOMATION_MODE === "stub") {
-    return { status: "skipped", reason: "stubbed" };
+  if (process.env.TREESEED_STAGE_WAIT_MODE === "skip") {
+    return { status: "skipped", reason: "disabled" };
   }
   try {
     const gh = resolveTreeseedToolBinary("gh");

package/dist/operations/services/github-actions-verification.d.ts

@@ -16,6 +16,8 @@ export type GitHubActionsWorkflowGate = {
     workflow: string;
     branch: string;
     headSha: string;
+    timeoutSeconds?: number;
+    pollSeconds?: number;
 };
 export type GitHubActionsWorkflowJobStep = {
     name: string;
@@ -116,6 +118,8 @@ export declare function skippedGitHubActionsGate(gate: GitHubActionsWorkflowGate
     url: null;
     createdAt: null;
     updatedAt: null;
+    timeoutSeconds: number | null;
+    cached: boolean;
 };
 export declare function formatGitHubActionsGateFailure(gate: GitHubActionsWorkflowGate, result: Record<string, unknown>): string;
 export declare function createGitHubActionsGateProgressReporter(gate: GitHubActionsWorkflowGate, options?: {

package/dist/operations/services/github-actions-verification.js

@@ -408,7 +408,9 @@ function skippedGitHubActionsGate(gate, reason) {
     runId: null,
     url: null,
     createdAt: null,
-    updatedAt: null
+    updatedAt: null,
+    timeoutSeconds: gate.timeoutSeconds ?? null,
+    cached: false
   };
 }
 function formatGitHubActionsGateFailure(gate, result) {
@@ -537,8 +539,8 @@ async function waitForGitHubActionsGate(gate, options = {}) {
     workflow: gate.workflow,
     headSha: gate.headSha,
     branch: gate.branch,
-    timeoutSeconds: options.timeoutSeconds,
-    pollSeconds: options.pollSeconds,
+    timeoutSeconds: gate.timeoutSeconds ?? options.timeoutSeconds,
+    pollSeconds: gate.pollSeconds ?? options.pollSeconds,
     onProgress: reportProgress
   });
 }

package/dist/operations/services/github-automation.d.ts

@@ -22,7 +22,7 @@ export interface TreeseedGitHubRepositoryTarget {
     visibility: 'private' | 'public' | 'internal';
     source: 'config' | 'origin' | 'default';
 }
-export declare function getGitHubAutomationMode(): "stub" | "real";
+export declare function getGitHubAutomationMode(): string;
 export declare function parseGitHubRepositoryFromRemote(remoteUrl: any): string | null;
 export declare function resolveGitHubRepositorySlug(tenantRoot: any): string;
 export declare function maybeResolveGitHubRepositorySlug(tenantRoot: any): string | null;
@@ -51,17 +51,7 @@ export declare function ensureGitHubBootstrapRepository(tenantRoot: string, { va
     pushed: boolean;
     mode: string;
 }>;
-export declare function createGitHubRepository(input: any): Promise<import("./github-api.ts").GitHubRepositorySummary | {
-    visibility: any;
-    defaultBranch: string;
-    mode: string;
-    slug: string;
-    owner: string;
-    name: string;
-    sshUrl: string;
-    httpsUrl: string;
-    url: string;
-}>;
+export declare function createGitHubRepository(input: any): Promise<import("./github-api.ts").GitHubRepositorySummary>;
 export declare function initializeGitHubRepositoryWorkingTree(cwd: any, repository: any, { defaultBranch, createStaging, commitMessage, remoteName, push, }?: {
     defaultBranch?: string | undefined;
     createStaging?: boolean | undefined;
@@ -74,14 +64,6 @@ export declare function initializeGitHubRepositoryWorkingTree(cwd: any, reposito
     defaultBranch: string;
     stagingBranch: string | null;
     pushed: boolean;
-    mode: string;
-} | {
-    repository: any;
-    remoteName: string;
-    defaultBranch: string;
-    stagingBranch: string | null;
-    pushed: boolean;
-    mode?: undefined;
 };
 export declare function resolveGitRepositoryRoot(tenantRoot: any): any;
 export declare function requiredGitHubEnvironment(tenantRoot: any, { scope, purpose }?: {
@@ -99,38 +81,20 @@ export declare function renderHostedProjectWorkflow({ workingDirectory }: {
     workingDirectory: any;
 }): string;
 export declare function ensureDeployWorkflow(tenantRoot: any): {
-    workflowPath: string;
-    changed: boolean;
-    workingDirectory: string;
-    mode: string;
-} | {
     workingDirectory: string;
     workflowPath: string;
     changed: boolean;
-    mode?: undefined;
 };
 export declare function ensureHostedProjectWorkflow(tenantRoot: any): {
-    workflowPath: string;
-    changed: boolean;
-    workingDirectory: string;
-    mode: string;
-} | {
     workingDirectory: string;
     workflowPath: string;
     changed: boolean;
-    mode?: undefined;
 };
-export declare function ensureStandardizedGitHubWorkflows(tenantRoot: any): ({
-    workflowPath: string;
-    changed: boolean;
-    workingDirectory: string;
-    mode: string;
-} | {
+export declare function ensureStandardizedGitHubWorkflows(tenantRoot: any): {
     workingDirectory: string;
     workflowPath: string;
     changed: boolean;
-    mode?: undefined;
-})[];
+}[];
 export declare function listGitHubSecretNames(repository: any, tenantRoot: any): Promise<Set<string>>;
 export declare function listGitHubVariableNames(repository: any, tenantRoot: any): Promise<Set<string>>;
 export declare function formatMissingSecretsReport(repository: any, missingSecrets: any, reason?: string): string;
@@ -139,9 +103,6 @@ export declare function ensureGitHubSecrets(tenantRoot: any, { dryRun }?: {
 }): Promise<{
     existing: never[];
     created: never[];
-} | {
-    existing: never[];
-    created: never[];
 } | {
     existing: string[];
     created: string[];
@@ -152,18 +113,6 @@ export declare function ensureGitHubEnvironment(tenantRoot: any, { dryRun, scope
     purpose?: string | undefined;
     valuesOverlay?: {} | undefined;
 }): Promise<{
-    repository: string | null;
-    secrets: {
-        existing: never[];
-        created: never[];
-    };
-    variables: {
-        existing: never[];
-        created: never[];
-    };
-    skipped: string;
-    mode: string;
-} | {
     repository: null;
     secrets: {
         existing: never[];
@@ -174,7 +123,6 @@ export declare function ensureGitHubEnvironment(tenantRoot: any, { dryRun, scope
         created: never[];
     };
     skipped: string;
-    mode?: undefined;
 } | {
     repository: string;
     secrets: {
@@ -186,7 +134,6 @@ export declare function ensureGitHubEnvironment(tenantRoot: any, { dryRun, scope
         created: string[];
     };
     skipped?: undefined;
-    mode?: undefined;
 }>;
 export declare function ensureGitHubDeployAutomation(tenantRoot: any, { dryRun, valuesOverlay }?: {
     dryRun?: boolean | undefined;
@@ -194,33 +141,18 @@ export declare function ensureGitHubDeployAutomation(tenantRoot: any, { dryRun,
 }): Promise<{
     mode: string;
     workflow: {
-        workflowPath: string;
-        changed: boolean;
-        workingDirectory: string;
-        mode: string;
-    } | {
         workingDirectory: string;
         workflowPath: string;
         changed: boolean;
-        mode?: undefined;
     };
-    workflows: ({
-        workflowPath: string;
-        changed: boolean;
-        workingDirectory: string;
-        mode: string;
-    } | {
+    workflows: {
         workingDirectory: string;
         workflowPath: string;
         changed: boolean;
-        mode?: undefined;
-    })[];
+    }[];
     secrets: {
         existing: never[];
         created: never[];
-    } | {
-        existing: never[];
-        created: never[];
     } | {
         existing: string[];
         created: string[];
@@ -228,26 +160,11 @@ export declare function ensureGitHubDeployAutomation(tenantRoot: any, { dryRun,
     variables: {
         existing: never[];
         created: never[];
-    } | {
-        existing: never[];
-        created: never[];
     } | {
         existing: string[];
         created: string[];
     };
     environment: {
-        repository: string | null;
-        secrets: {
-            existing: never[];
-            created: never[];
-        };
-        variables: {
-            existing: never[];
-            created: never[];
-        };
-        skipped: string;
-        mode: string;
-    } | {
         repository: null;
         secrets: {
             existing: never[];
@@ -258,7 +175,6 @@ export declare function ensureGitHubDeployAutomation(tenantRoot: any, { dryRun,
             created: never[];
         };
         skipped: string;
-        mode?: undefined;
     } | {
         repository: string;
         secrets: {
@@ -270,7 +186,6 @@ export declare function ensureGitHubDeployAutomation(tenantRoot: any, { dryRun,
             created: string[];
         };
         skipped?: undefined;
-        mode?: undefined;
     };
 }>;
 export declare function waitForGitHubWorkflowCompletion(tenantRoot: any, { repository, workflow, headSha, branch, timeoutSeconds, pollSeconds, onProgress, }?: {
@@ -290,11 +205,4 @@ export declare function waitForGitHubWorkflowCompletion(tenantRoot: any, { repos
     url: string | null;
     jobs: import("./github-api.ts").GitHubWorkflowJobSummary[];
     failedJobs: import("./github-api.ts").GitHubWorkflowJobSummary[];
-} | {
-    status: string;
-    reason: string;
-    repository: any;
-    workflow: string;
-    headSha: any;
-    branch: any;
 }>;

package/dist/operations/services/github-automation.js

@@ -22,10 +22,7 @@ function slugifySegment(value, fallback = "project") {
   return String(value ?? "").trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-").slice(0, 96) || fallback;
 }
 function getGitHubAutomationMode() {
-  return process.env.TREESEED_GITHUB_AUTOMATION_MODE === "stub" ? "stub" : "real";
-}
-function isGitHubAutomationStubbed() {
-  return getGitHubAutomationMode() === "stub";
+  return "real";
 }
 function parseGitHubRepositoryFromRemote(remoteUrl) {
   if (!remoteUrl) {
@@ -170,17 +167,6 @@ async function ensureGitHubBootstrapRepository(tenantRoot, {
   const remotes = resolveGitHubRemoteUrls(target.owner, target.name);
   const slug = remotes.slug;
   onProgress?.(`[local][github][repo] Preparing ${slug} from ${target.source}...`);
-  if (isGitHubAutomationStubbed()) {
-    onProgress?.(`[local][github][repo] Stubbed GitHub automation; repository ${slug} not changed.`);
-    return {
-      repository: slug,
-      target,
-      created: false,
-      remote: { changed: false, previous: null, next: remotes.sshUrl },
-      pushed: false,
-      mode: "stub"
-    };
-  }
   const client = createGitHubApiClient({
     env: {
       GH_TOKEN: configuredValue(values, "GH_TOKEN") || configuredValue(values, "GITHUB_TOKEN"),
@@ -217,14 +203,6 @@ async function ensureGitHubBootstrapRepository(tenantRoot, {
 async function createGitHubRepository(input) {
   const visibility = input.visibility ?? "private";
   const remotes = resolveGitHubRemoteUrls(input.owner, input.name);
-  if (isGitHubAutomationStubbed()) {
-    return {
-      ...remotes,
-      visibility,
-      defaultBranch: "main",
-      mode: "stub"
-    };
-  }
   return await ensureGitHubRepository({
     owner: remotes.owner,
     name: remotes.name,
@@ -243,16 +221,6 @@ function initializeGitHubRepositoryWorkingTree(cwd, repository, {
   remoteName = "origin",
   push = true
 } = {}) {
-  if (isGitHubAutomationStubbed()) {
-    return {
-      repository,
-      remoteName,
-      defaultBranch,
-      stagingBranch: createStaging ? "staging" : null,
-      pushed: false,
-      mode: "stub"
-    };
-  }
   runGit(["init", "-b", defaultBranch], { cwd, allowFailure: true });
   ensureGitIdentity(cwd);
   const currentRemote = runGit(["remote", "get-url", remoteName], { cwd, allowFailure: true }).stdout?.trim() ?? "";
@@ -348,14 +316,6 @@ function ensureWorkflowFile(tenantRoot, fileName, expected) {
   return { workflowPath, changed: true };
 }
 function ensureDeployWorkflow(tenantRoot) {
-  if (isGitHubAutomationStubbed()) {
-    return {
-      workflowPath: resolve(tenantRoot, ".github", "workflows", "deploy.yml"),
-      changed: false,
-      workingDirectory: ".",
-      mode: "stub"
-    };
-  }
   const repositoryRoot = resolveGitRepositoryRoot(tenantRoot);
   const workingDirectory = relative(repositoryRoot, tenantRoot).replaceAll("\\", "/") || ".";
   const expected = renderDeployWorkflow({ workingDirectory });
@@ -365,14 +325,6 @@ function ensureDeployWorkflow(tenantRoot) {
   };
 }
 function ensureHostedProjectWorkflow(tenantRoot) {
-  if (isGitHubAutomationStubbed()) {
-    return {
-      workflowPath: resolve(tenantRoot, ".github", "workflows", "hosted-project.yml"),
-      changed: false,
-      workingDirectory: ".",
-      mode: "stub"
-    };
-  }
   const repositoryRoot = resolveGitRepositoryRoot(tenantRoot);
   const workingDirectory = relative(repositoryRoot, tenantRoot).replaceAll("\\", "/") || ".";
   const expected = renderHostedProjectWorkflow({ workingDirectory });
@@ -419,21 +371,6 @@ function nonEmptyValues(values = {}) {
   );
 }
 async function ensureGitHubEnvironment(tenantRoot, { dryRun = false, scope = "prod", purpose = "save", valuesOverlay = {} } = {}) {
-  if (isGitHubAutomationStubbed()) {
-    return {
-      repository: maybeResolveGitHubRepositorySlug(tenantRoot),
-      secrets: {
-        existing: [],
-        created: []
-      },
-      variables: {
-        existing: [],
-        created: []
-      },
-      skipped: "stubbed",
-      mode: "stub"
-    };
-  }
   const repository = maybeResolveGitHubRepositorySlug(tenantRoot);
   if (!repository) {
     if (dryRun) {
@@ -518,16 +455,6 @@ async function waitForGitHubWorkflowCompletion(tenantRoot, {
   pollSeconds = 5,
   onProgress
 } = {}) {
-  if (isGitHubAutomationStubbed()) {
-    return {
-      status: "skipped",
-      reason: "stubbed",
-      repository: repository ?? maybeResolveGitHubRepositorySlug(tenantRoot),
-      workflow,
-      headSha: headSha ?? null,
-      branch: branch ?? null
-    };
-  }
   const repo = repository ?? resolveGitHubRepositorySlug(tenantRoot);
   return await waitForGitHubWorkflowRunCompletion(repo, {
     client: createGitHubApiClient(),

package/dist/operations/services/release-candidate.js

@@ -4,7 +4,7 @@ import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, write
 import { tmpdir } from "node:os";
 import { dirname, join, relative, resolve } from "node:path";
 import { isTreeseedEnvironmentEntryRelevant, isTreeseedEnvironmentEntryRequired } from "../../platform/environment.js";
-import { getGitHubAutomationMode, maybeResolveGitHubRepositorySlug } from "./github-automation.js";
+import { maybeResolveGitHubRepositorySlug } from "./github-automation.js";
 import { createGitHubApiClient, listGitHubEnvironmentSecretNames, listGitHubEnvironmentVariableNames } from "./github-api.js";
 import { collectInternalDevReferenceIssues } from "./package-reference-policy.js";
 import { collectTreeseedEnvironmentContext, resolveTreeseedMachineEnvironmentValues, validateTreeseedCommandEnvironment } from "./config-runtime.js";
@@ -123,9 +123,6 @@ function packageReadinessChecks(root, selectedPackageNames, failures) {
   if (selectedPackageNames.length === 0) {
     return { name: "package-release-readiness", status: "skipped", detail: "No packages are selected for this release." };
   }
-  if (getGitHubAutomationMode() === "stub") {
-    return { name: "package-release-readiness", status: "skipped", detail: "GitHub automation is stubbed." };
-  }
   const selected = new Set(selectedPackageNames);
   const packages = workspacePackages(root).filter((pkg) => selected.has(pkg.name));
   for (const pkg of packages) {
@@ -266,8 +263,8 @@ function buildRehearsalWorkspacePackageArtifacts(root) {
   }
 }
 function runProductionDependencyRehearsal(root, plannedVersions, selectedPackageNames, failures) {
-  if (getGitHubAutomationMode() === "stub" || process.env.TREESEED_RELEASE_CANDIDATE_REHEARSAL_MODE === "skip") {
-    return "Skipped clean install rehearsal in stub/skip mode.";
+  if (process.env.TREESEED_RELEASE_CANDIDATE_REHEARSAL_MODE === "skip") {
+    return "Skipped clean install rehearsal by request.";
   }
   const selectedPackageSet = new Set(selectedPackageNames);
   let tempParent = null;
@@ -379,9 +376,6 @@ function localConfigCheck(root, scope, failures) {
   }
 }
 async function githubRemoteConfigCheck(root, scope, failures) {
-  if (getGitHubAutomationMode() === "stub") {
-    return;
-  }
   const repository = maybeResolveGitHubRepositorySlug(root);
   if (!repository) {
     addFailure(failures, {
@@ -490,8 +484,8 @@ function providerResourceIdentifierCheck(root, scope, failures) {
   }
 }
 async function configParityChecks(root, failures) {
-  if (getGitHubAutomationMode() === "stub") {
-    return { name: "config-parity", status: "skipped", detail: "GitHub automation is stubbed." };
+  if (process.env.TREESEED_RELEASE_CANDIDATE_CONFIG_PARITY_MODE === "skip") {
+    return { name: "config-parity", status: "skipped", detail: "Remote config parity skipped by request." };
   }
   const before = failures.length;
   localConfigCheck(root, "staging", failures);

package/dist/operations/services/release-history.d.ts

@@ -0,0 +1,59 @@
+export type ReleaseHistoryCommit = {
+    sha: string;
+    subject: string;
+    body: string;
+};
+export type ReleaseHistorySection = 'Added' | 'Changed' | 'Fixed' | 'Infrastructure' | 'Tests' | 'Dependencies';
+export type ReleaseHistorySummary = {
+    version: string;
+    date: string;
+    sourceRef: string;
+    targetRef: string;
+    commitCount: number;
+    sections: Record<ReleaseHistorySection, string[]>;
+    notableCommits: ReleaseHistoryCommit[];
+    changelogPath: string;
+    changelogUpdated: boolean;
+    entry: string;
+};
+export declare function collectReleaseHistoryCommits(repoDir: string, sourceRef: string, targetRef: string, options?: {
+    maxCommits?: number;
+}): ReleaseHistoryCommit[];
+export declare function renderReleaseChangelogEntry(input: {
+    version: string;
+    date?: string;
+    commits: ReleaseHistoryCommit[];
+    extraBullets?: Partial<Record<ReleaseHistorySection, string[]>>;
+}): {
+    date: string;
+    sections: Record<ReleaseHistorySection, string[]>;
+    entry: string;
+};
+export declare function upsertReleaseChangelog(repoDir: string, input: {
+    version: string;
+    sourceRef: string;
+    targetRef: string;
+    commits: ReleaseHistoryCommit[];
+    extraBullets?: Partial<Record<ReleaseHistorySection, string[]>>;
+}): {
+    version: string;
+    date: string;
+    sourceRef: string;
+    targetRef: string;
+    commitCount: number;
+    sections: Record<ReleaseHistorySection, string[]>;
+    notableCommits: ReleaseHistoryCommit[];
+    changelogPath: string;
+    changelogUpdated: boolean;
+    entry: string;
+};
+export declare function renderAdministrativeCommitMessage(input: {
+    subject: string;
+    version?: string | null;
+    tagName?: string | null;
+    sourceRef: string;
+    targetRef: string;
+    commits: ReleaseHistoryCommit[];
+    changelog?: ReleaseHistorySummary | null;
+    extraLines?: string[];
+}): string;

package/dist/operations/services/release-history.js

@@ -0,0 +1,159 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+const SECTION_ORDER = [
+  "Added",
+  "Changed",
+  "Fixed",
+  "Infrastructure",
+  "Tests",
+  "Dependencies"
+];
+function runGit(repoDir, args) {
+  const result = spawnSync("git", args, {
+    cwd: repoDir,
+    stdio: "pipe",
+    encoding: "utf8"
+  });
+  if (result.status !== 0) {
+    throw new Error(result.stderr?.trim() || result.stdout?.trim() || `git ${args.join(" ")} failed`);
+  }
+  return result.stdout;
+}
+function shortSha(value) {
+  return value.slice(0, 12);
+}
+function cleanLine(value) {
+  return value.replace(/\s+/gu, " ").trim();
+}
+function bulletText(commit) {
+  const subject = cleanLine(commit.subject);
+  return subject ? `${subject} (${shortSha(commit.sha)})` : shortSha(commit.sha);
+}
+function sectionForCommit(commit) {
+  const value = `${commit.subject}
+${commit.body}`.toLowerCase();
+  if (/^(feat|add)(\(|:)/u.test(value) || /\badded?\b/u.test(value)) return "Added";
+  if (/^(fix|hotfix)(\(|:)/u.test(value) || /\bfix(e[ds])?\b|\bbug\b/u.test(value)) return "Fixed";
+  if (/^(test)(\(|:)/u.test(value) || /\btest(s|ing)?\b|\bverify\b/u.test(value)) return "Tests";
+  if (/^(deps?|build)(\(|:)/u.test(value) || /\bdependenc(y|ies)\b|\blockfile\b|\bpackage pointer\b/u.test(value)) return "Dependencies";
+  if (/^(ci|chore|release)(\(|:)/u.test(value) || /\bdeploy\b|\bworkflow\b|\brelease\b|\bsubmodule\b/u.test(value)) return "Infrastructure";
+  return "Changed";
+}
+function uniqueSectionBullets(commits) {
+  const sections = Object.fromEntries(SECTION_ORDER.map((section) => [section, []]));
+  const seen = /* @__PURE__ */ new Set();
+  for (const commit of commits) {
+    const bullet = bulletText(commit);
+    const key = bullet.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    sections[sectionForCommit(commit)].push(bullet);
+  }
+  return sections;
+}
+function collectReleaseHistoryCommits(repoDir, sourceRef, targetRef, options = {}) {
+  const maxCommits = options.maxCommits ?? 80;
+  const output = runGit(repoDir, [
+    "log",
+    "--no-merges",
+    `--max-count=${maxCommits}`,
+    "--format=%H%x1f%s%x1f%b%x1e",
+    `${sourceRef}..${targetRef}`
+  ]);
+  return output.split("").map((entry) => entry.trim()).filter(Boolean).map((entry) => {
+    const [sha = "", subject = "", body = ""] = entry.split("");
+    return { sha: sha.trim(), subject: subject.trim(), body: body.trim() };
+  }).filter((commit) => commit.sha.length > 0);
+}
+function renderReleaseChangelogEntry(input) {
+  const date = input.date ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const sections = uniqueSectionBullets(input.commits);
+  for (const [section, bullets] of Object.entries(input.extraBullets ?? {})) {
+    for (const bullet of bullets ?? []) {
+      const normalized = cleanLine(bullet);
+      if (normalized) sections[section].push(normalized);
+    }
+  }
+  const lines = [`## [${input.version}] - ${date}`, ""];
+  let wroteSection = false;
+  for (const section of SECTION_ORDER) {
+    const bullets = sections[section];
+    if (bullets.length === 0) continue;
+    wroteSection = true;
+    lines.push(`### ${section}`, "");
+    for (const bullet of bullets.slice(0, 20)) {
+      lines.push(`- ${bullet}`);
+    }
+    if (bullets.length > 20) {
+      lines.push(`- ${bullets.length - 20} additional change${bullets.length - 20 === 1 ? "" : "s"} omitted from this summary.`);
+    }
+    lines.push("");
+  }
+  if (!wroteSection) {
+    lines.push("### Changed", "", "- Release metadata and deployment history updated.", "");
+  }
+  return {
+    date,
+    sections,
+    entry: lines.join("\n").trimEnd()
+  };
+}
+function upsertReleaseChangelog(repoDir, input) {
+  const rendered = renderReleaseChangelogEntry(input);
+  const changelogPath = resolve(repoDir, "CHANGELOG.md");
+  const current = existsSync(changelogPath) ? readFileSync(changelogPath, "utf8") : "";
+  const title = "# Changelog";
+  const withoutExisting = current.replace(new RegExp(`^# Changelog\\s*\\n+## \\[${input.version.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}\\][\\s\\S]*?(?=\\n## \\[|$)`, "u"), `${title}
+
+`).trim();
+  const body = withoutExisting.startsWith(title) ? withoutExisting.slice(title.length).trim() : withoutExisting.trim();
+  const next = `${title}
+
+${rendered.entry}${body ? `
+
+${body}` : ""}
+`;
+  const changed = current !== next;
+  if (changed) {
+    writeFileSync(changelogPath, next, "utf8");
+  }
+  return {
+    version: input.version,
+    date: rendered.date,
+    sourceRef: input.sourceRef,
+    targetRef: input.targetRef,
+    commitCount: input.commits.length,
+    sections: rendered.sections,
+    notableCommits: input.commits.slice(0, 12),
+    changelogPath,
+    changelogUpdated: changed,
+    entry: rendered.entry
+  };
+}
+function renderAdministrativeCommitMessage(input) {
+  const lines = [
+    input.subject,
+    "",
+    "Release summary:",
+    input.version ? `- Version: ${input.version}` : null,
+    input.tagName ? `- Tag: ${input.tagName}` : null,
+    `- Source: ${input.sourceRef}`,
+    `- Target: ${input.targetRef}`,
+    `- Promoted commits: ${input.commits.length}`,
+    ...(input.extraLines ?? []).map((line) => `- ${line}`),
+    "",
+    "Notable changes:",
+    ...input.commits.length > 0 ? input.commits.slice(0, 12).map((commit) => `- ${bulletText(commit)}`) : ["- Release metadata and package pointers updated."],
+    input.commits.length > 12 ? `- ${input.commits.length - 12} additional promoted commit${input.commits.length - 12 === 1 ? "" : "s"} omitted from this summary.` : null,
+    input.changelog ? "" : null,
+    input.changelog ? "See CHANGELOG.md for the release history entry." : null
+  ].filter((line) => line !== null);
+  return lines.join("\n");
+}
+export {
+  collectReleaseHistoryCommits,
+  renderAdministrativeCommitMessage,
+  renderReleaseChangelogEntry,
+  upsertReleaseChangelog
+};