codebyplan 1.13.30 → 1.13.32

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.30";
+    VERSION = "1.13.32";
     PACKAGE_NAME = "codebyplan";
   }
 });
@@ -1493,6 +1493,23 @@ function mergeBaseSettingsIntoSettings(settings, base) {
     if (base.permissions.skipDangerousModePermissionPrompt !== void 0 && existing.skipDangerousModePermissionPrompt === void 0) {
       existing.skipDangerousModePermissionPrompt = base.permissions.skipDangerousModePermissionPrompt;
     }
+    const baseEntryTier = /* @__PURE__ */ new Map();
+    for (const key of ["deny", "ask", "allow"]) {
+      const baseArr = base.permissions[key];
+      if (!baseArr) continue;
+      for (const entry of baseArr) {
+        baseEntryTier.set(entry, key);
+      }
+    }
+    if (baseEntryTier.size > 0) {
+      for (const key of ["deny", "ask", "allow"]) {
+        const current = existing[key];
+        if (!current) continue;
+        existing[key] = current.filter(
+          (entry) => !baseEntryTier.has(entry) || baseEntryTier.get(entry) === key
+        );
+      }
+    }
     for (const key of ["deny", "ask", "allow"]) {
       const incoming = base.permissions[key];
       if (!incoming || incoming.length === 0) continue;
@@ -1507,6 +1524,11 @@ function mergeBaseSettingsIntoSettings(settings, base) {
       }
       existing[key] = merged;
     }
+    for (const key of ["deny", "ask", "allow"]) {
+      if (existing[key]?.length === 0) {
+        delete existing[key];
+      }
+    }
     if (settings.permissions !== void 0 || Object.keys(existing).length > 0) {
       settings.permissions = existing;
     }
@@ -1550,17 +1572,20 @@ function stripBaseSettingsFromSettings(settings, base) {
     if (base.permissions.skipDangerousModePermissionPrompt !== void 0 && perms.skipDangerousModePermissionPrompt === base.permissions.skipDangerousModePermissionPrompt) {
       delete perms.skipDangerousModePermissionPrompt;
     }
+    const baseOwned = /* @__PURE__ */ new Set();
     for (const key of ["deny", "ask", "allow"]) {
-      const baseList = base.permissions[key];
-      if (!baseList || baseList.length === 0) continue;
-      const current = perms[key];
-      if (!current) continue;
-      const baseSet = new Set(baseList);
-      const filtered = current.filter((x) => !baseSet.has(x));
-      if (filtered.length === 0) {
-        delete perms[key];
-      } else {
-        perms[key] = filtered;
+      for (const entry of base.permissions[key] ?? []) baseOwned.add(entry);
+    }
+    if (baseOwned.size > 0) {
+      for (const key of ["deny", "ask", "allow"]) {
+        const current = perms[key];
+        if (!current) continue;
+        const filtered = current.filter((x) => !baseOwned.has(x));
+        if (filtered.length === 0) {
+          delete perms[key];
+        } else {
+          perms[key] = filtered;
+        }
       }
     }
     if (Object.keys(perms).length === 0) {

package/package.json

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

package/templates/hooks/cbp-mcp-caller-worktree-inject.sh

@@ -0,0 +1,79 @@
+#!/bin/bash
+# @scope: org-shared
+# @hook: PreToolUse mcp__codebyplan__(update_checkpoint|complete_checkpoint|update_task|complete_task|add_round|update_round|complete_round|create_standalone_task|update_standalone_task|complete_standalone_task|add_standalone_round|update_standalone_round|complete_standalone_round|update_standalone_file_change)
+# Hook: PreToolUse for MCP write tools
+#
+# Purpose: Inject caller_worktree_id into MCP mutation tool inputs when the
+#          field is absent. Reads the worktree.local.json branch-keyed cache
+#          first (fast path); falls back to `codebyplan resolve-worktree --cache`.
+#
+# Fail-open: ALL exit paths exit 0. A hook failure must never block a tool call.
+#            Use explicit guards rather than set -euo pipefail (which would exit
+#            non-zero on the first failing command before the final exit 0).
+
+# C0 — require jq; if absent, emit nothing and exit 0 (fail-open).
+if ! command -v jq > /dev/null 2>&1; then
+  exit 0
+fi
+
+# Read stdin once into a variable.
+INPUT=$(cat)
+
+# C6 — if caller_worktree_id is already a non-empty string, do not overwrite.
+# (jq '// empty' already maps JSON null to an empty string, so a plain -n test suffices.)
+EXISTING=$(echo "$INPUT" | jq -r '.tool_input.caller_worktree_id // empty' 2>/dev/null)
+if [ -n "$EXISTING" ]; then
+  # Already populated — plain allow (exit 0 with no output).
+  exit 0
+fi
+
+# C5 — resolve worktree id, fast path first.
+RESOLVED_WT=""
+
+# Determine repo root: prefer $CLAUDE_PROJECT_DIR, fall back to PWD.
+REPO_ROOT="${CLAUDE_PROJECT_DIR:-$PWD}"
+CACHE_FILE="$REPO_ROOT/.codebyplan/worktree.local.json"
+
+if [ -f "$CACHE_FILE" ]; then
+  CACHED_WT=$(jq -r '.worktree_id // empty' "$CACHE_FILE" 2>/dev/null)
+  CACHED_BRANCH=$(jq -r '.branch // empty' "$CACHE_FILE" 2>/dev/null)
+
+  if [ -n "$CACHED_WT" ] && [ "$CACHED_WT" != "null" ] && \
+     [ -n "$CACHED_BRANCH" ] && [ "$CACHED_BRANCH" != "null" ]; then
+    # Validate branch matches current git branch.
+    CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null)
+    if [ -n "$CURRENT_BRANCH" ] && [ "$CURRENT_BRANCH" = "$CACHED_BRANCH" ]; then
+      RESOLVED_WT="$CACHED_WT"
+    fi
+  fi
+fi
+
+# Fallback to CLI resolution if cache miss or branch mismatch.
+if [ -z "$RESOLVED_WT" ]; then
+  RESOLVED_WT=$(codebyplan resolve-worktree --cache 2>/dev/null \
+    || npx --no-install codebyplan resolve-worktree --cache 2>/dev/null \
+    || true)
+fi
+
+# UUID guard — accept only a canonical UUID (8-4-4-4-12 hex).
+UUID_PATTERN='^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$'
+if [ -z "$RESOLVED_WT" ] || ! echo "$RESOLVED_WT" | grep -qE "$UUID_PATTERN"; then
+  # Unresolved or invalid — plain allow, no updatedInput.
+  exit 0
+fi
+
+# C3 — emit updatedInput as the FULL tool_input with caller_worktree_id added.
+# Claude Code's PreToolUse updatedInput REPLACES tool_input wholesale (it is not a
+# partial merge), so we must echo back every existing field merged with the new
+# caller_worktree_id — otherwise the tool loses round_id/duration_minutes/etc.
+echo "$INPUT" | jq \
+  --arg wt "$RESOLVED_WT" \
+  '{
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "allow",
+      updatedInput: (.tool_input + { caller_worktree_id: $wt })
+    }
+  }'
+
+exit 0

package/templates/hooks/cbp-test-hooks.sh

@@ -374,6 +374,87 @@ fi
 
 echo ""
 
+# ===== HOOK SMOKE TESTS — cbp-mcp-caller-worktree-inject =====
+echo "## Hook Smoke Tests — cbp-mcp-caller-worktree-inject (CHK-198)"
+
+INJECT_HOOK="$HOOKS_DIR/cbp-mcp-caller-worktree-inject.sh"
+# Absolute path — the fail-open test runs the hook from a temp cwd (to isolate it
+# from this repo's git context), where the relative "$HOOKS_DIR" no longer resolves.
+INJECT_HOOK_ABS="$(cd "$HOOKS_DIR" 2>/dev/null && pwd)/cbp-mcp-caller-worktree-inject.sh"
+
+if [ ! -f "$INJECT_HOOK" ]; then
+  test_result "cbp-mcp-caller-worktree-inject.sh present" "passed" "missing"
+else
+  test_result "cbp-mcp-caller-worktree-inject.sh present" "passed" "passed"
+
+  FIRST_LINE=$(head -1 "$INJECT_HOOK")
+  if echo "$FIRST_LINE" | grep -q '^#!/'; then
+    test_result "cbp-mcp-caller-worktree-inject.sh has shebang" "passed" "passed"
+  else
+    test_result "cbp-mcp-caller-worktree-inject.sh has shebang" "passed" "missing"
+  fi
+
+  if grep -q '@scope: org-shared' "$INJECT_HOOK"; then
+    test_result "cbp-mcp-caller-worktree-inject.sh has @scope: org-shared" "passed" "passed"
+  else
+    test_result "cbp-mcp-caller-worktree-inject.sh has @scope: org-shared" "passed" "missing"
+  fi
+
+  # Fail-open: run from a non-repo temp dir with no worktree cache and no
+  # CLAUDE_PROJECT_DIR — neither the cache nor the CLI fallback can resolve a
+  # worktree, so the hook must exit 0 with empty stdout (no updatedInput).
+  ISO=$(mktemp -d)
+  OUTPUT=$( (cd "$ISO" && env -u CLAUDE_PROJECT_DIR bash "$INJECT_HOOK_ABS" <<< '{"tool_input":{"task_id":"x"}}') 2>/dev/null )
+  EXIT_CODE=$?
+  if [ "$EXIT_CODE" = "0" ] && [ -z "$OUTPUT" ]; then
+    test_result "cbp-mcp-caller-worktree-inject.sh fail-open (unresolvable) exits 0 + empty stdout" "passed" "passed"
+  else
+    test_result "cbp-mcp-caller-worktree-inject.sh fail-open (unresolvable) exits 0 + empty stdout" "passed" "failed (exit=$EXIT_CODE)"
+  fi
+  rm -rf "$ISO"
+
+  # C6 — input already carries a non-empty caller_worktree_id → never overwrite;
+  # early-return with exit 0 and empty stdout (no resolution attempted).
+  OUTPUT=$(echo '{"tool_input":{"caller_worktree_id":"11111111-1111-1111-1111-111111111111"}}' | bash "$INJECT_HOOK" 2>/dev/null)
+  EXIT_CODE=$?
+  if [ "$EXIT_CODE" = "0" ] && [ -z "$OUTPUT" ]; then
+    test_result "cbp-mcp-caller-worktree-inject.sh C6 keeps existing caller_worktree_id (exit 0 + empty stdout)" "passed" "passed"
+  else
+    test_result "cbp-mcp-caller-worktree-inject.sh C6 keeps existing caller_worktree_id (exit 0 + empty stdout)" "passed" "failed (exit=$EXIT_CODE)"
+  fi
+
+  # Injection — a worktree.local.json whose .branch matches the current git branch
+  # makes the cache fast-path resolve. Use a synthetic UUID so the assertion proves
+  # the cache value (not the live CLI) was injected. Skipped when no concrete git
+  # branch resolves (detached HEAD / non-git checkout) or jq is unavailable.
+  CUR_BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null)
+  if [ -n "$CUR_BRANCH" ] && [ "$CUR_BRANCH" != "HEAD" ] && command -v jq >/dev/null 2>&1; then
+    ISO=$(mktemp -d)
+    mkdir -p "$ISO/.codebyplan"
+    FAKE_WT="abcdef01-2345-6789-abcd-ef0123456789"
+    jq -n --arg b "$CUR_BRANCH" --arg w "$FAKE_WT" \
+      '{worktree_id:$w, branch:$b}' > "$ISO/.codebyplan/worktree.local.json"
+    OUTPUT=$(CLAUDE_PROJECT_DIR="$ISO" bash "$INJECT_HOOK" <<< '{"tool_input":{"task_id":"x"}}' 2>/dev/null)
+    EXIT_CODE=$?
+    INJECTED=$(echo "$OUTPUT" | jq -r '.hookSpecificOutput.updatedInput.caller_worktree_id // empty' 2>/dev/null)
+    # Sibling-key survival — CC's updatedInput REPLACES tool_input wholesale (it is
+    # not a partial merge), so the hook must echo back every original field merged
+    # with caller_worktree_id. Assert the non-target sibling key (task_id) survives;
+    # this is the assertion gap that let the replace-vs-merge bug ship in round 2.
+    PRESERVED=$(echo "$OUTPUT" | jq -r '.hookSpecificOutput.updatedInput.task_id // empty' 2>/dev/null)
+    if [ "$EXIT_CODE" = "0" ] && [ "$INJECTED" = "$FAKE_WT" ] && [ "$PRESERVED" = "x" ]; then
+      test_result "cbp-mcp-caller-worktree-inject.sh injects caller_worktree_id AND preserves sibling keys" "passed" "passed"
+    else
+      test_result "cbp-mcp-caller-worktree-inject.sh injects caller_worktree_id AND preserves sibling keys" "passed" "failed (exit=$EXIT_CODE injected=$INJECTED preserved=$PRESERVED)"
+    fi
+    rm -rf "$ISO"
+  else
+    test_result "cbp-mcp-caller-worktree-inject.sh injection test (no branch resolvable — skipped)" "passed" "passed"
+  fi
+fi
+
+echo ""
+
 # ===== SUMMARY =====
 echo "=== TEST SUMMARY ==="
 echo -e "Passed: ${GREEN}$PASSED${NC}"

