specweave 1.0.520 → 1.0.521

package/plugins/specweave/lib/integrations/github/github-ac-comment-poster.ts

@@ -12,6 +12,7 @@ import { readFile } from 'fs/promises';
 import { existsSync } from 'fs';
 import * as path from 'path';
 import { execFileNoThrow } from '../../../../../src/utils/execFileNoThrow.js';
+import { buildFingerprint, extractFingerprint } from './github-body-utils.js';
 
 export interface CommentPostOptions {
   owner: string;
@@ -87,21 +88,50 @@ export async function postACProgressComments(
     const allComplete = acStates.length > 0 && acStates.every(ac => ac.completed);
 
     if (!allComplete) {
-      const commentBody = buildProgressCommentForUS(incrementId, usId, acStates);
+      const total = acStates.length;
+      const completed = acStates.filter(ac => ac.completed).length;
+      const currentFingerprint = buildFingerprint(completed, total);
 
-      const execResult = await execFileNoThrow(
-        'gh',
-        ['issue', 'comment', String(link.issueNumber), '--body', commentBody, '-R', repoSlug],
-        env ? { env } : {},
-      );
+      // Dedup: fetch last comment and check fingerprint before posting
+      let shouldPost = true;
+      try {
+        const commentsResult = await execFileNoThrow(
+          'gh',
+          [
+            'api',
+            `repos/${repoSlug}/issues/${link.issueNumber}/comments`,
+            '--jq', '.[-1].body',
+          ],
+          env ? { env } : {},
+        );
+        if (commentsResult.success && commentsResult.stdout.trim()) {
+          const lastFingerprint = extractFingerprint(commentsResult.stdout);
+          if (lastFingerprint === `${completed}/${total}`) {
+            shouldPost = false;
+          }
+        }
+      } catch {
+        // If comment fetch fails, proceed with posting
+      }
 
-      if (execResult.success) {
-        result.posted.push({ usId, issueNumber: link.issueNumber });
-      } else {
-        result.errors.push({
-          usId,
-          error: execResult.stderr || 'Unknown error posting comment',
-        });
+      if (shouldPost) {
+        const commentBody = buildProgressCommentForUS(incrementId, usId, acStates)
+          + currentFingerprint + '\n';
+
+        const execResult = await execFileNoThrow(
+          'gh',
+          ['issue', 'comment', String(link.issueNumber), '--body', commentBody, '-R', repoSlug],
+          env ? { env } : {},
+        );
+
+        if (execResult.success) {
+          result.posted.push({ usId, issueNumber: link.issueNumber });
+        } else {
+          result.errors.push({
+            usId,
+            error: execResult.stderr || 'Unknown error posting comment',
+          });
+        }
       }
     }
 

package/plugins/specweave/lib/integrations/github/github-body-utils.js

@@ -0,0 +1,15 @@
+function buildFingerprint(completed, total) {
+  return `<!-- sw-progress:${completed}/${total} -->`;
+}
+function extractFingerprint(text) {
+  const match = text.match(/<!-- sw-progress:(\d+\/\d+) -->/);
+  return match ? match[1] : null;
+}
+function normalizeIssueBody(body) {
+  return body.split("\n").map((line) => line.trimEnd()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+export {
+  buildFingerprint,
+  extractFingerprint,
+  normalizeIssueBody
+};

package/plugins/specweave/lib/integrations/github/github-body-utils.ts

@@ -0,0 +1,52 @@
+/**
+ * Shared utilities for GitHub issue body fingerprinting, extraction,
+ * and normalization. Used by the AC comment poster and feature sync
+ * to deduplicate progress comments and skip no-op edits.
+ *
+ * Fingerprint format: `<!-- sw-progress:N/M -->` (HTML comment,
+ * invisible in rendered Markdown, consistent with JIRA fingerprint
+ * pattern in jira-status-sync.ts).
+ *
+ * @module github-body-utils
+ */
+
+/**
+ * Build an HTML comment fingerprint for the current AC progress state.
+ *
+ * @param completed - Number of completed acceptance criteria
+ * @param total - Total number of acceptance criteria
+ * @returns HTML comment string, e.g. `<!-- sw-progress:3/5 -->`
+ */
+export function buildFingerprint(completed: number, total: number): string {
+  return `<!-- sw-progress:${completed}/${total} -->`;
+}
+
+/**
+ * Extract the progress fingerprint value from a block of text.
+ * Returns the `N/M` portion if found, or `null` if no fingerprint is present.
+ *
+ * @param text - Text to search (e.g. a GitHub comment body)
+ * @returns The fingerprint value like `"3/5"`, or `null`
+ */
+export function extractFingerprint(text: string): string | null {
+  const match = text.match(/<!-- sw-progress:(\d+\/\d+) -->/);
+  return match ? match[1] : null;
+}
+
+/**
+ * Normalize a GitHub issue body for comparison purposes.
+ * - Strips trailing whitespace from each line
+ * - Collapses multiple consecutive blank lines into a single blank line
+ * - Trims leading/trailing whitespace from the entire body
+ *
+ * @param body - Raw issue body text
+ * @returns Normalized body string
+ */
+export function normalizeIssueBody(body: string): string {
+  return body
+    .split('\n')
+    .map(line => line.trimEnd())
+    .join('\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}

package/plugins/specweave/lib/integrations/github/github-feature-sync.js

@@ -7,8 +7,9 @@ import { CompletionCalculator } from "./completion-calculator.js";
 import { DuplicateDetector } from "./duplicate-detector.js";
 import { execFileNoThrow } from "../../vendor/utils/execFileNoThrow.js";
 import { getGitHubAuthFromProject } from "../../vendor/utils/auth-helpers.js";
-const _GitHubFeatureSync = class _GitHubFeatureSync {
-  // 30 seconds
+import { LockManager } from "../../../../../src/utils/lock-manager.js";
+import { normalizeIssueBody } from "./github-body-utils.js";
+class GitHubFeatureSync {
   constructor(client, specsDir, projectRoot) {
     // Cached default branch for the sync session (one API call per session)
     this.defaultBranch = null;
@@ -69,14 +70,14 @@ const _GitHubFeatureSync = class _GitHubFeatureSync {
    * 4. Update frontmatter with GitHub issue links
    */
   async syncFeatureToGitHub(featureId, projectName) {
-    const lockKey = `${this.client.getOwner()}/${this.client.getRepo()}:${featureId}`;
-    const now = Date.now();
-    const lastSync = _GitHubFeatureSync.syncLocks.get(lockKey);
-    if (lastSync && now - lastSync < _GitHubFeatureSync.LOCK_DURATION_MS) {
-      const secondsRemaining = Math.ceil((_GitHubFeatureSync.LOCK_DURATION_MS - (now - lastSync)) / 1e3);
+    const owner = this.client.getOwner();
+    const repo = this.client.getRepo();
+    const lockDir = path.join(this.projectRoot, ".specweave", "state", "locks", `github-sync-${owner}-${repo}`);
+    const lock = new LockManager(lockDir, 120);
+    const acquired = await lock.acquire();
+    if (!acquired) {
       console.log(`
-\u23ED\uFE0F  Sync already in progress for ${featureId} (or completed ${Math.floor((now - lastSync) / 1e3)}s ago)`);
-      console.log(`   \u2139\uFE0F  Sync will be available in ${secondsRemaining}s to prevent duplicates`);
+\u23ED\uFE0F  Sync already in progress for ${featureId} (lock held by another process)`);
       console.log(`   \u{1F4A1} This prevents race conditions between task completion and status change syncs`);
       return {
         milestoneNumber: 0,
@@ -86,123 +87,126 @@ const _GitHubFeatureSync = class _GitHubFeatureSync {
         userStoriesProcessed: 0
       };
     }
-    _GitHubFeatureSync.syncLocks.set(lockKey, now);
-    console.log(`
+    try {
+      console.log(`
 \u{1F504} Syncing Feature ${featureId} to GitHub...`);
-    const featureFolder = await this.findFeatureFolder(featureId, projectName);
-    if (!featureFolder) {
-      console.log(`   \u26A0\uFE0F  Feature ${featureId} not found in ${this.specsDir} (no living docs and auto-create failed)`);
-      console.log(`   \u{1F4A1} Run /sw:sync-docs or /sw:living-docs to generate living docs first`);
-      return {
-        milestoneNumber: 0,
-        milestoneUrl: "",
-        issuesCreated: 0,
-        issuesUpdated: 0,
-        userStoriesProcessed: 0
-      };
-    }
-    const featurePath = path.join(featureFolder, "FEATURE.md");
-    const featureData = await this.parseFeatureMd(featurePath);
-    console.log(`   \u{1F4E6} Feature: ${featureData.title}`);
-    console.log(`   \u{1F4CA} Status: ${featureData.status}`);
-    let milestoneNumber = featureData.external_tools?.github?.id;
-    let milestoneUrl = featureData.external_tools?.github?.url;
-    if (!milestoneNumber) {
-      console.log(`   \u{1F680} Creating GitHub Milestone...`);
-      const milestone = await this.createMilestone(featureData);
-      milestoneNumber = milestone.number;
-      milestoneUrl = milestone.url;
-      console.log(`   \u2705 Created Milestone #${milestoneNumber}`);
-      await this.updateFeatureMd(featurePath, {
-        type: "milestone",
-        id: milestoneNumber,
-        url: milestoneUrl
-      });
-    } else {
-      console.log(`   \u267B\uFE0F  Using existing Milestone #${milestoneNumber}`);
-      milestoneUrl = featureData.external_tools?.github?.url || milestoneUrl;
-    }
-    const userStories = await this.findUserStories(featureId, projectName);
-    console.log(`
-   \u{1F4DD} Found ${userStories.length} User Stories to sync...`);
-    let issuesCreated = 0;
-    let issuesUpdated = 0;
-    const detectedBranch = await this.detectDefaultBranch();
-    console.log(`   \u{1F33F} Default branch: ${detectedBranch}`);
-    for (const userStory of userStories) {
+      const featureFolder = await this.findFeatureFolder(featureId, projectName);
+      if (!featureFolder) {
+        console.log(`   \u26A0\uFE0F  Feature ${featureId} not found in ${this.specsDir} (no living docs and auto-create failed)`);
+        console.log(`   \u{1F4A1} Run /sw:sync-docs or /sw:living-docs to generate living docs first`);
+        return {
+          milestoneNumber: 0,
+          milestoneUrl: "",
+          issuesCreated: 0,
+          issuesUpdated: 0,
+          userStoriesProcessed: 0
+        };
+      }
+      const featurePath = path.join(featureFolder, "FEATURE.md");
+      const featureData = await this.parseFeatureMd(featurePath);
+      console.log(`   \u{1F4E6} Feature: ${featureData.title}`);
+      console.log(`   \u{1F4CA} Status: ${featureData.status}`);
+      let milestoneNumber = featureData.external_tools?.github?.id;
+      let milestoneUrl = featureData.external_tools?.github?.url;
+      if (!milestoneNumber) {
+        console.log(`   \u{1F680} Creating GitHub Milestone...`);
+        const milestone = await this.createMilestone(featureData);
+        milestoneNumber = milestone.number;
+        milestoneUrl = milestone.url;
+        console.log(`   \u2705 Created Milestone #${milestoneNumber}`);
+        await this.updateFeatureMd(featurePath, {
+          type: "milestone",
+          id: milestoneNumber,
+          url: milestoneUrl
+        });
+      } else {
+        console.log(`   \u267B\uFE0F  Using existing Milestone #${milestoneNumber}`);
+        milestoneUrl = featureData.external_tools?.github?.url || milestoneUrl;
+      }
+      const userStories = await this.findUserStories(featureId, projectName);
       console.log(`
+   \u{1F4DD} Found ${userStories.length} User Stories to sync...`);
+      let issuesCreated = 0;
+      let issuesUpdated = 0;
+      const detectedBranch = await this.detectDefaultBranch();
+      console.log(`   \u{1F33F} Default branch: ${detectedBranch}`);
+      for (const userStory of userStories) {
+        console.log(`
    \u{1F539} Processing ${userStory.id}: ${userStory.title}`);
-      const repoInfo = {
-        owner: this.client.getOwner(),
-        repo: this.client.getRepo(),
-        branch: detectedBranch
-      };
-      const builder = new UserStoryIssueBuilder(
-        userStory.filePath,
-        this.projectRoot,
-        featureId,
-        repoInfo
-      );
-      const issueContent = await builder.buildIssueBody();
-      issueContent.status = userStory.status;
-      let issueNumber;
-      let wasUpdated = false;
-      if (userStory.existingIssue) {
-        console.log(`      \u267B\uFE0F  Issue #${userStory.existingIssue} exists in frontmatter`);
-        try {
-          await this.client.getIssue(userStory.existingIssue);
-          await this.updateUserStoryIssue(userStory.existingIssue, issueContent, userStory.filePath);
+        const repoInfo = {
+          owner: this.client.getOwner(),
+          repo: this.client.getRepo(),
+          branch: detectedBranch
+        };
+        const builder = new UserStoryIssueBuilder(
+          userStory.filePath,
+          this.projectRoot,
+          featureId,
+          repoInfo
+        );
+        const issueContent = await builder.buildIssueBody();
+        issueContent.status = userStory.status;
+        let issueNumber;
+        let wasUpdated = false;
+        if (userStory.existingIssue) {
+          console.log(`      \u267B\uFE0F  Issue #${userStory.existingIssue} exists in frontmatter`);
+          try {
+            await this.client.getIssue(userStory.existingIssue);
+            await this.updateUserStoryIssue(userStory.existingIssue, issueContent, userStory.filePath);
+            issuesUpdated++;
+            console.log(`      \u2705 Updated Issue #${userStory.existingIssue}`);
+            continue;
+          } catch (err) {
+            console.log(`      \u26A0\uFE0F  Issue #${userStory.existingIssue} deleted on GitHub, creating new`);
+          }
+        }
+        const titlePattern = `[${featureId}][${userStory.id}]`;
+        const milestoneTitle = `${featureData.id}: ${featureData.title}`;
+        console.log(`      \u{1F6E1}\uFE0F  Using DuplicateDetector (pattern: ${titlePattern})`);
+        const result = await DuplicateDetector.createWithProtection({
+          title: issueContent.title,
+          body: issueContent.body,
+          titlePattern,
+          incrementId: userStory.id,
+          labels: issueContent.labels,
+          milestone: milestoneTitle,
+          repo: `${this.client.getOwner()}/${this.client.getRepo()}`
+        });
+        issueNumber = result.issue.number;
+        if (result.wasReused) {
+          console.log(`      \u267B\uFE0F  Reused existing issue #${issueNumber} (duplicate prevented!)`);
+          wasUpdated = true;
+        } else {
+          console.log(`      \u2705 Created issue #${issueNumber}`);
+        }
+        if (result.duplicatesFound > 0) {
+          console.log(`      \u{1F6E1}\uFE0F  Duplicates detected: ${result.duplicatesFound}, auto-closed: ${result.duplicatesClosed}`);
+        }
+        await this.updateUserStoryFrontmatter(userStory.filePath, issueNumber);
+        await this.backfillIncrementMetadata(featureId, userStory.id, issueNumber, milestoneNumber);
+        await this.updateUserStoryIssue(issueNumber, issueContent, userStory.filePath);
+        if (result.wasReused) {
           issuesUpdated++;
-          console.log(`      \u2705 Updated Issue #${userStory.existingIssue}`);
-          continue;
-        } catch (err) {
-          console.log(`      \u26A0\uFE0F  Issue #${userStory.existingIssue} deleted on GitHub, creating new`);
+        } else {
+          issuesCreated++;
         }
       }
-      const titlePattern = `[${featureId}][${userStory.id}]`;
-      const milestoneTitle = `${featureData.id}: ${featureData.title}`;
-      console.log(`      \u{1F6E1}\uFE0F  Using DuplicateDetector (pattern: ${titlePattern})`);
-      const result = await DuplicateDetector.createWithProtection({
-        title: issueContent.title,
-        body: issueContent.body,
-        titlePattern,
-        incrementId: userStory.id,
-        labels: issueContent.labels,
-        milestone: milestoneTitle,
-        repo: `${this.client.getOwner()}/${this.client.getRepo()}`
-      });
-      issueNumber = result.issue.number;
-      if (result.wasReused) {
-        console.log(`      \u267B\uFE0F  Reused existing issue #${issueNumber} (duplicate prevented!)`);
-        wasUpdated = true;
-      } else {
-        console.log(`      \u2705 Created issue #${issueNumber}`);
-      }
-      if (result.duplicatesFound > 0) {
-        console.log(`      \u{1F6E1}\uFE0F  Duplicates detected: ${result.duplicatesFound}, auto-closed: ${result.duplicatesClosed}`);
-      }
-      await this.updateUserStoryFrontmatter(userStory.filePath, issueNumber);
-      await this.backfillIncrementMetadata(featureId, userStory.id, issueNumber, milestoneNumber);
-      await this.updateUserStoryIssue(issueNumber, issueContent, userStory.filePath);
-      if (result.wasReused) {
-        issuesUpdated++;
-      } else {
-        issuesCreated++;
-      }
-    }
-    console.log(`
+      console.log(`
 \u2705 Feature sync complete!`);
-    console.log(`   Milestone: ${milestoneUrl}`);
-    console.log(`   User Stories: ${userStories.length}`);
-    console.log(`   Issues created: ${issuesCreated}`);
-    console.log(`   Issues updated: ${issuesUpdated}`);
-    return {
-      milestoneNumber,
-      milestoneUrl,
-      issuesCreated,
-      issuesUpdated,
-      userStoriesProcessed: userStories.length
-    };
+      console.log(`   Milestone: ${milestoneUrl}`);
+      console.log(`   User Stories: ${userStories.length}`);
+      console.log(`   Issues created: ${issuesCreated}`);
+      console.log(`   Issues updated: ${issuesUpdated}`);
+      return {
+        milestoneNumber,
+        milestoneUrl,
+        issuesCreated,
+        issuesUpdated,
+        userStoriesProcessed: userStories.length
+      };
+    } finally {
+      await lock.release();
+    }
   }
   /**
    * Find Feature folder in specs directory.
@@ -710,17 +714,42 @@ Created: ${featureData.created}`;
    */
   async updateUserStoryIssue(issueNumber, issueContent, userStoryPath) {
     const repoSlug = this.getRepoSlug();
-    await execFileNoThrow("gh", [
-      "issue",
-      "edit",
-      issueNumber.toString(),
-      "--title",
-      issueContent.title,
-      "--body",
-      issueContent.body,
-      "-R",
-      repoSlug
-    ], { env: this.getGhEnv() });
+    let shouldEdit = true;
+    try {
+      const viewResult = await execFileNoThrow("gh", [
+        "issue",
+        "view",
+        issueNumber.toString(),
+        "--json",
+        "body",
+        "--jq",
+        ".body",
+        "-R",
+        repoSlug
+      ], { env: this.getGhEnv() });
+      if (viewResult.exitCode === 0 && viewResult.stdout) {
+        const currentNormalized = normalizeIssueBody(viewResult.stdout);
+        const newNormalized = normalizeIssueBody(issueContent.body);
+        if (currentNormalized === newNormalized) {
+          shouldEdit = false;
+          console.log(`      \u23ED\uFE0F  Body unchanged, skipping gh issue edit for #${issueNumber}`);
+        }
+      }
+    } catch {
+    }
+    if (shouldEdit) {
+      await execFileNoThrow("gh", [
+        "issue",
+        "edit",
+        issueNumber.toString(),
+        "--title",
+        issueContent.title,
+        "--body",
+        issueContent.body,
+        "-R",
+        repoSlug
+      ], { env: this.getGhEnv() });
+    }
     const completion = await this.calculator.calculateCompletion(userStoryPath);
     const issueData = await this.client.getIssue(issueNumber);
     const currentlyClosed = issueData.state === "closed";
@@ -996,12 +1025,7 @@ ${newFrontmatter}---${bodyContent}`;
 ${newFrontmatter}---${bodyContent}`;
     await writeFile(userStoryPath, newContent, "utf-8");
   }
-};
-// SYNC LOCK: Prevent concurrent syncs of the same feature
-// Maps featureId → last sync timestamp
-_GitHubFeatureSync.syncLocks = /* @__PURE__ */ new Map();
-_GitHubFeatureSync.LOCK_DURATION_MS = 3e4;
-let GitHubFeatureSync = _GitHubFeatureSync;
+}
 export {
   GitHubFeatureSync
 };

package/plugins/specweave/lib/integrations/github/github-feature-sync.ts

@@ -20,6 +20,8 @@ import { CompletionCalculator } from './completion-calculator.js';
 import { DuplicateDetector } from './duplicate-detector.js';
 import { execFileNoThrow } from '../../vendor/utils/execFileNoThrow.js';
 import { getGitHubAuthFromProject } from '../../vendor/utils/auth-helpers.js';
+import { LockManager } from '../../../../../src/utils/lock-manager.js';
+import { normalizeIssueBody } from './github-body-utils.js';
 
 interface FeatureFrontmatter {
   id: string;
@@ -57,11 +59,6 @@ export class GitHubFeatureSync {
   // Cached default branch for the sync session (one API call per session)
   private defaultBranch: string | null = null;
 
-  // SYNC LOCK: Prevent concurrent syncs of the same feature
-  // Maps featureId → last sync timestamp
-  private static syncLocks: Map<string, number> = new Map();
-  private static readonly LOCK_DURATION_MS = 30000; // 30 seconds
-
   constructor(client: GitHubClientV2, specsDir: string, projectRoot: string) {
     this.client = client;
     this.specsDir = specsDir;
@@ -134,18 +131,17 @@ export class GitHubFeatureSync {
     issuesUpdated: number;
     userStoriesProcessed: number;
   }> {
-    // SYNC LOCK CHECK: Prevent concurrent/rapid syncs of the same feature+repo
+    // SYNC LOCK: Cross-process file lock prevents concurrent syncs of the same feature+repo
     // Root cause: Two sync paths (task completion + status change) can fire simultaneously
     // Result: Duplicate GitHub comments due to race condition
-    // Key includes owner/repo so cross-project syncs (same featureId, different repos) aren't throttled
-    const lockKey = `${this.client.getOwner()}/${this.client.getRepo()}:${featureId}`;
-    const now = Date.now();
-    const lastSync = GitHubFeatureSync.syncLocks.get(lockKey);
-
-    if (lastSync && (now - lastSync) < GitHubFeatureSync.LOCK_DURATION_MS) {
-      const secondsRemaining = Math.ceil((GitHubFeatureSync.LOCK_DURATION_MS - (now - lastSync)) / 1000);
-      console.log(`\n⏭️  Sync already in progress for ${featureId} (or completed ${Math.floor((now - lastSync) / 1000)}s ago)`);
-      console.log(`   ℹ️  Sync will be available in ${secondsRemaining}s to prevent duplicates`);
+    const owner = this.client.getOwner();
+    const repo = this.client.getRepo();
+    const lockDir = path.join(this.projectRoot, '.specweave', 'state', 'locks', `github-sync-${owner}-${repo}`);
+    const lock = new LockManager(lockDir, 120);
+    const acquired = await lock.acquire();
+
+    if (!acquired) {
+      console.log(`\n⏭️  Sync already in progress for ${featureId} (lock held by another process)`);
       console.log(`   💡 This prevents race conditions between task completion and status change syncs`);
 
       // Return placeholder result (sync was skipped, not failed)
@@ -158,8 +154,7 @@ export class GitHubFeatureSync {
       };
     }
 
-    // Acquire lock
-    GitHubFeatureSync.syncLocks.set(lockKey, now);
+    try {
     console.log(`\n🔄 Syncing Feature ${featureId} to GitHub...`);
 
     // 1. Load Feature FEATURE.md
@@ -344,6 +339,9 @@ export class GitHubFeatureSync {
       issuesUpdated,
       userStoriesProcessed: userStories.length,
     };
+    } finally {
+      await lock.release();
+    }
   }
 
   /**
@@ -1016,19 +1014,41 @@ export class GitHubFeatureSync {
     },
     userStoryPath: string
   ): Promise<void> {
-    // Update issue body
+    // Body diff check: skip `gh issue edit` when body is unchanged (FS-587)
     const repoSlug = this.getRepoSlug();
-    await execFileNoThrow('gh', [
-      'issue',
-      'edit',
-      issueNumber.toString(),
-      '--title',
-      issueContent.title,
-      '--body',
-      issueContent.body,
-      '-R',
-      repoSlug,
-    ], { env: this.getGhEnv() });
+    let shouldEdit = true;
+    try {
+      const viewResult = await execFileNoThrow('gh', [
+        'issue', 'view', issueNumber.toString(),
+        '--json', 'body', '--jq', '.body',
+        '-R', repoSlug,
+      ], { env: this.getGhEnv() });
+
+      if (viewResult.exitCode === 0 && viewResult.stdout) {
+        const currentNormalized = normalizeIssueBody(viewResult.stdout);
+        const newNormalized = normalizeIssueBody(issueContent.body);
+        if (currentNormalized === newNormalized) {
+          shouldEdit = false;
+          console.log(`      ⏭️  Body unchanged, skipping gh issue edit for #${issueNumber}`);
+        }
+      }
+    } catch {
+      // 404 or other error fetching current body — proceed with edit
+    }
+
+    if (shouldEdit) {
+      await execFileNoThrow('gh', [
+        'issue',
+        'edit',
+        issueNumber.toString(),
+        '--title',
+        issueContent.title,
+        '--body',
+        issueContent.body,
+        '-R',
+        repoSlug,
+      ], { env: this.getGhEnv() });
+    }
 
     // ✅ VERIFICATION GATE: Calculate ACTUAL completion from checkboxes
     const completion = await this.calculator.calculateCompletion(userStoryPath);