forge-workflow 0.0.7 → 0.0.9

package/scripts/forge-team/lib/workload.sh

@@ -77,15 +77,38 @@ _status_icon() {
   esac
 }
 
+_json_escape() {
+  local value="${1:-}"
+  value="${value//\\/\\\\}"
+  value="${value//\"/\\\"}"
+  value="${value//$'\n'/\\n}"
+  value="${value//$'\r'/\\r}"
+  value="${value//$'\t'/\\t}"
+  printf '%s' "$value"
+}
+
 # _collect_issues — Gather all open/in_progress issues with details
 # Outputs lines: id|title|status|owner|updated|depends_on
 _collect_issues() {
   local bd_cmd="${BD_CMD:-bd}"
   local list_output
-  list_output="$("$bd_cmd" list --status=open,in_progress 2>/dev/null)" || return 1
+  local combined_exit=0
+
+  # beads 0.62 rejects comma-separated status filters, so fall back to
+  # separate queries when the combined form fails.
+  list_output="$("$bd_cmd" list --status=open,in_progress 2>/dev/null)"
+  combined_exit=$?
+  if [[ "$combined_exit" -ne 0 ]]; then
+    list_output="$(
+      {
+        "$bd_cmd" list --status=open 2>/dev/null || true
+        "$bd_cmd" list --status=in_progress 2>/dev/null || true
+      } | awk 'NF && !seen[$0]++'
+    )"
+  fi
 
   # Filter empty lines
-  if [[ -z "$list_output" ]] || [[ -z "$(echo "$list_output" | tr -d '[:space:]')" ]]; then
+  if [[ -z "$list_output" ]] || [[ -z "$(printf '%s' "$list_output" | tr -d '[:space:]')" ]]; then
     return 0
   fi
 
