@papi-ai/server 0.7.52 → 0.7.53

package/dist/backfill-cycle-metrics.js

@@ -25,6 +25,7 @@ __export(git_exports, {
   detectUnrecordedCommits: () => detectUnrecordedCommits,
   ensureLatestDevelop: () => ensureLatestDevelop,
   ensureTagAtHead: () => ensureTagAtHead,
+  findTaskCommitsOnBase: () => findTaskCommitsOnBase,
   getBranchDiff: () => getBranchDiff,
   getCommitsSinceTag: () => getCommitsSinceTag,
   getCurrentBranch: () => getCurrentBranch,
@@ -718,11 +719,29 @@ function escapeRegexLiteral(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function detectMergedInProgress(cwd, preferredBase, tasks) {
-  if (!isGitAvailable() || !isGitRepo(cwd)) return [];
   const inProgress = tasks.filter((t) => t.status === "In Progress");
   if (inProgress.length === 0) return [];
+  const landed = findTaskCommitsOnBase(cwd, preferredBase, inProgress.map((t) => t.displayId));
+  const hits = [];
+  for (const task of inProgress) {
+    const hit = landed.get(task.displayId);
+    if (!hit) continue;
+    hits.push({
+      displayId: task.displayId,
+      title: task.title,
+      commit: hit.commit,
+      subject: hit.subject,
+      pr: hit.pr
+    });
+  }
+  return hits;
+}
+function findTaskCommitsOnBase(cwd, preferredBase, displayIds) {
+  const out = /* @__PURE__ */ new Map();
+  if (displayIds.length === 0) return out;
+  if (!isGitAvailable() || !isGitRepo(cwd)) return out;
   const base = resolveDefaultBranch(cwd, preferredBase);
-  if (!branchExists(cwd, base)) return [];
+  if (!branchExists(cwd, base)) return out;
   let raw;
   try {
     raw = execFileSync(
@@ -731,28 +750,25 @@ function detectMergedInProgress(cwd, preferredBase, tasks) {
       { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
     );
   } catch {
-    return [];
+    return out;
   }
   const commits = raw.split("\n").map((line) => {
     const idx = line.indexOf("
");
     if (idx === -1) return null;
     return { hash: line.slice(0, idx).trim(), subject: line.slice(idx + 1).trim() };
   }).filter((c) => c !== null && c.hash !== "");
-  const hits = [];
-  for (const task of inProgress) {
-    const re = new RegExp(`(^|[^\\w-])${escapeRegexLiteral(task.displayId)}([^\\w-]|$)`);
+  for (const displayId of displayIds) {
+    const re = new RegExp(`(^|[^\\w-])${escapeRegexLiteral(displayId)}([^\\w-]|$)`);
     const hit = commits.find((c) => re.test(c.subject));
     if (!hit) continue;
     const prMatch = hit.subject.match(/#(\d+)/);
-    hits.push({
-      displayId: task.displayId,
-      title: task.title,
+    out.set(displayId, {
       commit: hit.hash,
       subject: hit.subject,
       pr: prMatch ? `#${prMatch[1]}` : null
     });
   }
-  return hits;
+  return out;
 }
 function detectUnrecordedCommits(cwd, baseBranch) {
   if (!isGitAvailable() || !isGitRepo(cwd)) return [];

package/dist/index.js

@@ -26,6 +26,7 @@ __export(git_exports, {
   detectUnrecordedCommits: () => detectUnrecordedCommits,
   ensureLatestDevelop: () => ensureLatestDevelop,
   ensureTagAtHead: () => ensureTagAtHead,
+  findTaskCommitsOnBase: () => findTaskCommitsOnBase,
   getBranchDiff: () => getBranchDiff,
   getCommitsSinceTag: () => getCommitsSinceTag,
   getCurrentBranch: () => getCurrentBranch,
@@ -719,11 +720,29 @@ function escapeRegexLiteral(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function detectMergedInProgress(cwd, preferredBase, tasks) {
-  if (!isGitAvailable() || !isGitRepo(cwd)) return [];
   const inProgress = tasks.filter((t) => t.status === "In Progress");
   if (inProgress.length === 0) return [];
+  const landed = findTaskCommitsOnBase(cwd, preferredBase, inProgress.map((t) => t.displayId));
+  const hits = [];
+  for (const task of inProgress) {
+    const hit = landed.get(task.displayId);
+    if (!hit) continue;
+    hits.push({
+      displayId: task.displayId,
+      title: task.title,
+      commit: hit.commit,
+      subject: hit.subject,
+      pr: hit.pr
+    });
+  }
+  return hits;
+}
+function findTaskCommitsOnBase(cwd, preferredBase, displayIds) {
+  const out = /* @__PURE__ */ new Map();
+  if (displayIds.length === 0) return out;
+  if (!isGitAvailable() || !isGitRepo(cwd)) return out;
   const base = resolveDefaultBranch(cwd, preferredBase);
-  if (!branchExists(cwd, base)) return [];
+  if (!branchExists(cwd, base)) return out;
   let raw;
   try {
     raw = execFileSync(
@@ -732,28 +751,25 @@ function detectMergedInProgress(cwd, preferredBase, tasks) {
       { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
     );
   } catch {
-    return [];
+    return out;
   }
   const commits = raw.split("\n").map((line) => {
     const idx = line.indexOf("
");
     if (idx === -1) return null;
     return { hash: line.slice(0, idx).trim(), subject: line.slice(idx + 1).trim() };
   }).filter((c) => c !== null && c.hash !== "");
-  const hits = [];
-  for (const task of inProgress) {
-    const re = new RegExp(`(^|[^\\w-])${escapeRegexLiteral(task.displayId)}([^\\w-]|$)`);
+  for (const displayId of displayIds) {
+    const re = new RegExp(`(^|[^\\w-])${escapeRegexLiteral(displayId)}([^\\w-]|$)`);
     const hit = commits.find((c) => re.test(c.subject));
     if (!hit) continue;
     const prMatch = hit.subject.match(/#(\d+)/);
-    hits.push({
-      displayId: task.displayId,
-      title: task.title,
+    out.set(displayId, {
       commit: hit.hash,
       subject: hit.subject,
       pr: prMatch ? `#${prMatch[1]}` : null
     });
   }
-  return hits;
+  return out;
 }
 function detectUnrecordedCommits(cwd, baseBranch) {
   if (!isGitAvailable() || !isGitRepo(cwd)) return [];
@@ -19087,15 +19103,35 @@ async function createRelease(config2, branch, version, adapter2, cycleNum, optio
   if (adapter2 && resolvedCycleNum > 0) {
     try {
       const stampedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const resolvedBase = resolveBaseBranch(config2.projectRoot, branch);
       const doneCycleTasks = (await adapter2.queryBoard()).filter(
         (t) => t.cycle === resolvedCycleNum && t.status === "Done"
       );
+      const canVerify = isGitAvailable() && isGitRepo(config2.projectRoot);
+      const landed = canVerify ? findTaskCommitsOnBase(
+        config2.projectRoot,
+        resolvedBase,
+        doneCycleTasks.map((t) => t.displayId)
+      ) : /* @__PURE__ */ new Map();
+      const unverified = [];
       for (const t of doneCycleTasks) {
+        const hit = landed.get(t.displayId);
+        if (canVerify && !hit) {
+          unverified.push(
+            `${t.displayId}${t.branchName ? ` (branch \`${t.branchName}\`)` : " (no branch recorded)"}`
+          );
+          continue;
+        }
         try {
           await adapter2.updateTask(t.id, { mergedAt: stampedAt });
         } catch {
         }
       }
+      if (unverified.length > 0) {
+        warnings.push(
+          `\u26A0\uFE0F DATA-INTEGRITY \u2014 ${unverified.length} task(s) are marked **Done** in cycle ${resolvedCycleNum} but their work is NOT on ${resolvedBase}: ${unverified.join("; ")}. They were NOT stamped as merged. Held ad-hoc work is the usual cause (\`ad_hoc\` + \`board_edit\` leaves the branch unmerged by design). Merge the branch(es), or move the task(s) to the next cycle \u2014 do not leave Done unbacked by git.`
+        );
+      }
     } catch {
     }
   }
@@ -19155,6 +19191,44 @@ async function createRelease(config2, branch, version, adapter2, cycleNum, optio
   };
 }
 
+// src/services/release-bookkeeping.ts
+async function beginRelease(tracker, cycleNum) {
+  tracker.setStreamScope({ cycle: cycleNum ?? null });
+  await tracker.recordStep("release_starting");
+}
+async function recordReadinessVerified(tracker) {
+  await tracker.recordStep("readiness_verified");
+}
+async function recordQualityGate(tracker, decision, caps) {
+  await tracker.recordStep("quality_gate", {
+    status: decision.stepStatus,
+    capabilityKey: "releaseGate",
+    capabilityEnabled: isCapabilityEnabled(caps, "releaseGate"),
+    metadata: decision.metadata
+  });
+}
+async function completeRelease(tracker, opts) {
+  tracker.setStreamScope({ cycle: opts.cycleClosed ?? null });
+  await tracker.recordStep("cycle_complete", { metadata: { version: opts.version } });
+  for (const m of opts.branchMerges ?? []) {
+    await tracker.recordStep("branch_merged", {
+      metadata: { branch: m.branch, prUrl: m.prUrl ?? null }
+    });
+  }
+  await tracker.recordStep("changelog", {
+    capabilityKey: "changelog",
+    capabilityEnabled: isCapabilityEnabled(opts.caps, "changelog"),
+    status: opts.changelogEmitted ? "complete" : "active"
+  });
+  if (opts.deployHookEmitted) {
+    await tracker.recordStep("deploy_hook", {
+      capabilityKey: "deployHook",
+      capabilityEnabled: isCapabilityEnabled(opts.caps, "deployHook")
+    });
+  }
+  await tracker.recordStep("released", { metadata: { version: opts.version } });
+}
+
 // src/tools/release.ts
 init_git();
 
@@ -19444,9 +19518,16 @@ async function handleRelease(adapter2, config2, args) {
   }
   const tracker = new ProgressTracker("validate-args").bindStream(adapter2, { stage: "release" });
   try {
-    await tracker.recordStep("release_starting");
     tracker.mark("owner-identity-guard");
     const gate = await resolveOwnerGate(adapter2, config2);
+    let cycleToClose = null;
+    try {
+      const resolved = await resolveCycleToClose(adapter2, version, gate.callerUserId);
+      cycleToClose = resolved > 0 ? resolved : null;
+    } catch {
+      cycleToClose = null;
+    }
+    await beginRelease(tracker, cycleToClose);
     const productionBaseBranch = resolveBaseBranch(config2.projectRoot, config2.baseBranch);
     if (branch === productionBaseBranch) {
       if (gate.enforced && !gate.callerIsOwner) {
@@ -19511,6 +19592,13 @@ Next: run \`plan\` to start your next cycle.`
         }
       }
     }
+    let caps = {};
+    try {
+      const info = adapter2.getProjectInfo ? await adapter2.getProjectInfo() : null;
+      caps = info?.capabilities ?? {};
+    } catch {
+      caps = {};
+    }
     if (isHostedTransport()) {
       tracker.mark("hosted-close-cycle");
       let closed;
@@ -19523,6 +19611,16 @@ Next: run \`plan\` to start your next cycle.`
         const message = err instanceof Error ? err.message : String(err);
         return errorResponse(message);
       }
+      await recordReadinessVerified(tracker);
+      const hostedGate = evaluateReleaseGate(caps, config2.gateCommand, gateResult);
+      await recordQualityGate(tracker, hostedGate, caps);
+      await completeRelease(tracker, {
+        cycleClosed: closed.resolvedCycleNum > 0 ? closed.resolvedCycleNum : null,
+        version,
+        caps,
+        branchMerges: [],
+        changelogEmitted: false
+      });
       const tagAnnotation = `Release ${version}`;
       const cyclePart = closed.resolvedCycleNum > 0 ? `Cycle ${closed.resolvedCycleNum}` : "The cycle";
       const warningsBlock = closed.warnings.length > 0 ? `
@@ -19583,22 +19681,10 @@ Run \`project_switch <slug>\` to switch the active PAPI project, or verify your
         console.error(`[release] gh CLI not available \u2014 ${pendingGrouped.length} shared branch(es) will be squash-merged via git: ${pendingGrouped.join(", ")}`);
       }
     }
-    await tracker.recordStep("readiness_verified");
-    let caps = {};
-    try {
-      const info = adapter2.getProjectInfo ? await adapter2.getProjectInfo() : null;
-      caps = info?.capabilities ?? {};
-    } catch {
-      caps = {};
-    }
+    await recordReadinessVerified(tracker);
     tracker.mark("quality-gate");
     const gateDecision = evaluateReleaseGate(caps, config2.gateCommand, gateResult);
-    await tracker.recordStep("quality_gate", {
-      status: gateDecision.stepStatus,
-      capabilityKey: "releaseGate",
-      capabilityEnabled: isCapabilityEnabled(caps, "releaseGate"),
-      metadata: gateDecision.metadata
-    });
+    await recordQualityGate(tracker, gateDecision, caps);
     if (gateDecision.action === "directive") {
       return textResponse(gateDecision.message);
     }
@@ -19611,13 +19697,6 @@ Run \`project_switch <slug>\` to switch the active PAPI project, or verify your
       skipVersion: skipVersion ?? false,
       callerUserId: gate.callerUserId
     });
-    tracker.setStreamScope({ cycle: result.cycleClosed ?? null });
-    await tracker.recordStep("cycle_complete", { metadata: { version: result.version } });
-    for (const m of result.groupedBranchMerges ?? []) {
-      await tracker.recordStep("branch_merged", {
-        metadata: { branch: m.branch, prUrl: m.prUrl ?? null }
-      });
-    }
     const lines = [
       `## Release ${result.version}${skipVersion ? " (skip version)" : ""}`,
       "",
@@ -19672,21 +19751,16 @@ Run \`project_switch <slug>\` to switch the active PAPI project, or verify your
       buildCycleUpdateCurationDirective(result.version, result.cycleClosed ?? 0)
     );
     if (cycleUpdateDirective) lines.push(cycleUpdateDirective);
-    await tracker.recordStep("changelog", {
-      capabilityKey: "changelog",
-      capabilityEnabled: isCapabilityEnabled(caps, "changelog"),
-      status: cycleUpdateDirective ? "complete" : "active"
-    });
     const deployDirective = buildDeployHookDirective(caps, config2.deployCommand);
-    if (deployDirective) {
-      lines.push(deployDirective);
-      await tracker.recordStep("deploy_hook", {
-        capabilityKey: "deployHook",
-        capabilityEnabled: isCapabilityEnabled(caps, "deployHook"),
-        status: "complete",
-        metadata: { configured: true }
-      });
-    }
+    if (deployDirective) lines.push(deployDirective);
+    await completeRelease(tracker, {
+      cycleClosed: result.cycleClosed ?? null,
+      version: result.version,
+      caps,
+      branchMerges: result.groupedBranchMerges ?? [],
+      changelogEmitted: Boolean(cycleUpdateDirective),
+      deployHookEmitted: Boolean(deployDirective)
+    });
     const publishEnabled = isCapabilityEnabled(caps, "publishDirective");
     if (publishEnabled) {
       try {
@@ -19714,7 +19788,6 @@ Run \`project_switch <slug>\` to switch the active PAPI project, or verify your
     const verifyDirective = buildVerifyHealthCheckDirective(caps);
     if (verifyDirective) lines.push(verifyDirective);
     lines.push("", `Next: cycle released! Run \`plan\` to start your next cycle, or \`idea "<what's next>"\` first if your backlog is thin.`);
-    await tracker.recordStep("released", { metadata: { version: result.version } });
     const filesToWriteSection = result.filesToWrite ? formatFilesToWriteSection(result.filesToWrite) : "";
     return textResponse(lines.join("\n") + filesToWriteSection);
   } catch (err) {
@@ -19874,32 +19947,94 @@ function capitalizeCompleted(value) {
   };
   return map[value] ?? "No";
 }
+function stripAnnotations(text) {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === ")") {
+      i++;
+      continue;
+    }
+    if (ch === "(") {
+      let depth = 0;
+      let j = i;
+      for (; j < text.length; j++) {
+        if (text[j] === "(") depth++;
+        else if (text[j] === ")") {
+          depth--;
+          if (depth === 0) {
+            j++;
+            break;
+          }
+        }
+      }
+      if (depth !== 0) {
+        break;
+      }
+      const inner = text.slice(i + 1, j - 1);
+      const prev = i > 0 ? text[i - 1] : "/";
+      const next = text[j] ?? "";
+      const isRouteGroup = (prev === "/" || i === 0) && !/\s/.test(inner) && next === "/";
+      if (isRouteGroup) {
+        out += text.slice(i, j);
+        i = j;
+        continue;
+      }
+      i = j;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
 function sanitisePredictedFiles(raw) {
   const out = [];
   for (const entry of raw) {
     if (typeof entry !== "string") continue;
-    for (const segment of entry.split(";")) {
-      const altMatches = segment.match(/\(\s*or\s+`([^`]+)`\s*\)/gi) ?? [];
-      for (const alt of altMatches) {
-        const inner = alt.match(/`([^`]+)`/);
-        if (inner) out.push(inner[1].trim());
-      }
-      const cleaned = segment.replace(/`/g, "").replace(/\s*\(.*$/, "").trim();
-      if (cleaned) out.push(cleaned);
+    let working = entry;
+    const altMatches = working.match(/\(\s*or\s+`([^`]+)`\s*\)/gi) ?? [];
+    for (const alt of altMatches) {
+      const inner = alt.match(/`([^`]+)`/);
+      if (inner) out.push(inner[1].trim());
+      working = working.replace(alt, " ");
+    }
+    const cleanedEntry = stripAnnotations(working.replace(/`/g, ""));
+    for (const segment of cleanedEntry.split(/[;,]/)) {
+      const cleaned = segment.trim();
+      if (!cleaned) continue;
+      if (/\s/.test(cleaned)) continue;
+      if (!/[A-Za-z0-9]/.test(cleaned)) continue;
+      out.push(cleaned);
     }
   }
   return Array.from(new Set(out));
 }
+function globToRegExp(entry) {
+  const source = entry.split(/(\*\*|\*)/).map((part) => {
+    if (part === "**") return ".*";
+    if (part === "*") return "[^/]*";
+    return part.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  }).join("");
+  return new RegExp(`^${source}$`, "i");
+}
 function pathBasename(p) {
   const parts = p.replace(/\\/g, "/").replace(/\/+$/, "").split("/");
   return parts[parts.length - 1] ?? p;
 }
 function isPathInPredictedScope(changedPath, predicted) {
-  const changedLower = changedPath.replace(/\\/g, "/").toLowerCase();
+  const changed = changedPath.replace(/\\/g, "/");
+  const changedLower = changed.toLowerCase();
   const changedBase = pathBasename(changedPath);
   for (const raw of predicted) {
     const entry = raw.replace(/\\/g, "/").replace(/\/+$/, "").trim();
     if (!entry) continue;
+    if (entry.includes("*")) {
+      if (globToRegExp(entry).test(changed)) return true;
+      if (!entry.includes("/") && globToRegExp(entry).test(changedBase)) return true;
+      continue;
+    }
     if (pathBasename(entry) === changedBase) return true;
     const entryLower = entry.toLowerCase();
     if (changedLower === entryLower || changedLower.startsWith(`${entryLower}/`)) {
@@ -19943,23 +20078,27 @@ function autoCommit(config2, taskId, taskTitle, predictedFiles) {
     };
     const cleanedPredicted = sanitisePredictedFiles(predictedFiles);
     const scoped = modified.filter((p) => isPathInPredictedScope(p, cleanedPredicted));
-    if (scoped.length === 0) {
+    const untracked = getUntrackedFiles(cwd);
+    const scopedSet = new Set(scoped);
+    const untrackedInScope = untracked.filter(
+      (p) => !scopedSet.has(p) && isPathInPredictedScope(p, cleanedPredicted)
+    );
+    if (scoped.length === 0 && untrackedInScope.length === 0) {
       const modSample = modified.slice(0, 5).join(", ");
       const predSample = cleanedPredicted.slice(0, 5).join(", ");
       return `Auto-commit: refused \u2014 none of the ${modified.length} modified file(s) intersect FILES LIKELY TOUCHED. Modified: ${modSample}. Expected: ${predSample}. Stage the intended files manually (\`git add <paths>\`) then re-run, or set PAPI_AUTO_COMMIT=false.`;
     }
-    const untracked = getUntrackedFiles(cwd);
     const scopedDirs = [...new Set(scoped.map(dirname7).filter((d) => d.length > 0))];
     const isUnderScopedDir = (p) => scopedDirs.some((d) => p === d || p.startsWith(`${d}/`) || p.startsWith(`${d}\\`));
-    const scopedSet = new Set(scoped);
+    const inScopeSet = /* @__PURE__ */ new Set([...scoped, ...untrackedInScope]);
     const adjacentUntracked = untracked.filter(
-      (p) => !scopedSet.has(p) && isUnderScopedDir(p)
+      (p) => !inScopeSet.has(p) && isUnderScopedDir(p)
     );
-    const toStage = [...scoped, ...adjacentUntracked];
+    const toStage = [...scoped, ...untrackedInScope, ...adjacentUntracked];
     const toStageSet = new Set(toStage);
     const droppedUntracked = untracked.filter((p) => !toStageSet.has(p));
     const droppedModified = modified.filter((p) => !scopedSet.has(p));
-    let line = safeRun(() => stagePathsAndCommit(cwd, toStage, message)) + ` (scoped to ${scoped.length}/${modified.length} files via FILES LIKELY TOUCHED` + (adjacentUntracked.length > 0 ? ` + ${adjacentUntracked.length} untracked under scoped dir(s)` : "") + `).`;
+    let line = safeRun(() => stagePathsAndCommit(cwd, toStage, message)) + ` (scoped to ${scoped.length}/${modified.length} files via FILES LIKELY TOUCHED` + (untrackedInScope.length > 0 ? ` + ${untrackedInScope.length} new file(s) named in the handoff` : "") + (adjacentUntracked.length > 0 ? ` + ${adjacentUntracked.length} untracked under scoped dir(s)` : "") + `).`;
     if (droppedModified.length > 0) {
       const sample = droppedModified.slice(0, 10).join(", ");
       const more = droppedModified.length > 10 ? ` (+${droppedModified.length - 10} more)` : "";
@@ -24035,11 +24174,38 @@ Merge or squash those PRs first, then run \`release\` manually.`;
             } catch {
             }
             const version = `v0.${result.currentCycle}.0`;
-            const releaseResult = await createRelease(config2, baseBranch, version, adapter2, result.currentCycle);
-            await tracker.recordStep("auto_release_triggered", { metadata: { version: releaseResult.version } });
-            const pushInfo = releaseResult.pushNotes.join(" ");
-            const groupedMergeNote = releaseResult.groupedBranchMerges?.length ? "\n" + releaseResult.groupedBranchMerges.map((r) => `- Merged shared branch \`${r.branch}\` via PR: ${r.prUrl ?? "n/a"}`).join("\n") : "";
-            autoReleaseNote = `
+            const autoGate = evaluateReleaseGate(caps, config2.gateCommand, void 0);
+            if (autoGate.action !== "proceed") {
+              autoReleaseNote = `
+
+---
+
+\u26A0\uFE0F **Auto-release skipped** \u2014 a release quality gate is configured (\`${config2.gateCommand}\`), and it cannot be run from inside \`review_submit\`.
+
+Run \`release\` manually: PAPI will hand you the gate command, then release once you report it green.`;
+            } else {
+              const releaseTracker = new ProgressTracker("auto-release").bindStream(adapter2, { stage: "release" });
+              await beginRelease(releaseTracker, result.currentCycle);
+              const releaseResult = await createRelease(config2, baseBranch, version, adapter2, result.currentCycle);
+              await recordReadinessVerified(releaseTracker);
+              await recordQualityGate(releaseTracker, autoGate, caps);
+              await tracker.recordStep("auto_release_triggered", { metadata: { version: releaseResult.version } });
+              const autoChangelogDirective = buildChangelogDirective(
+                caps,
+                buildCycleUpdateCurationDirective(releaseResult.version, releaseResult.cycleClosed ?? 0)
+              );
+              const autoDeployDirective = buildDeployHookDirective(caps, config2.deployCommand);
+              await completeRelease(releaseTracker, {
+                cycleClosed: releaseResult.cycleClosed ?? null,
+                version: releaseResult.version,
+                caps,
+                branchMerges: releaseResult.groupedBranchMerges ?? [],
+                changelogEmitted: Boolean(autoChangelogDirective),
+                deployHookEmitted: Boolean(autoDeployDirective)
+              });
+              const pushInfo = releaseResult.pushNotes.join(" ");
+              const groupedMergeNote = releaseResult.groupedBranchMerges?.length ? "\n" + releaseResult.groupedBranchMerges.map((r) => `- Merged shared branch \`${r.branch}\` via PR: ${r.prUrl ?? "n/a"}`).join("\n") : "";
+              autoReleaseNote = `
 
 ---
 
@@ -24049,9 +24215,15 @@ Merge or squash those PRs first, then run \`release\` manually.`;
 - ${releaseResult.commitNote}
 - ${releaseResult.tagMessage}
 - ${pushInfo}` + groupedMergeNote + (releaseResult.warnings?.length ? `
-- Warnings: ${releaseResult.warnings.join(", ")}` : "") + `
+- Warnings: ${releaseResult.warnings.join(", ")}` : "") + // task-2598 (C328): the auto path previously swallowed the curated
+              // cycle-update directive that the manual path emits, so an auto-released
+              // cycle never prompted the Discord post. Same directive, same gate.
+              (autoChangelogDirective ? `
+${autoChangelogDirective}` : "") + (autoDeployDirective ? `
+${autoDeployDirective}` : "") + `
 
 Run \`plan\` to create Cycle ${result.currentCycle + 1}.`;
+            }
           }
         }
       } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@papi-ai/server",
-  "version": "0.7.52",
+  "version": "0.7.53",
   "description": "PAPI MCP server — AI-powered sprint planning, build execution, and strategy review for software projects",
   "license": "Elastic-2.0",
   "mcpName": "io.github.getpapi/papi",