codebyplan 1.13.34 → 1.13.36

package/dist/cli.js

@@ -14,7 +14,7 @@ var VERSION, PACKAGE_NAME;
 var init_version = __esm({
   "src/lib/version.ts"() {
     "use strict";
-    VERSION = "1.13.34";
+    VERSION = "1.13.36";
     PACKAGE_NAME = "codebyplan";
   }
 });
@@ -1606,22 +1606,16 @@ function mergeEnabledPluginsIntoSettings(settings, plugins) {
   }
   return settings;
 }
-function stripOwnedHooksFromSettings(settings) {
+function collapseEmptyHookBlocks(settings) {
   if (!settings.hooks) {
-    return settings;
+    return;
   }
   for (const event of Object.keys(settings.hooks)) {
     const eventBlocks = settings.hooks[event];
     if (!eventBlocks) {
       continue;
     }
-    const survivingBlocks = [];
-    for (const block of eventBlocks) {
-      block.hooks = block.hooks.filter((e) => e._owner !== OWNER);
-      if (block.hooks.length > 0) {
-        survivingBlocks.push(block);
-      }
-    }
+    const survivingBlocks = eventBlocks.filter((b) => b.hooks.length > 0);
     if (survivingBlocks.length > 0) {
       settings.hooks[event] = survivingBlocks;
     } else {
@@ -1631,6 +1625,54 @@ function stripOwnedHooksFromSettings(settings) {
   if (Object.keys(settings.hooks).length === 0) {
     delete settings.hooks;
   }
+}
+function stripOwnedHooksFromSettings(settings) {
+  if (!settings.hooks) {
+    return settings;
+  }
+  for (const event of Object.keys(settings.hooks)) {
+    const eventBlocks = settings.hooks[event];
+    if (!eventBlocks) {
+      continue;
+    }
+    for (const block of eventBlocks) {
+      block.hooks = block.hooks.filter((e) => e._owner !== OWNER);
+    }
+  }
+  collapseEmptyHookBlocks(settings);
+  return settings;
+}
+function pruneMissingManagedHooks(settings, hooksJson, onPruned) {
+  if (!settings.hooks) {
+    return settings;
+  }
+  const liveIdsByEvent = /* @__PURE__ */ new Map();
+  for (const [event, matchers] of Object.entries(hooksJson.hooks)) {
+    const ids = /* @__PURE__ */ new Set();
+    for (const block of matchers) {
+      for (const cmd of block.hooks) {
+        ids.add(extractHookId(cmd.command));
+      }
+    }
+    liveIdsByEvent.set(event, ids);
+  }
+  for (const event of Object.keys(settings.hooks)) {
+    const eventBlocks = settings.hooks[event];
+    if (!eventBlocks) {
+      continue;
+    }
+    const liveIds = liveIdsByEvent.get(event) ?? /* @__PURE__ */ new Set();
+    for (const block of eventBlocks) {
+      block.hooks = block.hooks.filter((e) => {
+        const shouldPrune = e._owner === OWNER && e._hook_id !== void 0 && !liveIds.has(e._hook_id);
+        if (shouldPrune && onPruned) {
+          onPruned(e._hook_id);
+        }
+        return !shouldPrune;
+      });
+    }
+  }
+  collapseEmptyHookBlocks(settings);
   return settings;
 }
 var OWNER, PLACEHOLDER_RE, REPLACEMENT, SCALAR_BASE_KEYS, DEPRECATED_BASE_KEYS;
@@ -2558,9 +2600,9 @@ async function runLspFull(projectPath, opts = {}) {
     `  Detected LSP servers: ${servers.map((s) => s.plugin).join(", ")}
 `
   );
-  const settingsPath = join10(projectPath, ".claude", "settings.json");
+  const settingsLocalPath = join10(projectPath, ".claude", "settings.local.json");
   let settings = {};
-  const existingSettingsRaw = await readJsonFile(settingsPath);
+  const existingSettingsRaw = await readJsonFile(settingsLocalPath);
   if (existingSettingsRaw) {
     settings = existingSettingsRaw;
   }
@@ -2569,15 +2611,15 @@ async function runLspFull(projectPath, opts = {}) {
     servers.map((s) => s.plugin)
   );
   if (dryRun) {
-    console.log(`  [dry-run] would update ${settingsPath}`);
+    console.log(`  [dry-run] would update ${settingsLocalPath}`);
   } else {
     await mkdir4(join10(projectPath, ".claude"), { recursive: true });
     await writeFile6(
-      settingsPath,
+      settingsLocalPath,
       JSON.stringify(settings, null, 2) + "\n",
       "utf-8"
     );
-    console.log(`  Updated ${settingsPath}`);
+    console.log(`  Updated ${settingsLocalPath}`);
   }
   const lspJsonPath = join10(projectPath, ".codebyplan", "lsp.json");
   const lspJsonContent = {
@@ -2648,7 +2690,7 @@ async function runLspFull(projectPath, opts = {}) {
     `    Enabled plugins: ${pluginNames.length > 0 ? pluginNames.join(", ") : "none"}`
   );
   console.log(
-    `    (settings.json key format: <plugin>@claude-plugins-official)`
+    `    (settings.local.json key format: <plugin>@claude-plugins-official)`
   );
   if (autoInstalled.length > 0) {
     console.log(
@@ -2811,6 +2853,13 @@ async function runInstall(opts, deps = {}) {
         fs3.readFileSync(hooksJsonPath, "utf8")
       );
       mergeHooksIntoSettings(existingSettings, hooksJson);
+      pruneMissingManagedHooks(
+        existingSettings,
+        hooksJson,
+        opts.verbose ? (id) => console.log(
+          `${opts.dryRun ? "[dry-run] would prune" : "pruned"} removed managed hook: ${id}`
+        ) : void 0
+      );
     }
     if (!opts.dryRun) {
       fs3.mkdirSync(path4.dirname(settingsPath), { recursive: true });
@@ -5628,6 +5677,13 @@ function defaultPrBody(feat, base) {
 Merge \`${feat}\` \u2192 \`${base}\`.
 `;
 }
+function evaluateChecks(checks) {
+  const failed = checks.filter(
+    (c) => c.bucket !== "pass" && c.bucket !== "skipping" && c.bucket !== "pending"
+  ).map((c) => c.name);
+  const pending = checks.filter((c) => c.bucket === "pending").length;
+  return { passed: failed.length === 0 && pending === 0, failed, pending };
+}
 async function pollChecks(feat, timeoutSeconds, cwd, _sleepMs = (ms) => new Promise((r) => setTimeout(r, ms))) {
   const deadline = Date.now() + timeoutSeconds * 1e3;
   const POLL_INTERVAL_MS = 15e3;
@@ -5640,7 +5696,7 @@ async function pollChecks(feat, timeoutSeconds, cwd, _sleepMs = (ms) => new Prom
   while (Date.now() < deadline) {
     const ghResult = spawnSync6(
       "gh",
-      ["pr", "checks", feat, "--json", "name,state,conclusion"],
+      ["pr", "checks", feat, "--json", "name,state,bucket"],
       {
         cwd,
         encoding: "utf-8",
@@ -5678,17 +5734,14 @@ async function pollChecks(feat, timeoutSeconds, cwd, _sleepMs = (ms) => new Prom
       return { passed: true };
     }
     iteration++;
-    const pending = checks.filter(
-      (c) => c.state === "PENDING" || c.state === "QUEUED" || c.state === "IN_PROGRESS"
-    );
-    const failed = checks.filter(
-      (c) => c.state === "COMPLETED" && c.conclusion !== null && c.conclusion !== "SUCCESS" && c.conclusion !== "NEUTRAL" && c.conclusion !== "SKIPPED"
-    );
-    if (failed.length > 0) {
-      const names = failed.map((c) => c.name).join(", ");
-      return { passed: false, reason: `Checks failed: ${names}` };
+    const result = evaluateChecks(checks);
+    if (result.failed.length > 0) {
+      return {
+        passed: false,
+        reason: `Checks failed: ${result.failed.join(", ")}`
+      };
     }
-    if (pending.length === 0) {
+    if (result.pending === 0) {
       return { passed: true };
     }
     await _sleepMs(POLL_INTERVAL_MS);
@@ -8806,6 +8859,13 @@ async function runUpdate(opts, deps = {}) {
         fs7.readFileSync(hooksJsonPath, "utf8")
       );
       mergeHooksIntoSettings(existingSettings, hooksJson);
+      pruneMissingManagedHooks(
+        existingSettings,
+        hooksJson,
+        opts.verbose ? (id) => console.log(
+          `${opts.dryRun ? "[dry-run] would prune" : "pruned"} removed managed hook: ${id}`
+        ) : void 0
+      );
     }
     if (!opts.dryRun) {
       fs7.mkdirSync(path8.dirname(settingsPath), { recursive: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebyplan",
-  "version": "1.13.34",
+  "version": "1.13.36",
   "description": "CLI for CodeByPlan — AI-powered development planning and tracking",
   "type": "module",
   "bin": {

package/templates/rules/supabase-branch-lifecycle.md

@@ -10,6 +10,7 @@ paths:
   - ".claude/skills/cbp-checkpoint-end/**"
   - ".claude/skills/cbp-git-worktree-remove/**"
   - ".claude/skills/cbp-ship-main/**"
+  - ".claude/skills/cbp-standalone-task-complete/**"
 ---
 
 # Supabase Branch Lifecycle
@@ -50,6 +51,7 @@ The Supabase branch is removed wherever the git branch is deleted:
 | `cbp-checkpoint-end` | stale-branch cleanup + current feat-branch delete on ship |
 | `cbp-git-worktree-remove` | worktree teardown removes the coupled Supabase branch |
 | `cbp-ship-main` | `branch_deleted` event after PR merge |
+| `cbp-standalone-task-complete` | `branch_deleted` event after standalone PR merge (Step 7.3) |
 
 Deletion is **existence-checked and idempotent** — a not-found response is treated as
 success. This tolerates the GitHub integration auto-deleting the preview branch on PR
@@ -93,7 +95,7 @@ or auto-created by the GitHub integration — both paths use the same branch nam
 | Role | Skill |
 |---|---|
 | Create (lazy) | `cbp-supabase-migrate` (Step 2.3) |
-| Delete | `cbp-checkpoint-end`, `cbp-git-worktree-remove`, `cbp-ship-main` |
+| Delete | `cbp-checkpoint-end`, `cbp-standalone-task-complete`, `cbp-git-worktree-remove`, `cbp-ship-main` |
 | PR gate | `cbp-supabase-branch-check` |
 
 Each skill in the Skill Map above carries an inline back-reference to this rule at its create or teardown step.

package/templates/skills/cbp-ship-main/SKILL.md

@@ -38,6 +38,24 @@ Write to `/tmp/cbp-ship-main-body.md`:
 - /cbp-checkpoint-check passed
 ```
 
+### Step 2.5: Supabase Branch Pre-Merge Gate
+
+**PR-existence pre-check** — `codebyplan ship` (Step 3) is what pushes the branch and creates the PR, so on the FIRST ship of a branch no PR exists yet and a `pre_merge` gate would self-defeatingly block the very step that creates it. Probe first:
+
+```bash
+PR_EXISTS=$(gh pr list --head "$(git branch --show-current)" --json number --jq 'length' 2>/dev/null || echo 0)
+```
+
+- `PR_EXISTS` is `0` → skip this gate and proceed directly to Step 3 with a one-line note: `Supabase pre-merge gate skipped (no PR yet) — the generic check-poll inside codebyplan ship gates Supabase Preview as a required check.`
+- `PR_EXISTS` ≥ `1` → run the gate: invoke the `cbp-supabase-branch-check` skill with `--mode pre_merge --target production` and parse the fenced JSON block it emits (`status`, `reason`, optional `failed_step` / `log_excerpt`).
+
+Gate dispositions:
+
+- `status: "passed"` or `status: "skipped"` → proceed to Step 3.
+- `status: "blocked"` or `status: "pending_pr"` → surface `reason` (plus `failed_step` and `log_excerpt` when present) and STOP — do NOT invoke `codebyplan ship`.
+
+**Dual-gate note**: this dedicated gate adds DB-failure diagnostics (`failed_step`, `log_excerpt` pulled from Supabase logs) that the generic check-poll inside `codebyplan ship` cannot produce. The generic poll (`pollChecks` → `evaluateChecks` in `src/lib/ship.ts`, gh bucket model) still runs after PR creation and gates Supabase Preview as one required check among all checks — the two gates are complementary, not redundant.
+
 ### Step 3: Invoke `codebyplan ship`
 
 ```bash
@@ -53,7 +71,7 @@ Pass `--dry-run` through if the skill was invoked with a dry-run arg.
 
 Parse JSON from Step 3. Report `pr_url`, `merge_commit`, `branch_deleted`. If `checks_failed: true`, surface `checks_failure_reason` and stop.
 
-> **gh false-negative workaround.** `codebyplan ship` can report `checks_failed: true` when the underlying `gh` query reads a stale/mismatched check field (it queries `conclusion`/`state` and the GitHub API can lag). Before treating the stop as final, verify the real status: `gh pr checks <PR> --watch`. If every required check is green, merge manually with `gh pr merge <PR> --merge` — add `--admin` ONLY to escape a transient secondary-rate-limit loop, never to bypass a genuinely-failing gate. Never auto-merge silently on a `checks_failed` report; this verification is a manual decision.
+> **gh false-negative workaround.** `codebyplan ship` can report `checks_failed: true` when the underlying `gh` query reads a stale/mismatched check field (the poller queries the gh `bucket` field — `pass|fail|pending|skipping|cancel` — and fail-safe-blocks anything outside `pass`/`skipping`, so an API lag or an unrecognized bucket reads as a failure). Before treating the stop as final, verify the real status: `gh pr checks <PR> --watch`. If every required check is green, merge manually with `gh pr merge <PR> --merge` — add `--admin` ONLY to escape a transient secondary-rate-limit loop, never to bypass a genuinely-failing gate. Never auto-merge silently on a `checks_failed` report; this verification is a manual decision. (A `checks_failed` at this stage most likely pertains to a non-Supabase-Preview check — Supabase Preview was already gated in Step 2.5 when a PR pre-existed. If `gh pr checks <PR> --watch` shows Supabase Preview itself failing, investigate via `cbp-supabase-branch-check`'s `failed_step`/`log_excerpt` diagnostics before treating it as a false negative.)
 
 If `bumps[]` is present with any non-skipped entry, surface a **Version bumps** line per package — `<name>: <currentVersion> → <nextVersion>` — so the user sees what this PR will publish on merge.
 

package/templates/skills/cbp-standalone-task-complete/SKILL.md

@@ -1,7 +1,7 @@
 ---
 scope: repo-only:codebyplan
 name: cbp-standalone-task-complete
-description: Complete a standalone task — merge feat branch and mark done
+description: Complete a standalone task — ship feat branch to production via PR and mark done
 argument-hint: [task]  # e.g. `45` (standalone TASK-45)
 effort: xhigh
 ---
@@ -125,24 +125,60 @@ Skip only when nothing was committed AND `/cbp-merge-main` reported already-up-t
 
 `update_standalone_task(task_id, context: { ...existing, files_changed: aggregated_files })`.
 
-### Step 7: Standalone Task Branch Merge
+### Step 7: Standalone Task Branch Ship
 
 Only when current branch matches `feat/standalone-TASK-*`:
 
-1. Read `.codebyplan/git.json` `branch_config.production` (default: `main`). Store as `PRODUCTION`.
-2. `git checkout {PRODUCTION}`
-3. `git merge {feat-branch} --no-ff -m "Merge {feat-branch}: {task title}"`
-4. `git push origin {PRODUCTION}`
-5. Delete feat branch local: `git branch -d {feat-branch}`
-6. Delete feat branch remote: `git push origin --delete {feat-branch}`
+#### Step 7.1 — Compose PR body
 
-If merge has conflicts, stop immediately and ask the user to resolve. Do not delete the feat branch until the merge succeeds and is pushed.
+Write `/tmp/cbp-ship-body-standalone-{N}.md`:
 
-If current branch is not `feat/standalone-TASK-*`, skip this step.
+```markdown
+## Summary
+
+{standalone_task.title}
+
+Standalone TASK-{N}
+
+## Test Plan
+
+- All rounds passed testing-qa
+- /cbp-standalone-task-check passed
+```
+
+#### Step 7.2 — Invoke `codebyplan ship`
+
+```bash
+codebyplan ship --body-file /tmp/cbp-ship-body-standalone-{N}.md --json
+```
+
+`codebyplan ship` patch-bumps every changed workspace package and commits `chore(release): bump versions` on the feat branch BEFORE creating the PR, so the bump rides this same feat→main PR. Pass `--no-bump` for infra/doc-only standalone work where a version bump is not appropriate.
+
+`codebyplan ship` pushes the feat branch, gets-or-creates the PR, polls required checks (including Supabase Preview) via the gh bucket model (`pollChecks` → `evaluateChecks` — pass|fail|pending|skipping|cancel; only pass/skipping are non-blocking), merges with `gh pr merge --merge`, checks out the base branch, and deletes the feat branch.
+
+**On `checks_failed: true`**: surface `checks_failure_reason` and STOP — do NOT proceed to Step 7.5 (`complete_standalone_task` is never called on a failed ship).
+
+> **gh false-negative workaround.** `codebyplan ship` can report `checks_failed: true` when the underlying `gh` query reads a stale/mismatched check field. Before treating the stop as final, verify with `gh pr checks <PR> --watch`. If every required check is genuinely green, merge manually with `gh pr merge <PR> --merge`. Never auto-merge silently on a `checks_failed` report — this verification is a manual decision.
+
+Parse the JSON output and store: `pr_url`, `merge_commit`, `branch_deleted`, `feat_branch`, `checks_failed`, `checks_failure_reason`, `bumps[]`.
+
+#### Step 7.3 — Supabase preview-branch teardown
+
+> Lifecycle contract: see [[supabase-branch-lifecycle]].
+
+When `branch_deleted === true` in the ship JSON:
+
+- Read `FEAT_BRANCH` from the `feat_branch` field in the ship JSON — NOT from `git branch --show-current`. By the time Step 7.3 runs, `codebyplan ship` has already checked out the base branch, so the live branch is the base, not the feat branch.
+- Call `mcp__supabase__list_branches` with `project_id: rrvtrumtkhrsbhcyrwvf`.
+- Scan the returned list for an entry whose `name` exactly equals `FEAT_BRANCH`.
+- If found: call `mcp__supabase__delete_branch` with its `branch_id`. Report the outcome.
+- If not found: no-op silently — the GitHub integration may have already removed the preview branch on PR close; not-found is success, NOT an error.
+- If the `list_branches` call itself fails (network, auth, or non-success response): emit a non-blocking warning that the Supabase preview branch for `FEAT_BRANCH` may still exist and should be verified in the dashboard. Never treat an API failure as a not-found success.
+- Never delete the parent project `rrvtrumtkhrsbhcyrwvf` itself or any persistent/production branch.
 
 ### Step 7.5: Complete Standalone Task
 
-Note: `complete_standalone_task` is called only after the branch merge succeeds — the DB completion record reflects work that has landed in production.
+Note: `complete_standalone_task` is called only after `codebyplan ship` succeeds (no `checks_failed`) — the DB completion record reflects work that has landed in production.
 
 Resolve caller worktree: `CALLER_WT=$(npx codebyplan resolve-worktree 2>/dev/null)`.
 
@@ -168,7 +204,10 @@ Apply the `cleanup` skill inline to remove orphan references to deleted/modified
 **Rounds**: [N] completed
 **Files**: [N] changed
 **Commit**: [hash]
-**Branch merged**: [feat-branch] → {PRODUCTION}
+**PR**: [pr_url]
+**Merge commit**: [merge_commit]
+**Branch deleted**: [branch_deleted]
+**Version bumps**: [<name>: <current> → <next> per package, or "none"]
 **Warnings**: [any QA / file-approval warnings from Step 3, or "none"]
 ```
 
@@ -187,7 +226,7 @@ Do NOT use AskUserQuestion for routing. Do NOT use the Skill tool to auto-trigge
 ## Key Rules
 
 - **`caller_worktree_id` is REQUIRED** for `complete_standalone_task`
-- **Branch merge lives here** (not in checkpoint-end) — standalone tasks self-ship to production
+- **Branch shipping lives here** (not in checkpoint-end) — standalone tasks self-ship to production via `codebyplan ship`
 - **Single-directive routing** — no menus, no auto-triggers via Skill tool
 - **No checkpoint** — never check `checkpoint_id`, always treat task as standalone
 - **Never skippable prerequisites** — check_verdict READY + task_testing_output all_passed required
@@ -196,6 +235,7 @@ Do NOT use AskUserQuestion for routing. Do NOT use the Skill tool to auto-trigge
 
 - **Triggered by**: `/cbp-standalone-task-testing` emits directive (user runs it manually after seeing directive)
 - **Chain**: `/cbp-standalone-task-check` → `/cbp-standalone-task-testing` → `/cbp-standalone-task-complete`
+- **Delegates to**: `codebyplan ship` CLI (Step 7 — PR creation, check polling, merge, branch cleanup)
 - **Reads**: MCP `get_current_standalone_task`, `get_standalone_tasks`, `get_standalone_rounds`
 - **Writes**: MCP `update_standalone_task`, `complete_standalone_task`
 - **Uses skills (inline, no sub-agent)**: `cleanup` (if deletions), `migration` (if exports renamed)

package/templates/skills/cbp-supabase-branch-check/SKILL.md

@@ -57,7 +57,7 @@ Invalid --mode value: <value>. Valid values: pre_pr_create, pre_merge.
 
 Infer `TARGET` when absent:
 - `pre_pr_create` → `integration`
-- `pre_merge` → detect via `gh pr view --json baseRefName --jq '.baseRefName'`; fallback to `integration` if no PR is open.
+- `pre_merge` → detect via `gh pr view --json baseRefName --jq '.baseRefName'`; fallback to `integration` if no PR is open. Production-ship callers (e.g. `cbp-ship-main` Step 2.5) should pass `--target production` explicitly rather than rely on auto-detect.
 
 ## Step 1 — Read DB Paths Config
 
@@ -339,5 +339,6 @@ Both emit `status: passed` so callers proceed; the `reason` differs for traceabi
 
 ## Integration
 
-**Callers**: `/cbp-ship-main` invokes this skill pre-merge (mode=`pre_merge`, target=`production`, no override).
+**Callers**: `cbp-ship-main` Step 2.5 invokes this skill pre-merge (`--mode pre_merge --target production`, only when a PR already exists for the branch); the caller proceeds on `passed` (Supabase Preview check green — including the CI-level `skipping` bucket, which Step 8 maps to `passed`) and `skipped` (no DB-path changes detected — the gate did not apply), and stops on `blocked`/`pending_pr`. Note: `status: "skipped"` is NOT the CI `skipping` bucket — the two are distinct layers.
+**Canonical bucket contract**: the gh-checks bucket vocabulary used in Step 6 — `pass|fail|pending|skipping|cancel` — is the single canonical contract shared with `evaluateChecks()` in `packages/codebyplan-package/src/lib/ship.ts` (the generic poller inside `codebyplan ship`). Only `pass`/`skipping` are non-blocking, `pending` waits, and every other disposition blocks (fail-safe). The two pollers MUST NOT drift — any change to this enum or its dispositions must land in both places.
 **Tools used**: `mcp__supabase__list_branches` for project_ref resolution; `mcp__supabase__get_logs` for failure diagnostics; `gh pr checks` for status polling; `supabase --experimental branches get` as CLI fallback.