@planu/cli 5.3.14 → 5.3.15

package/dist/engine/planu-core.linux-x64-gnu.node.sbom.json

@@ -4,14 +4,14 @@
   "version": 1,
   "metadata": {
     "component": {
-      "bom-ref": "pkg:cargo/planu-core@5.3.14",
+      "bom-ref": "pkg:cargo/planu-core@5.3.15",
       "type": "library",
       "name": "planu-core",
-      "version": "5.3.14",
+      "version": "5.3.15",
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "ab11f8980f5b174b9c2d5b6806daa3d356a12e841b2eaf668c106a3c45cd816e"
+          "content": "ef2493926703d865ea8673d8357a238058a32a64325050d3880518d8884f25f2"
         }
       ]
     }
@@ -1106,7 +1106,7 @@
       "dependsOn": []
     },
     {
-      "ref": "pkg:cargo/planu-core@5.3.14",
+      "ref": "pkg:cargo/planu-core@5.3.15",
       "dependsOn": [
         "pkg:cargo/core-foundation@0.10.1",
         "pkg:cargo/hmac@0.12.1",

package/dist/engine/planu-core.linux-x64-musl.node.manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
-  "cliVersion": "5.3.14",
-  "engineVersion": "5.3.14",
-  "buildId": "1-5.3.14-x86_64-unknown-linux-musl",
+  "cliVersion": "5.3.15",
+  "engineVersion": "5.3.15",
+  "buildId": "1-5.3.15-x86_64-unknown-linux-musl",
   "protocolAbi": 1,
   "capabilityAbi": 2,
   "nodeApiAbi": 4,
@@ -16,15 +16,15 @@
   "platform": "linux",
   "arch": "x64",
   "libc": "musl",
-  "artifactSha256": "c23996625c6b938358150cf4179453e12e2e0fd13e8eea0e84f5fcc85c55e150",
+  "artifactSha256": "be770ad8fff0c70d1adf1599af7b60a9e0055e133890476e08e04c88c3f28c69",
   "sbom": {
     "format": "CycloneDX-1.5",
     "path": "planu-core.linux-x64-musl.node.sbom.json",
-    "sha256": "6dc9f80ab3206c95cc8a9f3eff39bf21f21e8fbb30e0cf31c4dbcd26e095c675"
+    "sha256": "efd3cf900ecd753f0bee1eba0c6ecc8bd21d4f405e5d346f0fbe58972cf65da4"
   },
   "provenance": {
     "builder": "scripts/build-rust-local.sh",
-    "sourceCommit": "a847a7442e7735a9f4f2a9878eccbd52fc54509b",
+    "sourceCommit": "14948c630bfb7a355391c10563934cc79e8bb167",
     "sourceTreeDirty": false,
     "sourceDateEpoch": 1,
     "rustToolchain": "rustc 1.95.0 (59807616e 2026-04-14)",
@@ -33,6 +33,6 @@
   "signature": {
     "algorithm": "Ed25519",
     "keyId": "e2ee765cb5ad9fbdc433ece332bce26d746d5e350b3acde0721a4c8c6337ff7b",
-    "value": "813Dm95ogKfJ0gWnnob2MqAjFqrZiGqBFsOKm9fbJB1y3MWxQn1ntV1t/eONh0I1r6qA/LJFarprcALWHEMbAA=="
+    "value": "tiDSdVl5hTKNRg88FbcmEwUh4rXFh7OGfMzb9fV3BqwBAwSA/XktD4rXe4YZyBy75Kebo11zW+gp3DMnf+KECA=="
   }
 }

package/dist/engine/planu-core.linux-x64-musl.node.sbom.json

@@ -4,14 +4,14 @@
   "version": 1,
   "metadata": {
     "component": {
-      "bom-ref": "pkg:cargo/planu-core@5.3.14",
+      "bom-ref": "pkg:cargo/planu-core@5.3.15",
       "type": "library",
       "name": "planu-core",
-      "version": "5.3.14",
+      "version": "5.3.15",
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "c23996625c6b938358150cf4179453e12e2e0fd13e8eea0e84f5fcc85c55e150"
+          "content": "be770ad8fff0c70d1adf1599af7b60a9e0055e133890476e08e04c88c3f28c69"
         }
       ]
     }
@@ -1106,7 +1106,7 @@
       "dependsOn": []
     },
     {
-      "ref": "pkg:cargo/planu-core@5.3.14",
+      "ref": "pkg:cargo/planu-core@5.3.15",
       "dependsOn": [
         "pkg:cargo/core-foundation@0.10.1",
         "pkg:cargo/hmac@0.12.1",

package/dist/engine/planu-core.win32-arm64-msvc.node.manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
-  "cliVersion": "5.3.14",
-  "engineVersion": "5.3.14",
-  "buildId": "1-5.3.14-aarch64-pc-windows-msvc",
+  "cliVersion": "5.3.15",
+  "engineVersion": "5.3.15",
+  "buildId": "1-5.3.15-aarch64-pc-windows-msvc",
   "protocolAbi": 1,
   "capabilityAbi": 2,
   "nodeApiAbi": 4,
@@ -16,15 +16,15 @@
   "platform": "win32",
   "arch": "arm64",
   "libc": null,
-  "artifactSha256": "0668394e6f892080771e2f878c2f75d7692f7d2db03c543bdda4fd2fbbf27bd4",
+  "artifactSha256": "583b397fb748d8ce083c4b7d412800789e8b08d6cfcdf51dbb00ca8f16b790c3",
   "sbom": {
     "format": "CycloneDX-1.5",
     "path": "planu-core.win32-arm64-msvc.node.sbom.json",
-    "sha256": "8bd0170c6b52aed934ad9d080190e2d63cf012bd6d6f132449e599e1770c60fa"
+    "sha256": "ed94ce39f49489d682bc80cce95eb3ef04bafd64ed7fd7d8ea6def8b12c9a458"
   },
   "provenance": {
     "builder": "scripts/build-rust-local.sh",
-    "sourceCommit": "a847a7442e7735a9f4f2a9878eccbd52fc54509b",
+    "sourceCommit": "14948c630bfb7a355391c10563934cc79e8bb167",
     "sourceTreeDirty": false,
     "sourceDateEpoch": 1,
     "rustToolchain": "rustc 1.95.0 (59807616e 2026-04-14)",
@@ -33,6 +33,6 @@
   "signature": {
     "algorithm": "Ed25519",
     "keyId": "e2ee765cb5ad9fbdc433ece332bce26d746d5e350b3acde0721a4c8c6337ff7b",
-    "value": "Pse3AY39p2tC7McGWVjvSCG/TOprOtT1W9dvf0XwP/ZWVEd4fVCQUwrTyoXKGAwXCOp4vQjViiE+CvHuSkQ2Dw=="
+    "value": "gaOwCaYMRwh0TEujBu7Rabl255fJETQEAo4i+NFVpamCPo5YWa2sknnxsbm/ZM4iX9YLD1W5S1MeYFUcwVrIAg=="
   }
 }

package/dist/engine/planu-core.win32-arm64-msvc.node.sbom.json

@@ -4,14 +4,14 @@
   "version": 1,
   "metadata": {
     "component": {
-      "bom-ref": "pkg:cargo/planu-core@5.3.14",
+      "bom-ref": "pkg:cargo/planu-core@5.3.15",
       "type": "library",
       "name": "planu-core",
-      "version": "5.3.14",
+      "version": "5.3.15",
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "0668394e6f892080771e2f878c2f75d7692f7d2db03c543bdda4fd2fbbf27bd4"
+          "content": "583b397fb748d8ce083c4b7d412800789e8b08d6cfcdf51dbb00ca8f16b790c3"
         }
       ]
     }
@@ -1106,7 +1106,7 @@
       "dependsOn": []
     },
     {
-      "ref": "pkg:cargo/planu-core@5.3.14",
+      "ref": "pkg:cargo/planu-core@5.3.15",
       "dependsOn": [
         "pkg:cargo/core-foundation@0.10.1",
         "pkg:cargo/hmac@0.12.1",

package/dist/engine/planu-core.win32-x64-msvc.node.manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
-  "cliVersion": "5.3.14",
-  "engineVersion": "5.3.14",
-  "buildId": "1-5.3.14-x86_64-pc-windows-msvc",
+  "cliVersion": "5.3.15",
+  "engineVersion": "5.3.15",
+  "buildId": "1-5.3.15-x86_64-pc-windows-msvc",
   "protocolAbi": 1,
   "capabilityAbi": 2,
   "nodeApiAbi": 4,
@@ -16,15 +16,15 @@
   "platform": "win32",
   "arch": "x64",
   "libc": null,
-  "artifactSha256": "60f4555904763ce92bb3193d78ce261c98334ff4630466214ba8ab1c257a2482",
+  "artifactSha256": "612e2d929b12f1011da69ddcc598cbd251123294b52cfe7c04cd921e18d46ad7",
   "sbom": {
     "format": "CycloneDX-1.5",
     "path": "planu-core.win32-x64-msvc.node.sbom.json",
-    "sha256": "4754b2b3a274f43a3ee5d1bcece2ae4c8a02373bf9ba646291dce44574304df5"
+    "sha256": "b6f3af124aeadba537605434bc406ac76f0bd798244edfbe31566b5011989207"
   },
   "provenance": {
     "builder": "scripts/build-rust-local.sh",
-    "sourceCommit": "a847a7442e7735a9f4f2a9878eccbd52fc54509b",
+    "sourceCommit": "14948c630bfb7a355391c10563934cc79e8bb167",
     "sourceTreeDirty": false,
     "sourceDateEpoch": 1,
     "rustToolchain": "rustc 1.95.0 (59807616e 2026-04-14)",
@@ -33,6 +33,6 @@
   "signature": {
     "algorithm": "Ed25519",
     "keyId": "e2ee765cb5ad9fbdc433ece332bce26d746d5e350b3acde0721a4c8c6337ff7b",
-    "value": "KLoEL/AX7y2xHycyQKsFA2zksyqZ8uDBBixdAqVnSTf5Oa/aEUsOS7CbH2dt3vpY034HSgbZO319iN+ws/taBA=="
+    "value": "2W3TfOtk1zUPWqx2o2a9DmJPT1rSEBL0kLVOrZfggV/B/hEWC5KgLZs0Cy9w6kE5QeWTeGQZ1spl12XVCdAZDQ=="
   }
 }

package/dist/engine/planu-core.win32-x64-msvc.node.sbom.json

@@ -4,14 +4,14 @@
   "version": 1,
   "metadata": {
     "component": {
-      "bom-ref": "pkg:cargo/planu-core@5.3.14",
+      "bom-ref": "pkg:cargo/planu-core@5.3.15",
       "type": "library",
       "name": "planu-core",
-      "version": "5.3.14",
+      "version": "5.3.15",
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "60f4555904763ce92bb3193d78ce261c98334ff4630466214ba8ab1c257a2482"
+          "content": "612e2d929b12f1011da69ddcc598cbd251123294b52cfe7c04cd921e18d46ad7"
         }
       ]
     }
@@ -1106,7 +1106,7 @@
       "dependsOn": []
     },
     {
-      "ref": "pkg:cargo/planu-core@5.3.14",
+      "ref": "pkg:cargo/planu-core@5.3.15",
       "dependsOn": [
         "pkg:cargo/core-foundation@0.10.1",
         "pkg:cargo/hmac@0.12.1",

package/dist/engine/spec-migrator/planu-root-cleaner.d.ts

@@ -1,5 +1,5 @@
-import type { CleanupResult } from '../../types/index.js';
+import type { CleanupResult, HousekeepingAuthority } from '../../types/index.js';
 export type { CleanupResult };
 /** Remove all non-canonical files from planu/ root and per-spec directories. */
-export declare function cleanPlanuRoot(planuDir: string, projectPath?: string): Promise<CleanupResult>;
+export declare function cleanPlanuRoot(planuDir: string, projectPath?: string, authority?: HousekeepingAuthority): Promise<CleanupResult>;
 //# sourceMappingURL=planu-root-cleaner.d.ts.map

package/dist/engine/spec-migrator/planu-root-cleaner.js

@@ -2,9 +2,9 @@
 import { dirname } from 'node:path';
 import { runStrictPlanuCleanup } from './strict-planu-cleanup.js';
 /** Remove all non-canonical files from planu/ root and per-spec directories. */
-export async function cleanPlanuRoot(planuDir, projectPath) {
+export async function cleanPlanuRoot(planuDir, projectPath, authority = { mode: 'report' }) {
     const root = projectPath ?? dirname(planuDir);
-    const strict = await runStrictPlanuCleanup(root);
+    const strict = await runStrictPlanuCleanup(root, authority);
     const deletedRootFiles = [];
     const deletedSpecFiles = [];
     for (const path of [...strict.deleted, ...strict.merged]) {
@@ -20,6 +20,7 @@ export async function cleanPlanuRoot(planuDir, projectPath) {
         deletedRootFiles,
         deletedSpecFiles,
         totalDeleted: strict.deleted.length + strict.merged.length,
+        proposed: strict.proposed,
     };
 }
 //# sourceMappingURL=planu-root-cleaner.js.map

package/dist/engine/spec-migrator/strict-planu-cleanup.d.ts

@@ -1,6 +1,6 @@
-import type { StrictPlanuCleanupResult, StrictPlanuValidationOptions, StrictPlanuValidationResult } from '../../types/index.js';
+import type { StrictPlanuCleanupResult, StrictPlanuValidationOptions, StrictPlanuValidationResult, HousekeepingAuthority } from '../../types/index.js';
 import { PLANU_CANONICAL_POLICY } from './planu-canonical-policy.js';
-export declare function runStrictPlanuCleanup(projectPath: string): Promise<StrictPlanuCleanupResult>;
+export declare function runStrictPlanuCleanup(projectPath: string, authority?: HousekeepingAuthority): Promise<StrictPlanuCleanupResult>;
 export declare function validateStrictPlanuLayout(projectPath: string, options?: StrictPlanuValidationOptions): Promise<StrictPlanuValidationResult>;
 export { PLANU_CANONICAL_POLICY };
 //# sourceMappingURL=strict-planu-cleanup.d.ts.map

package/dist/engine/spec-migrator/strict-planu-cleanup.js

@@ -139,8 +139,24 @@ async function shouldDeleteOrphanSpecDir(specDir) {
     // Keeping them without spec.md leaves a permanently non-canonical orphan behind.
     return !entries.includes('spec.md');
 }
-export async function runStrictPlanuCleanup(projectPath) {
-    const result = { deleted: [], merged: [], gitignoreUpdated: false };
+export async function runStrictPlanuCleanup(projectPath, authority = { mode: 'report' }) {
+    if (authority.mode === 'report') {
+        const validation = await validateStrictPlanuLayout(projectPath);
+        return {
+            mode: 'report',
+            deleted: [],
+            merged: [],
+            proposed: validation.offenders,
+            gitignoreUpdated: false,
+        };
+    }
+    const result = {
+        mode: 'execute',
+        deleted: [],
+        merged: [],
+        proposed: [],
+        gitignoreUpdated: false,
+    };
     const planuDir = join(projectPath, 'planu');
     if (!existsSync(planuDir)) {
         return result;

package/dist/tools/git/cleanup-ops.d.ts

@@ -1,4 +1,4 @@
-import type { ToolResult, GitConfig, SpecDoneCleanupResult } from '../../types/index.js';
+import type { ToolResult, GitConfig, HousekeepingAuthority, SpecDoneCleanupResult } from '../../types/index.js';
 /**
  * AC-02: Eliminate gone branches + remote prune.
  * AC-03: List stale stashes (>7d); drop if force=true.
@@ -11,5 +11,5 @@ export declare function handleCleanup(projectId: string, config?: GitConfig): Pr
  * AC-01: When a spec is marked done, clean its worktree, local branch, and remote branch.
  * Best-effort — never throws. Caller should fire-and-forget or log result.
  */
-export declare function cleanupSpecOnDone(projectPath: string, specId: string, gitBranch: string | undefined): Promise<SpecDoneCleanupResult>;
+export declare function cleanupSpecOnDone(projectPath: string, specId: string, gitBranch: string | undefined, authority?: HousekeepingAuthority): Promise<SpecDoneCleanupResult>;
 //# sourceMappingURL=cleanup-ops.d.ts.map

package/dist/tools/git/cleanup-ops.js

@@ -3,6 +3,7 @@ import { existsSync } from 'node:fs';
 import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { git, resolveProjectPath } from './git-helpers.js';
+import { runAbortableProcess } from '../../engine/abortable-process-runner.js';
 import { compactResult, compactError } from '../output-formatter.js';
 const WORKTREES_DIR = '.claude/worktrees';
 const STALE_DAYS_THRESHOLD = 7;
@@ -48,9 +49,9 @@ async function getMergedBranches(projectPath) {
     return new Set();
 }
 /** Remove a worktree — idempotent (ignores "not a worktree" errors). */
-async function removeWorktree(projectPath, worktreePath) {
+async function removeWorktree(projectPath, worktreePath, force) {
     try {
-        await git(projectPath, ['worktree', 'remove', '--force', worktreePath]);
+        await git(projectPath, ['worktree', 'remove', ...(force ? ['--force'] : []), worktreePath]);
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -97,7 +98,7 @@ async function cleanupOrphanWorktrees(projectPath, mergedBranches) {
                 continue;
             }
             try {
-                await removeWorktree(projectPath, wt.path);
+                await removeWorktree(projectPath, wt.path, true);
                 removed.push(wt.path);
             }
             catch (err) {
@@ -337,85 +338,149 @@ async function findSpecWorktree(projectPath, specId) {
  * AC-01: When a spec is marked done, clean its worktree, local branch, and remote branch.
  * Best-effort — never throws. Caller should fire-and-forget or log result.
  */
-export async function cleanupSpecOnDone(projectPath, specId, gitBranch) {
+export async function cleanupSpecOnDone(projectPath, specId, gitBranch, authority = { mode: 'report' }) {
     const result = {
+        mode: authority.mode,
+        proposals: [],
         worktreeRemoved: null,
         localBranchRemoved: null,
         remoteBranchRemoved: null,
         errors: [],
     };
-    // 1. Remove worktree if it exists
     const worktreePath = await findSpecWorktree(projectPath, specId);
+    const mergedState = gitBranch ? await getBranchMergedState(projectPath, gitBranch) : 'unknown';
+    if (worktreePath) {
+        const worktreeClean = await isWorktreeClean(worktreePath);
+        result.proposals.push({
+            kind: 'worktree',
+            ref: worktreePath,
+            worktreeClean,
+            mergedState,
+            reason: `spec ${specId} is done`,
+            suggestedAction: worktreeClean ? 'delete' : 'inspect',
+        });
+    }
+    if (gitBranch) {
+        const currentBranch = await getCurrentBranch(projectPath);
+        const suggestedAction = mergedState === 'merged' && currentBranch !== gitBranch ? 'delete' : 'keep';
+        result.proposals.push({
+            kind: 'local-branch',
+            ref: gitBranch,
+            worktreeClean: null,
+            mergedState,
+            reason: `spec ${specId} is done`,
+            suggestedAction,
+        });
+        if (await remoteBranchExists(projectPath, gitBranch)) {
+            result.proposals.push({
+                kind: 'remote-branch',
+                ref: `origin/${gitBranch}`,
+                worktreeClean: null,
+                mergedState,
+                reason: `spec ${specId} is done`,
+                suggestedAction: mergedState === 'merged' ? 'delete' : 'keep',
+            });
+        }
+    }
+    if (authority.mode === 'report') {
+        return result;
+    }
     if (worktreePath) {
         try {
-            await removeWorktree(projectPath, worktreePath);
+            await removeWorktree(projectPath, worktreePath, false);
             result.worktreeRemoved = worktreePath;
         }
         catch (err) {
             result.errors.push(`worktree: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
-    if (!gitBranch) {
+    if (!gitBranch || mergedState !== 'merged') {
         return result;
     }
-    // 2. Remove local branch if merged
-    try {
-        const { stdout } = await git(projectPath, ['branch', '--merged', 'develop']);
-        const merged = new Set(stdout
-            .split('\n')
-            .map((b) => b.replace(/^\*?\s+/, '').trim())
-            .filter(Boolean));
-        const isMerged = merged.has(gitBranch);
-        // Also check main as fallback
-        let isMergedMain = false;
-        if (!isMerged) {
-            try {
-                const { stdout: mainOut } = await git(projectPath, ['branch', '--merged', 'main']);
-                const mergedMain = new Set(mainOut
-                    .split('\n')
-                    .map((b) => b.replace(/^\*?\s+/, '').trim())
-                    .filter(Boolean));
-                isMergedMain = mergedMain.has(gitBranch);
-            }
-            catch {
-                // ignore
-            }
+    if ((await getCurrentBranch(projectPath)) !== gitBranch) {
+        try {
+            await git(projectPath, ['branch', '-d', gitBranch]);
+            result.localBranchRemoved = gitBranch;
         }
-        if (isMerged || isMergedMain) {
-            // Never delete current branch
-            const { stdout: headOut } = await git(projectPath, ['rev-parse', '--abbrev-ref', 'HEAD']);
-            if (headOut.trim() !== gitBranch) {
-                try {
-                    await git(projectPath, ['branch', '-d', gitBranch]);
-                    result.localBranchRemoved = gitBranch;
-                }
-                catch {
-                    // Force-delete if needed
-                    try {
-                        await git(projectPath, ['branch', '-D', gitBranch]);
-                        result.localBranchRemoved = gitBranch;
-                    }
-                    catch (err) {
-                        result.errors.push(`local branch: ${err instanceof Error ? err.message : String(err)}`);
-                    }
-                }
-            }
+        catch (err) {
+            result.errors.push(`local branch: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
-    catch (err) {
-        result.errors.push(`merged check: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    // 3. Remove remote branch if it exists
-    try {
-        const { stdout } = await git(projectPath, ['ls-remote', '--heads', 'origin', gitBranch]);
-        if (stdout.trim()) {
+    if (authority.deleteRemoteRefs && (await remoteBranchExists(projectPath, gitBranch))) {
+        try {
             await git(projectPath, ['push', 'origin', '--delete', gitBranch]);
             result.remoteBranchRemoved = `origin/${gitBranch}`;
         }
-    }
-    catch (err) {
-        result.errors.push(`remote branch: ${err instanceof Error ? err.message : String(err)}`);
+        catch (err) {
+            result.errors.push(`remote branch: ${err instanceof Error ? err.message : String(err)}`);
+        }
     }
     return result;
 }
+async function isAncestorOf(projectPath, branch, base) {
+    try {
+        const result = await runAbortableProcess('git', ['merge-base', '--is-ancestor', branch, base], {
+            cwd: projectPath,
+            timeoutMs: 30_000,
+            maxBufferBytes: 1024 * 1024,
+        });
+        if (result.status === 0) {
+            return 'yes';
+        }
+        return result.status === 1 && !result.error ? 'no' : 'indeterminate';
+    }
+    catch {
+        return 'indeterminate';
+    }
+}
+async function getBranchMergedState(projectPath, branch) {
+    let sawNotMerged = false;
+    let indeterminate = false;
+    for (const base of ['main', 'develop', 'master']) {
+        try {
+            await git(projectPath, ['rev-parse', '--verify', base]);
+        }
+        catch {
+            continue;
+        }
+        const ancestry = await isAncestorOf(projectPath, branch, base);
+        if (ancestry === 'yes') {
+            return 'merged';
+        }
+        if (ancestry === 'no') {
+            sawNotMerged = true;
+        }
+        else {
+            indeterminate = true;
+        }
+    }
+    return sawNotMerged && !indeterminate ? 'not_merged' : 'unknown';
+}
+async function isWorktreeClean(worktreePath) {
+    try {
+        const { stdout } = await git(worktreePath, ['status', '--porcelain']);
+        return stdout.trim() === '';
+    }
+    catch {
+        return null;
+    }
+}
+async function getCurrentBranch(projectPath) {
+    try {
+        const { stdout } = await git(projectPath, ['rev-parse', '--abbrev-ref', 'HEAD']);
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function remoteBranchExists(projectPath, branch) {
+    try {
+        const { stdout } = await git(projectPath, ['ls-remote', '--heads', 'origin', branch]);
+        return stdout.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
 //# sourceMappingURL=cleanup-ops.js.map

package/dist/tools/github-release-handler.js

@@ -209,13 +209,12 @@ export async function handleCreateRelease(args, exec = defaultExec) {
         const { runHousekeepingSweep } = await import('../engine/housekeeping/index.js');
         const sweepReport = await runHousekeepingSweep({
             projectPath: releasePath,
-            dryRun: false,
             aggressive: false,
             includeStashes: false,
         });
-        if (sweepReport.deleted.branches > 0 || sweepReport.deleted.worktrees > 0) {
-            outputLines.push(`  Housekeeping: deleted ${String(sweepReport.deleted.branches)} branch(es), ` +
-                `${String(sweepReport.deleted.worktrees)} worktree(s)`);
+        if (sweepReport.wouldDelete.branches.length > 0 ||
+            sweepReport.wouldDelete.worktrees.length > 0) {
+            outputLines.push(`  Housekeeping: ${String(sweepReport.wouldDelete.branches.length)} branch(es), ${String(sweepReport.wouldDelete.worktrees.length)} worktree(s) proposed — run housekeeping_sweep`);
         }
     }
     catch {
@@ -247,14 +246,6 @@ export async function handleCreateRelease(args, exec = defaultExec) {
                 validateScore: null,
                 allSpecs,
             }, { disabledByConfig: new Set(), disabledByEnv: new Set() });
-            // SPEC-790: Auto-trigger housekeeping_sweep after release to clean branches/worktrees
-            try {
-                const { runHousekeepingSweep } = await import('../engine/housekeeping/index.js');
-                void runHousekeepingSweep({ projectPath: releasePath, dryRun: false });
-            }
-            catch {
-                /* best-effort — housekeeping never blocks the release */
-            }
         }
         catch {
             /* best-effort — release_completed cascade never blocks the release response */

package/dist/tools/housekeeping-sweep.d.ts

@@ -3,6 +3,7 @@ import type { ToolResult } from '../types/index.js';
 export declare const HousekeepingSweepInputSchema: z.ZodObject<{
     projectPath: z.ZodOptional<z.ZodString>;
     dryRun: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    deleteRemoteRefs: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     aggressive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     includeStashes: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, z.core.$strip>;

package/dist/tools/housekeeping-sweep.js

@@ -19,6 +19,11 @@ export const HousekeepingSweepInputSchema = z.object({
         .optional()
         .default(true)
         .describe('When true (default), only report — no deletions performed'),
+    deleteRemoteRefs: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('When true with dryRun false, allow deletion of merged origin branches'),
     aggressive: z
         .boolean()
         .optional()
@@ -107,9 +112,13 @@ function formatReportWithEphemeral(report, orphan, ephemeral) {
 export async function handleHousekeepingSweep(args, resolvedProjectPath) {
     const projectPath = args.projectPath ?? resolvedProjectPath;
     const dryRun = args.dryRun ?? true;
+    const deleteRemoteRefs = args.deleteRemoteRefs ?? false;
+    const authority = dryRun
+        ? { mode: 'report' }
+        : { mode: 'execute', deleteRemoteRefs };
     const report = await runHousekeepingSweep({
         projectPath,
-        dryRun,
+        authority,
         aggressive: args.aggressive ?? false,
         includeStashes: args.includeStashes ?? false,
     });
@@ -145,15 +154,13 @@ export async function handleHousekeepingSweep(args, resolvedProjectPath) {
     }
     let strictPlanuCleanup = null;
     try {
-        const { runStrictPlanuCleanup, validateStrictPlanuLayout } = await import('../engine/spec-migrator/index.js');
-        if (!dryRun) {
-            const cleanup = await runStrictPlanuCleanup(projectPath);
-            strictPlanuCleanup = { deleted: cleanup.deleted, merged: cleanup.merged, offenders: [] };
-        }
-        else {
-            const validation = await validateStrictPlanuLayout(projectPath);
-            strictPlanuCleanup = { deleted: [], merged: [], offenders: validation.offenders };
-        }
+        const { runStrictPlanuCleanup } = await import('../engine/spec-migrator/index.js');
+        const cleanup = await runStrictPlanuCleanup(projectPath, authority);
+        strictPlanuCleanup = {
+            deleted: cleanup.deleted,
+            merged: cleanup.merged,
+            offenders: cleanup.proposed,
+        };
     }
     catch {
         /* best-effort — never block housekeeping_sweep */

package/dist/tools/init-project/git-setup.d.ts

@@ -3,6 +3,7 @@ export interface GitSetupResult {
     gitFlowType: string;
     gitignoreUpdated: boolean;
     gitRepoDetected: boolean;
+    layoutOffenders: string[];
 }
 /** SPEC-001 + SPEC-539: Setup git hooks, detect branching model, and configure .gitignore.
  * SPEC-539: Only installs hooks if a git repository is detected — never creates .git. */