@@ -95,7 +118,7 @@ _collect_issues() {
 
     # Extract issue id: first field like "forge-xxx" after optional icon
     local issue_id
-    issue_id="$(echo "$line" | grep -oE 'forge-[a-zA-Z0-9]+' | head -1)"
+    issue_id="$(echo "$line" | grep -oE 'forge-[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)*' | head -1)"
     [[ -z "$issue_id" ]] && continue
 
     # Get details via bd show
@@ -141,9 +164,10 @@ cmd_workload() {
 
   # Parse arguments
   while [[ $# -gt 0 ]]; do
-    case "$1" in
+    local arg="${1%$'\r'}"
+    case "$arg" in
       --developer=*)
-        filter_developer="${1#--developer=}"
+        filter_developer="${arg#--developer=}"
         shift
         ;;
       --me)
@@ -160,11 +184,11 @@ cmd_workload() {
         shift
         ;;
       --format=*)
-        _workload_error "Unsupported format: ${1#--format=}"
+        _workload_error "Unsupported format: ${arg#--format=}"
         return 1
         ;;
       *)
-        _workload_error "Unknown argument: $1"
+        _workload_error "Unknown argument: $arg"
         return 1
         ;;
     esac
@@ -232,16 +256,13 @@ cmd_workload() {
       [[ -n "$stale_flag" ]] && stale_bool="true"
       local blocked_ids=""
       [[ -n "$depends_on" ]] && blocked_ids="$depends_on"
-
-      # Use jq to build safe JSON
-      jq -n -c \
-        --arg id "$issue_id" \
-        --arg title "$title" \
-        --arg status "$status" \
-        --arg updated "$updated" \
-        --argjson stale "$stale_bool" \
-        --arg blocked_by "$blocked_ids" \
-        '{id: $id, title: $title, status: $status, updated: $updated, stale: $stale, blocked_by: $blocked_by}' \
+      printf '{"id":"%s","title":"%s","status":"%s","updated":"%s","stale":%s,"blocked_by":"%s"}\n' \
+        "$(_json_escape "$issue_id")" \
+        "$(_json_escape "$title")" \
+        "$(_json_escape "$status")" \
+        "$(_json_escape "$updated")" \
+        "$stale_bool" \
+        "$(_json_escape "$blocked_ids")" \
         >> "$work_dir/json/${owner}"
     fi
   done <<< "$issues_data"
@@ -260,22 +281,30 @@ cmd_workload() {
   # Output
   if [[ "$format" == "json" ]]; then
     # Build JSON object: { "devone": [...], "devtwo": [...] }
-    local json_result="{"
-    local first=true
+    local first_dev="true"
+    printf '{'
     for dev_file in "$work_dir/json"/*; do
       local dev_name
       dev_name="$(basename "$dev_file")"
-      local issues_array
-      issues_array="$(jq -s '.' "$dev_file")"
-      if [[ "$first" == "true" ]]; then
-        first=false
+      local first_issue="true"
+      if [[ "$first_dev" == "true" ]]; then
+        first_dev="false"
       else
-        json_result+=","
+        printf ','
       fi
-      json_result+="$(jq -n -c --arg dev "$dev_name" --argjson issues "$issues_array" '{($dev): $issues}' | sed 's/^{//' | sed 's/}$//')"
+      printf '"%s":[' "$(_json_escape "$dev_name")"
+      while IFS= read -r issue_json; do
+        [[ -z "$issue_json" ]] && continue
+        if [[ "$first_issue" == "true" ]]; then
+          first_issue="false"
+        else
+          printf ','
+        fi
+        printf '%s' "$issue_json"
+      done < "$dev_file"
+      printf ']'
     done
-    json_result+="}"
-    echo "$json_result"
+    printf '}\n'
   else
     local first_dev=true
     for dev_file in "$work_dir/devs"/*; do

package/scripts/forge-team/tests/workload.test.sh

@@ -32,9 +32,15 @@ cat > "$mock_dir/bd" << 'MOCK'
 #!/usr/bin/env bash
 case "$1 $2" in
   "list --status=open,in_progress")
-    echo "◐ forge-aaa · Feature A"
+    exit 1
+    ;;
+  "list --status=open")
     echo "○ forge-bbb · Feature B"
+    ;;
+  "list --status=in_progress")
+    echo "◐ forge-aaa · Feature A"
     echo "◐ forge-ccc · Feature C"
+    echo "◐ forge-m1n8.6 · Sub-feature X (dotted ID)"
     ;;
   "show forge-aaa")
     echo "◐ forge-aaa · Feature A [● P2 · IN_PROGRESS]"
@@ -54,6 +60,19 @@ case "$1 $2" in
     echo "DEPENDS ON"
     echo "  → forge-aaa: Feature A"
     ;;
+  "show forge-m1n8.6")
+    # Dotted sub-ID — bd show must receive the full ID including .6
+    echo "◐ forge-m1n8.6 · Sub-feature X [● P2 · IN_PROGRESS]"
+    echo "Owner: devthree"
+    echo "Updated: 2026-03-27T08:00:00Z"
+    ;;
+  "show forge-m1n8")
+    # Parent epic — if a buggy parser truncates forge-m1n8.6 to forge-m1n8,
+    # the workload would get this WRONG owner and trigger the guard below.
+    echo "◐ forge-m1n8 · PARENT EPIC (WRONG — dotted ID was truncated)"
+    echo "Owner: WRONG_OWNER_DO_NOT_USE"
+    echo "Updated: 2026-03-20T10:00:00Z"
+    ;;
 esac
 MOCK
 chmod +x "$mock_dir/bd"
@@ -65,6 +84,12 @@ case "$1 $2" in
   "list --status=open,in_progress")
     echo ""
     ;;
+  "list --status=open")
+    echo "○ forge-should-not-appear · Open fallback sentinel"
+    ;;
+  "list --status=in_progress")
+    echo "◐ forge-should-not-appear-2 · In-progress fallback sentinel"
+    ;;
 esac
 MOCK
 chmod +x "$mock_dir/bd-empty"
@@ -125,6 +150,11 @@ assert_contains "shows devtwo header" "Developer: devtwo" "$output"
 assert_contains "shows forge-aaa" "forge-aaa" "$output"
 assert_contains "shows forge-bbb" "forge-bbb" "$output"
 assert_contains "shows forge-ccc" "forge-ccc" "$output"
+# Dotted ID regression (forge-hpev): the full forge-m1n8.6 must be extracted,
+# not truncated to forge-m1n8. devthree owns the sub-issue, not WRONG_OWNER.
+assert_contains "shows devthree (dotted ID owner)" "Developer: devthree" "$output"
+assert_contains "shows dotted ID forge-m1n8.6 in full" "forge-m1n8.6" "$output"
+assert_not_contains "does NOT attribute to WRONG_OWNER (parent epic)" "WRONG_OWNER" "$output"
 
 # ── Test 2: --developer=devone filters correctly ─────────────────────────
 echo ""
@@ -158,6 +188,7 @@ rc=0
 output="$(cmd_workload 2>/dev/null)" || rc=$?
 assert_exit "exits 0" 0 "$rc"
 assert_contains "shows no active work message" "No active work" "$output"
+assert_not_contains "does not fall back when combined query succeeds with no issues" "forge-should-not-appear" "$output"
 export BD_CMD="$mock_dir/bd"
 
 # ── Test 5: Stale assignment flagged (>48h) ──────────────────────────────
@@ -178,18 +209,18 @@ rc=0
 output="$(cmd_workload --format=json 2>/dev/null)" || rc=$?
 assert_exit "exits 0" 0 "$rc"
 # Validate it's parseable JSON
-if echo "$output" | jq . >/dev/null 2>&1; then
+if echo "$output" | node -e 'JSON.parse(require("fs").readFileSync(0, "utf8"));' >/dev/null 2>&1; then
   PASS=$((PASS + 1)); echo "  PASS: output is valid JSON"
 else
   FAIL=$((FAIL + 1)); echo "  FAIL: output is not valid JSON: $output"
 fi
 # Check JSON has developer keys
-if echo "$output" | jq -e '.devone' >/dev/null 2>&1; then
+if echo "$output" | node -e 'const data = JSON.parse(require("fs").readFileSync(0, "utf8")); process.exit(data.devone ? 0 : 1);' >/dev/null 2>&1; then
   PASS=$((PASS + 1)); echo "  PASS: JSON contains devone key"
 else
   FAIL=$((FAIL + 1)); echo "  FAIL: JSON missing devone key"
 fi
-if echo "$output" | jq -e '.devtwo' >/dev/null 2>&1; then
+if echo "$output" | node -e 'const data = JSON.parse(require("fs").readFileSync(0, "utf8")); process.exit(data.devtwo ? 0 : 1);' >/dev/null 2>&1; then
   PASS=$((PASS + 1)); echo "  PASS: JSON contains devtwo key"
 else
   FAIL=$((FAIL + 1)); echo "  FAIL: JSON missing devtwo key"

package/scripts/github-beads-sync/run-bd.mjs

@@ -79,10 +79,12 @@ export function buildSearchArgs(query) {
  * @returns {string|null}
  */
 export function parseCreateOutput(stdout) {
-  const match = stdout.match(/Created issue:\s+(forge-[\w-]+)/);
+  // Match forge-xxx with optional dotted sub-IDs (e.g. forge-m1n8.6, forge-dq8j.1).
+  // \w in JS doesn't include '.', so the dotted sub-ID group is explicit.
+  const match = stdout.match(/Created issue:\s+(forge-[a-zA-Z0-9]+(?:\.[a-zA-Z0-9]+)*)/);
   if (match) return match[1];
   // Fallback: loose match for any forge-prefixed ID anywhere in output
-  const fallback = stdout.match(/(forge-[a-z0-9]+)/i);
+  const fallback = stdout.match(/(forge-[a-zA-Z0-9]+(?:\.[a-zA-Z0-9]+)*)/);
   return fallback ? fallback[1] : null;
 }
 

package/scripts/lib/eval-runner.js

@@ -9,6 +9,7 @@
  */
 
 const path = require('path');
+const fs = require('fs');
 const { execSync } = require('node:child_process');
 
 // ── active worktree tracking (cleanup on crash) ─────────────────────
@@ -17,6 +18,17 @@ const { execSync } = require('node:child_process');
 // Note: execSync is safe here — all paths are internally generated, never user input.
 const activeEvalWorktrees = new Map(); // path -> branch
 
+/**
+ * Force-remove a directory that git worktree remove may leave behind (Windows).
+ */
+function forceRemoveDir(dirPath) {
+  try {
+    if (fs.existsSync(dirPath)) {
+      fs.rmSync(dirPath, { recursive: true, force: true });
+    }
+  } catch (_err) { /* best-effort */ }
+}
+
 function cleanupActiveWorktrees() {
   if (activeEvalWorktrees.size === 0) return;
   let repoRoot;
@@ -25,6 +37,7 @@ function cleanupActiveWorktrees() {
     try {
       execSync(`git worktree remove --force "${wtPath}"`, { cwd: repoRoot, stdio: 'pipe' });
     } catch (_err) { /* already removed */ }
+    forceRemoveDir(wtPath);
     if (branch && branch.startsWith('eval-')) {
       try {
         execSync(`git branch -D "${branch}"`, { cwd: repoRoot, stdio: 'pipe' });
@@ -35,6 +48,37 @@ function cleanupActiveWorktrees() {
   activeEvalWorktrees.clear();
 }
 
+/**
+ * Remove stale eval-* directories left behind by crashed runs.
+ * Git has already forgotten them (worktree prune), but the directories persist on Windows.
+ */
+function cleanupStaleEvalWorktrees() {
+  try {
+    const worktreesDir = getWorktreesDir();
+    if (!fs.existsSync(worktreesDir)) return;
+
+    // Get the list of paths git still knows about
+    const repoRoot = getRepoRoot();
+    const knownRaw = execSync('git worktree list --porcelain', {
+      cwd: repoRoot, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    const knownPaths = new Set(
+      knownRaw.split('\n')
+        .filter((l) => l.startsWith('worktree '))
+        .map((l) => l.slice('worktree '.length).replace(/\\/g, '/'))
+    );
+
+    const entries = fs.readdirSync(worktreesDir);
+    for (const entry of entries) {
+      if (!entry.startsWith('eval-')) continue;
+      const fullPath = path.join(worktreesDir, entry).replace(/\\/g, '/');
+      if (!knownPaths.has(fullPath)) {
+        forceRemoveDir(path.join(worktreesDir, entry));
+      }
+    }
+  } catch (_err) { /* best-effort — don't block eval creation */ }
+}
+
 process.on('exit', cleanupActiveWorktrees);
 process.on('SIGINT', () => {
   const hadWork = activeEvalWorktrees.size > 0;
@@ -78,6 +122,9 @@ function getWorktreesDir() {
  * @returns {Promise<{ path: string, branch: string }>}
  */
 async function createEvalWorktree() {
+  // Self-heal: remove stale eval dirs from previous crashed runs
+  cleanupStaleEvalWorktrees();
+
   const timestamp = Date.now();
   const pid = process.pid;
   const name = `eval-${timestamp}-${pid}`;
@@ -128,6 +175,9 @@ async function destroyEvalWorktree(worktreePath) {
     stdio: ['pipe', 'pipe', 'pipe'],
   });
 
+  // Windows: git worktree remove often leaves the directory behind
+  forceRemoveDir(worktreePath);
+
   // Prune to clean up references
   execSync('git worktree prune', {
     cwd: repoRoot,

package/scripts/smart-status.sh

@@ -68,7 +68,9 @@ if ! command -v jq &>/dev/null; then
 fi
 
 # Warn if jq < 1.6 (fromdateiso8601 and sub/2 require 1.6+)
-_jq_version="$(jq --version 2>/dev/null | sed 's/jq-//')" || true
+# Strip CR here as well because Windows jq.exe (or a CRLF-emitting wrapper in
+# tests) can affect the version probe before the jq() shim is defined below.
+_jq_version="$(command jq --version 2>/dev/null | tr -d '\r' | sed 's/jq-//')" || true
 if [ -n "$_jq_version" ]; then
   _jq_major="${_jq_version%%.*}"
   _jq_minor="${_jq_version#*.}"; _jq_minor="${_jq_minor%%.*}"
@@ -77,6 +79,13 @@ if [ -n "$_jq_version" ]; then
   fi
 fi
 
+# On Windows/WSL we may be invoking jq.exe, which emits CRLF and breaks
+# numeric comparisons like `[ "$count" -gt 0 ]`. Strip trailing CRs from
+# all jq output after the dependency/version checks above.
+jq() {
+  command jq "$@" | tr -d '\r'
+}
+
 # ── Configuration ───────────────────────────────────────────────────────
 
 BD="${BD_CMD:-bd}"

package/scripts/sync-utils.sh

@@ -271,16 +271,55 @@ _run_sync() {
   fi
 }
 
+_has_dolt_remote() {
+  local remote_name="${1:-origin}"
+  local remote_list=""
+  local raw_output=""
+  local bd_cmd="${BD_CMD:-bd}"
+  local remote_status=0
+
+  if ! command -v "$bd_cmd" >/dev/null 2>&1; then
+    return 2
+  fi
+
+  raw_output="$("$bd_cmd" dolt remote list 2>/dev/null)"
+  remote_status=$?
+  if [[ "$remote_status" -ne 0 ]]; then
+    return 2
+  fi
+  remote_list="$(printf '%s' "$raw_output" | tr -d '\r')"
+
+  if [[ -z "$remote_list" ]]; then
+    return 1
+  fi
+
+  printf '%s\n' "$remote_list" | awk 'NF { print $1 }' | grep -Fqx -- "$remote_name"
+}
+
 # Environment overrides (for testing):
 #   BD_SYNC_CMD — single command to run instead of default pull+push (e.g. "echo mock-sync")
 #   FILE_INDEX_ROOT — root directory for file-index.sh (default: repo_dir)
 auto_sync() {
   local repo_dir="${1:-.}"
   local last_sync_file="$repo_dir/.beads/.last-sync"
+  local sync_remote
+  sync_remote="$(get_sync_remote "$repo_dir")"
 
   # Ensure .beads directory exists
   mkdir -p "$repo_dir/.beads"
 
+  if _has_dolt_remote "$sync_remote"; then
+    :
+  else
+    local remote_status=$?
+    if [[ "$remote_status" -eq 2 ]]; then
+      echo "Warning: sync skipped, unable to inspect Beads Dolt remotes (is 'bd' installed and configured?)." >&2
+    else
+      echo "Warning: sync skipped, Beads Dolt remote '$sync_remote' is not configured (run 'bd dolt remote add $sync_remote <url>')." >&2
+    fi
+    return 0
+  fi
+
   # Run sync — helper function avoids eval while supporting compound default
   if _run_sync >/dev/null 2>&1; then
     # Success: record timestamp

package/scripts/test.js

@@ -1,17 +1,29 @@
 #!/usr/bin/env node
 /**
- * Cross-platform test runner for lefthook pre-push hook.
- * Replaces bash-only: bun/pnpm/yarn/npm test detection with if/elif.
- * Works on Windows CMD, PowerShell, macOS, Linux.
+ * Cross-platform test runner for the lefthook pre-push hook.
+ *
+ * Runs only the tests affected by the changes being pushed when possible.
+ * Falls back to the full suite only for package-level changes.
  */
 
-const { spawnSync } = require('node:child_process');
+const { execFileSync: defaultExecFileSync, spawnSync: defaultSpawnSync } = require('node:child_process');
 const fs = require('node:fs');
 
-// On Windows, package manager CLIs are .cmd files — shell: true resolves them
+const {
+  getAffectedTestFiles,
+  getChangedFiles,
+} = require('../lib/commands/test');
+
+const PACKAGE_LEVEL_PATHS = new Set([
+  'package.json',
+  'bun.lockb',
+  'pnpm-lock.yaml',
+  'yarn.lock',
+  'package-lock.json',
+]);
+
 const isWindows = process.platform === 'win32';
 
-// Detect package manager from lock files (same priority as forge.js)
 function detectPackageManager() {
   if (fs.existsSync('bun.lockb') || fs.existsSync('bun.lock')) return 'bun';
   if (fs.existsSync('pnpm-lock.yaml')) return 'pnpm';
@@ -19,43 +31,137 @@ function detectPackageManager() {
   return 'npm';
 }
 
-const pkgManager = detectPackageManager();
-console.log(`🧪 Running test suite (${pkgManager} test)...`);
-
-// Strip git hook environment variables so child processes (especially tests
-// that create temp git repos) never accidentally operate on the real worktree.
-// During pre-push hooks, git sets GIT_DIR pointing to the repo — any test that
-// runs `git init` / `git commit` in a temp dir inherits this and silently
-// commits into the worktree instead, creating rogue "initial commit" that
-// deletes the entire codebase.
-const env = { ...process.env };
-for (const key of Object.keys(env)) {
-  if (key === 'GIT_DIR' || key === 'GIT_WORK_TREE' || key === 'GIT_INDEX_FILE'
-    || key === 'GIT_OBJECT_DIRECTORY' || key === 'GIT_ALTERNATE_OBJECT_DIRECTORIES'
-    || key === 'GIT_QUARANTINE_PATH') {
-    delete env[key];
+function stripGitHookEnv(sourceEnv = process.env) {
+  const env = { ...sourceEnv };
+  for (const key of Object.keys(env)) {
+    if (key === 'GIT_DIR' || key === 'GIT_WORK_TREE' || key === 'GIT_INDEX_FILE'
+      || key === 'GIT_OBJECT_DIRECTORY' || key === 'GIT_ALTERNATE_OBJECT_DIRECTORIES'
+      || key === 'GIT_QUARANTINE_PATH') {
+      delete env[key];
+    }
   }
+  return env;
 }
 
-// Use 'run test' to invoke the package.json script (which may include --timeout flags)
-// 'bun test' is a built-in that ignores package.json scripts
-const result = spawnSync(pkgManager, ['run', 'test'], { stdio: 'inherit', shell: isWindows, env });
+function classifyPushTests(projectRoot, execFileSync = defaultExecFileSync) {
+  const changedFiles = getChangedFiles(execFileSync, { sinceUpstream: true });
+  const testTargets = getAffectedTestFiles(projectRoot, execFileSync, fs, { sinceUpstream: true });
+
+  let runFullSuite = false;
+  let runTestEnv = false;
+  let runE2E = false;
+  let hasUnmappedFiles = false;
+  const hasUnknownChangedFiles = changedFiles.length === 0 && testTargets.length === 0;
+
+  for (const file of changedFiles) {
+    if (PACKAGE_LEVEL_PATHS.has(file) || file.startsWith('packages/')) {
+      runFullSuite = true;
+      runTestEnv = true;
+      runE2E = true;
+      break;
+    }
+
+    if (file.startsWith('test-env/')) {
+      runTestEnv = true;
+      continue;
+    }
+
+    if (file.startsWith('test/e2e/')) {
+      runE2E = true;
+      continue;
+    }
+
+    if ((file.startsWith('lib/') || file.startsWith('scripts/')) && file.endsWith('.js')) {
+      runTestEnv = true;
+      continue;
+    }
+
+    if (file.startsWith('test/') || file.startsWith('.github/workflows/') || file.startsWith('.claude/commands/')) {
+      continue;
+    }
+
+    hasUnmappedFiles = true;
+  }
+
+  return {
+    changedFiles,
+    hasUnmappedFiles,
+    hasUnknownChangedFiles,
+    runE2E,
+    runFullSuite: runFullSuite || hasUnmappedFiles || hasUnknownChangedFiles,
+    runTestEnv,
+    testTargets,
+  };
+}
 
-if (result.error) {
-  console.error('');
-  console.error(`❌ Failed to run ${pkgManager} test: ${result.error.message}`);
-  console.error(`   Is '${pkgManager}' installed and on PATH?`);
-  console.error('');
-  process.exit(1);
+function runCommand(command, args, options = {}, spawnSync = defaultSpawnSync) {
+  const result = spawnSync(command, args, {
+    stdio: 'inherit',
+    shell: isWindows,
+    ...options,
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  return result.status ?? 1;
+}
+
+function runPrePushTests(projectRoot = process.cwd(), deps = {}) {
+  const spawnSync = deps.spawnSync || defaultSpawnSync;
+  const execFileSync = deps.execFileSync || defaultExecFileSync;
+  const pkgManager = deps.pkgManager || detectPackageManager();
+  const env = deps.env || stripGitHookEnv(process.env);
+  const plan = classifyPushTests(projectRoot, execFileSync);
+
+  console.log(`Running pre-push tests (${pkgManager})...`);
+
+  try {
+    if (plan.runFullSuite) {
+      const reason = plan.hasUnmappedFiles
+        ? 'unmapped pushed files require full unit coverage'
+        : plan.hasUnknownChangedFiles
+          ? 'changed files could not be resolved safely'
+          : 'package-level changes detected';
+      console.log(`  Mode: full suite (${reason})`);
+      const status = runCommand(pkgManager, ['run', 'test'], { env }, spawnSync);
+      if (status !== 0) return status;
+    } else if (plan.testTargets.length > 0) {
+      console.log(`  Mode: targeted (${plan.testTargets.length} test file${plan.testTargets.length === 1 ? '' : 's'})`);
+      const status = runCommand(pkgManager, ['run', 'test', ...plan.testTargets], { env }, spawnSync);
+      if (status !== 0) return status;
+    }
+
+    if (plan.runE2E) {
+      console.log('  Extra: running affected e2e tests');
+      const status = runCommand('bun', ['test', 'test/e2e/'], { env }, spawnSync);
+      if (status !== 0) return status;
+    }
+
+    if (plan.runTestEnv) {
+      console.log('  Extra: running affected edge-case tests');
+      const status = runCommand('bun', ['test', 'test-env/'], { env }, spawnSync);
+      if (status !== 0) return status;
+    }
+
+    console.log('Relevant tests passed');
+    return 0;
+  } catch (error) {
+    console.error('');
+    console.error(`Failed to run tests: ${error.message}`);
+    console.error('');
+    return 1;
+  }
 }
 
-if (result.status !== 0) {
-  console.error('');
-  console.error('❌ Tests failed. Fix them before pushing.');
-  console.error('');
-  console.error('Fix the failing checks. Do not bypass hooks.');
-  console.error('');
-  process.exit(1);
+if (require.main === module) {
+  process.exit(runPrePushTests());
 }
 
-console.log('✅ All tests passed');
+module.exports = {
+  classifyPushTests,
+  detectPackageManager,
+  runPrePushTests,
+  stripGitHookEnv,
+};