package/templates/hooks/hooks.json

@@ -45,6 +45,15 @@
             "command": "bash ${CLAUDE_PLUGIN_ROOT}/hooks/cbp-mcp-migration-guard.sh"
           }
         ]
+      },
+      {
+        "matcher": "mcp__codebyplan__(update_checkpoint|complete_checkpoint|update_task|complete_task|add_round|update_round|complete_round|create_standalone_task|update_standalone_task|complete_standalone_task|add_standalone_round|update_standalone_round|complete_standalone_round|update_standalone_file_change)",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ${CLAUDE_PLUGIN_ROOT}/hooks/cbp-mcp-caller-worktree-inject.sh"
+          }
+        ]
       }
     ],
     "PostToolUse": [

package/templates/skills/cbp-checkpoint-start/SKILL.md

@@ -57,7 +57,7 @@ This mirrors the CHK-104 hard-lock model — never wrest a checkpoint from a liv
 
 If the checkpoint is already `active` AND `worktree_id` already equals `CALLER_WT` (the Step 3 no-op row), skip this step entirely and proceed to Step 5 — nothing to write.
 
-Otherwise set the checkpoint `active` via MCP `update_checkpoint(checkpoint_id, status: "active"`, plus `worktree_id: CALLER_WT` when claiming per Step 3. The server resolves the caller's worktree identity from the JWT/ctx (CHK-140 TASK-3 — `caller_worktree_id` input field removed). If the checkpoint was already `active` but a claim is still needed, skip the status write and only write `worktree_id`.
+Otherwise set the checkpoint `active` via MCP `update_checkpoint(checkpoint_id, status: "active"`, plus `worktree_id: CALLER_WT` when claiming per Step 3. `caller_worktree_id` (CHK-140 TASK-7) identifies the calling worktree and is auto-injected by the `cbp-mcp-caller-worktree-inject.sh` PreToolUse hook (CHK-198 TASK-2); the server falls back to the repo `main` worktree only when it is absent. If the checkpoint was already `active` but a claim is still needed, skip the status write and only write `worktree_id`.
 
 ### Step 5: Route
 
@@ -78,7 +78,7 @@ Show a one-line confirmation before routing:
 ## Integration
 
 - **Reads**: MCP `get_checkpoints`, `get_tasks`; `npx codebyplan resolve-worktree`
-- **Writes**: MCP `update_checkpoint` (status + worktree_id; server resolves caller worktree from JWT/ctx)
+- **Writes**: MCP `update_checkpoint` (status + worktree_id; `caller_worktree_id` auto-injected by the cbp-mcp-caller-worktree-inject.sh hook, CHK-198 TASK-2; server falls back to repo `main` only when absent)
 - **Triggered by**: `/cbp-checkpoint-plan` (auto when claimed at create), `/cbp-todo` (planned-but-pending gate), or user directly
 - **Triggers**: `/cbp-task-start` (auto when claimed), or `/cbp-checkpoint-plan` (when the checkpoint is unplanned)
 - **Never**: plans or creates tasks — that is `/cbp-checkpoint-plan`

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

@@ -136,7 +136,7 @@ Skip the push only when nothing was committed in Step 5 AND `/cbp-merge-main` re
 
 ### Step 7: Complete Task
 
-Call `complete_task(task_id)`. The server resolves the caller's worktree identity from the JWT/ctx and enforces the mutate-lock (CHK-140 TASK-3 — `caller_worktree_id` input field removed). The server auto-clears `assigned_user_id` + `assigned_worktree_id` on the task; if this was the last sibling task, it also clears the parent checkpoint's assignment. (Per CHK-104 hard-lock.)
+Call `complete_task(task_id)`. `caller_worktree_id` (CHK-140 TASK-7) identifies the calling worktree and is auto-injected by the `cbp-mcp-caller-worktree-inject.sh` PreToolUse hook (CHK-198 TASK-2); the server falls back to the repo `main` worktree only when it is absent, then enforces the mutate-lock. The server auto-clears `assigned_user_id` + `assigned_worktree_id` on the task; if this was the last sibling task, it also clears the parent checkpoint's assignment. (Per CHK-104 hard-lock.)
 
 ### Step 8: Run Cleanup + Migration (inline)
 

package/templates/skills/cbp-task-start/SKILL.md

@@ -171,7 +171,7 @@ See `dependency-vulnerability-fixes.md` "Audit Sweep at Task Start" for the sour
 
 ### Step 3.5: Worktree-Match Verification
 
-Before activating the task, verify the caller's worktree matches the assigned worktree on the target row. (Per CHK-104 — DB-level hard-lock prevents cross-worktree mutations; the server resolves caller identity from the JWT/ctx.)
+Before activating the task, verify the caller's worktree matches the assigned worktree on the target row. (Per CHK-104 — DB-level hard-lock prevents cross-worktree mutations.)
 
 1. Read caller worktree: `CALLER_WT=$(npx codebyplan resolve-worktree 2>/dev/null)`.
 2. Determine target worktree:
@@ -232,7 +232,7 @@ Display context summary:
 
 Use MCP `update_task(task_id, status: "in_progress")`.
 
-If worktree_id present, include `claim_worktree_id` to auto-claim the checkpoint. The server resolves the caller's worktree identity from the JWT/ctx (CHK-140 TASK-3 — `caller_worktree_id` input field removed).
+If worktree_id present, include `claim_worktree_id` to auto-claim the checkpoint. `caller_worktree_id` (CHK-140 TASK-7) identifies the calling worktree and is auto-injected by the `cbp-mcp-caller-worktree-inject.sh` PreToolUse hook (CHK-198 TASK-2); the server falls back to the repo `main` worktree only when it is absent.
 
 ### Step 6: Auto-trigger Round Start