@lovehlmmm/primekit 1.0.0

package/skills/worktree/scripts/worktree.test.cjs

@@ -0,0 +1,1127 @@
+#!/usr/bin/env node
+/**
+ * Test suite for worktree.cjs
+ * Run: node .claude/skills/ak-worktree/scripts/worktree.test.cjs
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const SCRIPT_PATH = path.join(__dirname, 'worktree.cjs');
+const STANDALONE_DIR = path.dirname(path.dirname(__dirname)); // worktree dir
+const MONOREPO_DIR = process.env.MONOREPO_DIR || '/path/to/claudekit';
+const CURRENT_GIT_ROOT = execSync('git rev-parse --show-toplevel', {
+  encoding: 'utf-8',
+  cwd: STANDALONE_DIR,
+  stdio: ['pipe', 'pipe', 'pipe']
+}).trim();
+
+let passed = 0;
+let failed = 0;
+const results = [];
+
+// Test helper
+function run(args, options = {}) {
+  const cwd = options.cwd || STANDALONE_DIR;
+  try {
+    const output = execSync(`node "${SCRIPT_PATH}" ${args}`, {
+      encoding: 'utf-8',
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    return { success: true, output: output.trim(), exitCode: 0 };
+  } catch (error) {
+    return {
+      success: false,
+      output: error.stdout?.toString().trim() || '',
+      stderr: error.stderr?.toString().trim() || '',
+      exitCode: error.status || 1
+    };
+  }
+}
+
+function test(name, fn) {
+  try {
+    fn();
+    passed++;
+    results.push({ name, status: 'PASS' });
+    console.log(`  ✓ ${name}`);
+  } catch (error) {
+    failed++;
+    results.push({ name, status: 'FAIL', error: error.message });
+    console.log(`  ✗ ${name}`);
+    console.log(`    Error: ${error.message}`);
+  }
+}
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message || 'Assertion failed');
+}
+
+function assertJSON(str) {
+  try {
+    return JSON.parse(str);
+  } catch {
+    throw new Error(`Invalid JSON: ${str.slice(0, 100)}...`);
+  }
+}
+
+// Isolated fixtures for worktree.root config precedence tests: a throwaway
+// git repo (never the real agentkit repo) plus a throwaway HOME, so these
+// tests can freely write .agentkit/config.yaml without touching real state.
+function mkTempGitRepo() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ak-wt-test-repo-'));
+  execSync('git init -q', { cwd: dir, stdio: ['pipe', 'pipe', 'pipe'] });
+  return dir;
+}
+
+function mkTempHome() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'ak-wt-test-home-'));
+}
+
+function writeWorktreeRootConfig(dir, root) {
+  fs.mkdirSync(path.join(dir, '.agentkit'), { recursive: true });
+  fs.writeFileSync(path.join(dir, '.agentkit', 'config.yaml'), `worktree:\n  root: ${root}\n`);
+}
+
+function runInRepo(repoDir, homeDir, args) {
+  try {
+    const output = execSync(`node "${SCRIPT_PATH}" ${args}`, {
+      encoding: 'utf-8',
+      cwd: repoDir,
+      env: { ...process.env, HOME: homeDir, USERPROFILE: homeDir },
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    return { success: true, output: output.trim() };
+  } catch (error) {
+    return {
+      success: false,
+      output: error.stdout?.toString().trim() || '',
+      stderr: error.stderr?.toString().trim() || ''
+    };
+  }
+}
+
+// ============================================
+// INFO COMMAND TESTS
+// ============================================
+console.log('\n📋 INFO Command Tests');
+
+test('info returns valid JSON', () => {
+  const result = run('info --json');
+  assert(result.success, 'Command should succeed');
+  const json = assertJSON(result.output);
+  assert(json.info === true, 'Should have info: true');
+});
+
+test('info detects repo type', () => {
+  const result = run('info --json');
+  const json = assertJSON(result.output);
+  assert(['standalone', 'monorepo'].includes(json.repoType), 'Should detect repo type');
+});
+
+test('info detects base branch', () => {
+  const result = run('info --json');
+  const json = assertJSON(result.output);
+  assert(json.baseBranch, 'Should detect base branch');
+  assert(['dev', 'develop', 'main', 'master'].includes(json.baseBranch), 'Should be valid branch');
+});
+
+test('info finds env files', () => {
+  const result = run('info --json');
+  const json = assertJSON(result.output);
+  assert(Array.isArray(json.envFiles), 'Should have envFiles array');
+});
+
+test('info detects dirty state', () => {
+  const result = run('info --json');
+  const json = assertJSON(result.output);
+  assert(typeof json.dirtyState === 'boolean', 'Should have dirtyState boolean');
+});
+
+test('info detects monorepo from monorepo root', () => {
+  if (!fs.existsSync(MONOREPO_DIR)) return; // Skip if not available
+  const result = run('info --json', { cwd: MONOREPO_DIR });
+  const json = assertJSON(result.output);
+  assert(json.repoType === 'monorepo', 'Should detect monorepo');
+  assert(json.projects.length > 0, 'Should have projects');
+});
+
+test('monorepo uses internal worktrees directory', () => {
+  if (!fs.existsSync(MONOREPO_DIR)) return; // Skip if not available
+  const result = run('info --json', { cwd: MONOREPO_DIR });
+  const json = assertJSON(result.output);
+  // Monorepo should use worktrees/ inside the repo, not sibling
+  assert(json.worktreeRoot === path.join(MONOREPO_DIR, 'worktrees'),
+    `Expected ${path.join(MONOREPO_DIR, 'worktrees')}, got ${json.worktreeRoot}`);
+  assert(json.worktreeRootSource === 'monorepo internal',
+    `Expected 'monorepo internal', got ${json.worktreeRootSource}`);
+});
+
+test('info returns text output without --json', () => {
+  const result = run('info');
+  assert(result.success, 'Command should succeed');
+  assert(result.output.includes('Repository Info'), 'Should have text output');
+});
+
+// ============================================
+// LIST COMMAND TESTS
+// ============================================
+console.log('\n📂 LIST Command Tests');
+
+test('list returns valid JSON', () => {
+  const result = run('list --json');
+  assert(result.success, 'Command should succeed');
+  const json = assertJSON(result.output);
+  assert(json.success === true, 'Should have success: true');
+  assert(Array.isArray(json.worktrees), 'Should have worktrees array');
+});
+
+test('list worktrees have required fields', () => {
+  const result = run('list --json');
+  const json = assertJSON(result.output);
+  if (json.worktrees.length > 0) {
+    const wt = json.worktrees[0];
+    assert(wt.path, 'Worktree should have path');
+    assert(wt.commit, 'Worktree should have commit');
+    assert(wt.branch, 'Worktree should have branch');
+  }
+});
+
+test('list returns text output without --json', () => {
+  const result = run('list');
+  assert(result.success, 'Command should succeed');
+  assert(result.output.includes('worktrees'), 'Should have text output');
+});
+
+// ============================================
+// STATUS COMMAND TESTS
+// ============================================
+console.log('\n🩺 STATUS Command Tests');
+
+test('status returns valid JSON', () => {
+  const result = run('status --json');
+  assert(result.success, 'Command should succeed');
+  const json = assertJSON(result.output);
+  assert(json.success === true, 'Should have success: true');
+  assert(json.currentWorktree, 'Should include currentWorktree');
+  assert(Array.isArray(json.worktrees), 'Should include worktrees array');
+});
+
+test('status reports current worktree health fields', () => {
+  const result = run('status --json');
+  const json = assertJSON(result.output);
+  const current = json.currentWorktree;
+  assert(current.path === CURRENT_GIT_ROOT, `Should normalize current path to ${CURRENT_GIT_ROOT}`);
+  assert(typeof current.isCurrentWorktree === 'boolean', 'Should flag current worktree');
+  assert(typeof current.isMainWorktree === 'boolean', 'Should flag main worktree');
+  assert(typeof current.branchExists === 'boolean', 'Should report branch existence');
+  assert(typeof current.dirtyState === 'boolean', 'Should report dirty state');
+  assert(typeof current.ahead === 'number', 'Should report ahead count');
+  assert(typeof current.behind === 'number', 'Should report behind count');
+});
+
+test('status includes normalized path entry for current worktree', () => {
+  const result = run('status --json');
+  const json = assertJSON(result.output);
+  assert(json.worktrees.some(w => w.path === CURRENT_GIT_ROOT), 'Should include normalized current worktree path');
+});
+
+test('status returns text output without --json', () => {
+  const result = run('status');
+  assert(result.success, 'Command should succeed');
+  assert(result.output.includes('Worktree Status'), 'Should have text output');
+});
+
+// ============================================
+// CREATE COMMAND TESTS
+// ============================================
+console.log('\n🆕 CREATE Command Tests');
+
+test('create requires feature name', () => {
+  const result = run('create --json');
+  assert(!result.success, 'Should fail without feature');
+  const json = assertJSON(result.output);
+  assert(json.error.code === 'MISSING_FEATURE', 'Should have MISSING_FEATURE error');
+});
+
+test('create dry-run does not create worktree', () => {
+  const result = run('create test-dry-run --prefix feat --dry-run --json');
+  assert(result.success, 'Dry-run should succeed');
+  const json = assertJSON(result.output);
+  assert(json.dryRun === true, 'Should have dryRun: true');
+  assert(json.wouldCreate, 'Should have wouldCreate object');
+});
+
+test('create dry-run shows correct branch name', () => {
+  const result = run('create my-feature --prefix fix --dry-run --json');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.branch === 'fix/my-feature', 'Branch should be fix/my-feature');
+});
+
+test('create sanitizes feature name - spaces', () => {
+  const result = run('create "my cool feature" --dry-run --json');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.branch.includes('my-cool-feature'), 'Should sanitize spaces');
+});
+
+test('create sanitizes feature name - uppercase', () => {
+  const result = run('create "MyFeature" --dry-run --json');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.branch.includes('myfeature'), 'Should lowercase');
+});
+
+test('create sanitizes feature name - special chars', () => {
+  const result = run('create "feat@#$test" --dry-run --json');
+  const json = assertJSON(result.output);
+  assert(!json.wouldCreate.branch.includes('@'), 'Should remove special chars');
+});
+
+test('create respects --prefix flag', () => {
+  const prefixes = ['feat', 'fix', 'docs', 'refactor', 'test', 'chore', 'perf'];
+  for (const prefix of prefixes) {
+    const result = run(`create test-${prefix} --prefix ${prefix} --dry-run --json`);
+    const json = assertJSON(result.output);
+    assert(json.wouldCreate.branch.startsWith(`${prefix}/`), `Should use ${prefix} prefix`);
+  }
+});
+
+test('create shows base branch', () => {
+  const result = run('create test-base --dry-run --json');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.baseBranch, 'Should show base branch');
+});
+
+test('create shows worktree path', () => {
+  const result = run('create test-path --dry-run --json');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.worktreePath, 'Should show worktree path');
+  assert(json.wouldCreate.worktreePath.includes('worktrees'), 'Path should include worktrees dir');
+});
+
+test('create dry-run surfaces checkout-submodules flag', () => {
+  const result = run('create test-submodules --dry-run --json --checkout-submodules');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.checkoutSubmodules === true, 'Should show checkoutSubmodules flag');
+});
+
+test('create dry-run shows explicit base branch source', () => {
+  const result = run('create test-explicit-base --dry-run --json --base dev');
+  assert(result.success, 'Should succeed with explicit base');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.baseBranch === 'dev', 'Should use explicit base branch');
+  assert(json.wouldCreate.baseBranchSource === 'explicit', 'Should mark baseBranchSource as explicit');
+});
+
+test('create rejects invalid explicit base branch input', () => {
+  const result = run('create test-invalid-base --json --base "--oops"');
+  assert(!result.success, 'Should fail with invalid base branch');
+  const json = assertJSON(result.output);
+  assert(json.error.code === 'INVALID_BASE_BRANCH', 'Should report INVALID_BASE_BRANCH');
+});
+
+test('create rejects nonexistent explicit base branch', () => {
+  const result = run('create test-missing-base --json --base branch-that-should-not-exist-xyz');
+  assert(!result.success, 'Should fail with nonexistent base branch');
+  const json = assertJSON(result.output);
+  assert(json.error.code === 'BASE_BRANCH_NOT_FOUND', 'Should report BASE_BRANCH_NOT_FOUND');
+});
+
+test('create in monorepo requires project', () => {
+  if (!fs.existsSync(MONOREPO_DIR)) return;
+  const result = run('create --json', { cwd: MONOREPO_DIR });
+  assert(!result.success, 'Should fail without project in monorepo');
+  const json = assertJSON(result.output);
+  assert(json.error.code === 'MISSING_ARGS', 'Should have MISSING_ARGS error');
+});
+
+test('create in monorepo with project works', () => {
+  if (!fs.existsSync(MONOREPO_DIR)) return;
+  const result = run('create engineer test-mono --prefix feat --dry-run --json', { cwd: MONOREPO_DIR });
+  assert(result.success, 'Should succeed with project');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.project === 'claudekit-engineer', 'Should detect project');
+});
+
+test('create detects invalid project', () => {
+  if (!fs.existsSync(MONOREPO_DIR)) return;
+  const result = run('create nonexistent test-invalid --json', { cwd: MONOREPO_DIR });
+  assert(!result.success, 'Should fail with invalid project');
+  const json = assertJSON(result.output);
+  assert(json.error.code === 'PROJECT_NOT_FOUND', 'Should have PROJECT_NOT_FOUND error');
+});
+
+// ============================================
+// REMOVE COMMAND TESTS
+// ============================================
+console.log('\n🗑️  REMOVE Command Tests');
+
+test('remove requires worktree name', () => {
+  const result = run('remove --json');
+  assert(!result.success, 'Should fail without name');
+  const json = assertJSON(result.output);
+  assert(json.error.code === 'MISSING_WORKTREE', 'Should have MISSING_WORKTREE error');
+});
+
+test('remove dry-run does not remove worktree', () => {
+  // First get a worktree name from list
+  const listResult = run('list --json');
+  const listJson = assertJSON(listResult.output);
+  const removable = listJson.worktrees.find(w => !w.isMainWorktree);
+
+  if (removable) {
+    const name = path.basename(removable.path);
+    const result = run(`remove "${name}" --dry-run --json`);
+    assert(result.success, 'Dry-run should succeed');
+    const json = assertJSON(result.output);
+    assert(json.dryRun === true, 'Should have dryRun: true');
+    assert(json.wouldRemove, 'Should have wouldRemove object');
+  }
+});
+
+test('remove handles not found', () => {
+  const result = run('remove nonexistent-worktree-xyz --json');
+  assert(!result.success, 'Should fail for nonexistent');
+  const json = assertJSON(result.output);
+  assert(json.error.code === 'WORKTREE_NOT_FOUND', 'Should have WORKTREE_NOT_FOUND error');
+});
+
+test('remove error includes available worktrees', () => {
+  const result = run('remove nonexistent-worktree-xyz --json');
+  const json = assertJSON(result.output);
+  assert(Array.isArray(json.error.availableWorktrees), 'Should list available worktrees');
+});
+
+// ============================================
+// PRUNE COMMAND TESTS
+// ============================================
+console.log('\n🧹 PRUNE Command Tests');
+
+test('prune dry-run returns valid JSON', () => {
+  const result = run('prune --dry-run --json');
+  assert(result.success, 'Dry-run should succeed');
+  const json = assertJSON(result.output);
+  assert(json.success === true, 'Should have success: true');
+  assert(json.dryRun === true, 'Should have dryRun: true');
+  assert(Array.isArray(json.entries), 'Should include entries array');
+});
+
+test('prune text output is readable', () => {
+  const result = run('prune --dry-run');
+  assert(result.success, 'Dry-run should succeed');
+  assert(result.output.includes('Prune'), 'Should have readable prune output');
+});
+
+// ============================================
+// AUTO-FEATURES TESTS (env templates)
+// ============================================
+console.log('\n🤖 Auto-Features Tests');
+
+test('create dry-run succeeds', () => {
+  const result = run('create test-env-feature --prefix feat --dry-run --json');
+  assert(result.success, 'Dry-run should succeed');
+  const json = assertJSON(result.output);
+  assert(json.dryRun === true, 'Should have dryRun: true');
+});
+
+test('create ignores unsafe --env traversal entries', () => {
+  const result = run('create env-guard --prefix feat --dry-run --json --env "../.env,secrets/.env,.env.local"');
+  assert(result.success, 'Dry-run should succeed');
+  const json = assertJSON(result.output);
+  assert(Array.isArray(json.warnings), 'Should include warnings');
+  assert(json.warnings.some(w => w.includes('unsafe env file')), 'Should warn for unsafe env entries');
+});
+
+// ============================================
+// WORKTREE ROOT DETECTION TESTS
+// ============================================
+console.log('\n📍 Worktree Root Detection Tests');
+
+test('info shows worktreeRoot and worktreeRootSource', () => {
+  const result = run('info --json');
+  const json = assertJSON(result.output);
+  assert(json.worktreeRoot, 'Should have worktreeRoot');
+  assert(json.worktreeRootSource, 'Should have worktreeRootSource');
+  assert(typeof json.worktreeRoot === 'string', 'worktreeRoot should be string');
+  assert(json.worktreeRoot.includes('worktrees'), 'worktreeRoot should include worktrees');
+});
+
+test('create --worktree-root overrides default location', () => {
+  const customRoot = '/tmp/test-worktrees';
+  const result = run(`create test-custom-root --prefix feat --dry-run --json --worktree-root "${customRoot}"`);
+  assert(result.success, 'Should succeed with custom root');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.worktreePath.startsWith(customRoot), 'Path should use custom root');
+  assert(json.wouldCreate.worktreeRootSource === '--worktree-root flag', 'Source should be flag');
+});
+
+test('create --worktree-root with relative path resolves to absolute', () => {
+  const result = run('create test-relative --prefix feat --dry-run --json --worktree-root "./custom-worktrees"');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  assert(path.isAbsolute(json.wouldCreate.worktreePath), 'Path should be absolute');
+});
+
+test('create dry-run shows worktreeRootSource', () => {
+  const result = run('create test-source --prefix feat --dry-run --json');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.worktreeRootSource, 'Should show worktreeRootSource');
+});
+
+test('superproject detection in submodule', () => {
+  // Test from claudekit-engineer submodule
+  const submodulePath = path.join(MONOREPO_DIR, 'claudekit-engineer');
+  if (!fs.existsSync(submodulePath)) return;
+  const result = run('info --json', { cwd: submodulePath });
+  const json = assertJSON(result.output);
+  // Should detect parent monorepo as superproject
+  assert(json.worktreeRootSource.includes('superproject') || json.worktreeRootSource === 'monorepo root',
+    'Should detect superproject or monorepo root');
+});
+
+test('WORKTREE_ROOT env var overrides detection', () => {
+  const envRoot = '/tmp/env-worktrees';
+  try {
+    const output = execSync(`WORKTREE_ROOT="${envRoot}" node "${SCRIPT_PATH}" create test-env --prefix feat --dry-run --json`, {
+      encoding: 'utf-8',
+      cwd: STANDALONE_DIR,
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    const json = JSON.parse(output.trim());
+    assert(json.wouldCreate.worktreePath.startsWith(envRoot), 'Should use env var root');
+    assert(json.wouldCreate.worktreeRootSource === 'WORKTREE_ROOT env', 'Source should be env');
+  } catch (error) {
+    // May fail if script path issue - skip
+  }
+});
+
+test('invalid WORKTREE_ROOT env var fails safely', () => {
+  const invalidRoot = '/etc/passwd';
+  try {
+    execSync(`WORKTREE_ROOT="${invalidRoot}" node "${SCRIPT_PATH}" info --json`, {
+      encoding: 'utf-8',
+      cwd: STANDALONE_DIR,
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    assert(false, 'Should fail with invalid WORKTREE_ROOT');
+  } catch (error) {
+    const json = assertJSON(error.stdout.toString());
+    assert(json.error.code === 'INVALID_WORKTREE_ROOT', 'Should have INVALID_WORKTREE_ROOT');
+  }
+});
+
+test('create --worktree-root validates path existence', () => {
+  // Use a deeply nested non-existent path that can't be created
+  const invalidRoot = '/nonexistent/deeply/nested/path/that/does/not/exist';
+  const result = run(`create test-invalid-root --prefix feat --json --worktree-root "${invalidRoot}"`);
+  assert(!result.success, 'Should fail with invalid path');
+  const json = assertJSON(result.output);
+  assert(json.error.code === 'INVALID_WORKTREE_ROOT', 'Should have INVALID_WORKTREE_ROOT error');
+});
+
+test('info reports agentkit project config as worktreeRootSource', () => {
+  const repo = mkTempGitRepo();
+  const home = mkTempHome();
+  writeWorktreeRootConfig(repo, '../project-worktrees');
+  const result = runInRepo(repo, home, 'info --json');
+  assert(result.success, 'info should succeed');
+  const json = assertJSON(result.output);
+  assert(json.worktreeRootSource === 'agentkit project config', `unexpected source: ${json.worktreeRootSource}`);
+  assert(json.worktreeRoot === path.resolve(repo, '../project-worktrees'), `unexpected root: ${json.worktreeRoot}`);
+});
+
+test('info reports agentkit user config as worktreeRootSource', () => {
+  const repo = mkTempGitRepo();
+  const home = mkTempHome();
+  const userRoot = path.join(os.tmpdir(), 'ak-wt-portable-drive');
+  writeWorktreeRootConfig(home, userRoot);
+  const result = runInRepo(repo, home, 'info --json');
+  assert(result.success, 'info should succeed');
+  const json = assertJSON(result.output);
+  assert(json.worktreeRootSource === 'agentkit user config', `unexpected source: ${json.worktreeRootSource}`);
+  assert(json.worktreeRoot === userRoot, `unexpected root: ${json.worktreeRoot}`);
+});
+
+test('AGENTKIT_HOME overrides where user worktree.root config is read from', () => {
+  // When AGENTKIT_HOME is set, the AgentKit home is that directory itself
+  // (config.yaml lives directly under it), not `$HOME/.agentkit`. A user
+  // worktree.root written to the real $HOME/.agentkit/config.yaml must be
+  // ignored in favor of $AGENTKIT_HOME/config.yaml.
+  const repo = mkTempGitRepo();
+  const home = mkTempHome();
+  const agentkitHome = fs.mkdtempSync(path.join(os.tmpdir(), 'ak-wt-test-akhome-'));
+  const decoyRoot = path.join(os.tmpdir(), 'ak-wt-decoy-should-not-win');
+  writeWorktreeRootConfig(home, decoyRoot); // would resolve as $HOME/.agentkit/config.yaml
+  fs.writeFileSync(path.join(agentkitHome, 'config.yaml'), 'worktree:\n  root: ' + path.join(os.tmpdir(), 'ak-wt-real-akhome-root') + '\n');
+  const output = execSync(`node "${SCRIPT_PATH}" info --json`, {
+    encoding: 'utf-8',
+    cwd: repo,
+    env: { ...process.env, HOME: home, USERPROFILE: home, AGENTKIT_HOME: agentkitHome },
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+  const json = assertJSON(output.trim());
+  assert(json.worktreeRootSource === 'agentkit user config', `unexpected source: ${json.worktreeRootSource}`);
+  assert(
+    json.worktreeRoot === path.join(os.tmpdir(), 'ak-wt-real-akhome-root'),
+    `expected AGENTKIT_HOME config to win, got ${json.worktreeRoot}`
+  );
+});
+
+test('project worktree.root config overrides user worktree.root config', () => {
+  const repo = mkTempGitRepo();
+  const home = mkTempHome();
+  writeWorktreeRootConfig(repo, '../project-wins-worktrees');
+  writeWorktreeRootConfig(home, path.join(os.tmpdir(), 'ak-wt-user-loses'));
+  const result = runInRepo(repo, home, 'info --json');
+  const json = assertJSON(result.output);
+  assert(json.worktreeRootSource === 'agentkit project config', `expected project to win, got ${json.worktreeRootSource}`);
+  assert(json.worktreeRoot === path.resolve(repo, '../project-wins-worktrees'), `unexpected root: ${json.worktreeRoot}`);
+});
+
+test('absolute worktree.root at project scope is skipped with a warning', () => {
+  const repo = mkTempGitRepo();
+  const home = mkTempHome();
+  writeWorktreeRootConfig(repo, path.join(os.tmpdir(), 'ak-wt-untrusted-absolute'));
+  const result = runInRepo(repo, home, 'info --json');
+  assert(result.success, 'info should still succeed (warning, not a hard error)');
+  const json = assertJSON(result.output);
+  assert(json.worktreeRootSource !== 'agentkit project config', 'absolute project-scope value must not win');
+  assert(Array.isArray(json.warnings) && json.warnings.length > 0, 'should surface a warning');
+  assert(/project scope only honors a relative path/.test(json.warnings[0]), 'warning should explain the rejection');
+});
+
+test('--worktree-root flag overrides worktree.root config', () => {
+  const repo = mkTempGitRepo();
+  const home = mkTempHome();
+  writeWorktreeRootConfig(repo, '../config-worktrees');
+  const flagRoot = os.tmpdir();
+  const result = runInRepo(repo, home, `create test-flag-wins --prefix feat --dry-run --json --worktree-root "${flagRoot}"`);
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.worktreeRootSource === '--worktree-root flag', `unexpected source: ${json.wouldCreate.worktreeRootSource}`);
+});
+
+test('worktree.root config outranks WORKTREE_ROOT env var', () => {
+  // Precedence is flag > project config > user config > WORKTREE_ROOT env >
+  // built-in chain, so a set config value must win over the env var here.
+  const repo = mkTempGitRepo();
+  const home = mkTempHome();
+  writeWorktreeRootConfig(repo, '../config-worktrees');
+  const envRoot = os.tmpdir();
+  try {
+    const output = execSync(`node "${SCRIPT_PATH}" create test-config-outranks-env --prefix feat --dry-run --json`, {
+      encoding: 'utf-8',
+      cwd: repo,
+      env: { ...process.env, HOME: home, USERPROFILE: home, WORKTREE_ROOT: envRoot },
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    const json = JSON.parse(output.trim());
+    assert(json.wouldCreate.worktreeRootSource === 'agentkit project config', `unexpected source: ${json.wouldCreate.worktreeRootSource}`);
+  } catch (error) {
+    assert(false, `command should succeed: ${error.stderr || error.message}`);
+  }
+});
+
+test('WORKTREE_ROOT env var still wins when no worktree.root config is set', () => {
+  const repo = mkTempGitRepo();
+  const home = mkTempHome();
+  const envRoot = os.tmpdir();
+  try {
+    const output = execSync(`node "${SCRIPT_PATH}" create test-env-wins-no-config --prefix feat --dry-run --json`, {
+      encoding: 'utf-8',
+      cwd: repo,
+      env: { ...process.env, HOME: home, USERPROFILE: home, WORKTREE_ROOT: envRoot },
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    const json = JSON.parse(output.trim());
+    assert(json.wouldCreate.worktreeRootSource === 'WORKTREE_ROOT env', `unexpected source: ${json.wouldCreate.worktreeRootSource}`);
+  } catch (error) {
+    assert(false, `command should succeed: ${error.stderr || error.message}`);
+  }
+});
+
+test('a worktree.root value with shell metacharacters cannot execute code (real create, not dry-run)', () => {
+  // A project's committed .agentkit/config.yaml is untrusted input (it can
+  // arrive from a cloned repo). worktreeRoot must never reach a shell -
+  // otherwise a value like this one plants an arbitrary file the moment
+  // someone runs `create` in the clone. This exercises the real (non
+  // --dry-run) create path so the actual `git worktree add` invocation runs.
+  const repo = mkTempGitRepo();
+  execSync('git config user.email test@example.com', { cwd: repo, stdio: ['pipe', 'pipe', 'pipe'] });
+  execSync('git config user.name test', { cwd: repo, stdio: ['pipe', 'pipe', 'pipe'] });
+  execSync('git commit -q --allow-empty -m init', { cwd: repo, stdio: ['pipe', 'pipe', 'pipe'] });
+  const home = mkTempHome();
+  const parentDir = path.dirname(repo);
+  writeWorktreeRootConfig(repo, '../wt";touch PWNED-RCE;echo "');
+  runInRepo(repo, home, 'create pocfeat --prefix feat --json');
+  const canaryLocations = [repo, parentDir, home, os.tmpdir()].map((dir) => path.join(dir, 'PWNED-RCE'));
+  for (const canary of canaryLocations) {
+    assert(!fs.existsSync(canary), `shell metacharacters in worktree.root must not execute a command (found ${canary})`);
+  }
+});
+
+// ============================================
+// ERROR HANDLING TESTS
+// ============================================
+console.log('\n⚠️  Error Handling Tests');
+
+test('unknown command returns error', () => {
+  const result = run('unknowncommand --json');
+  assert(!result.success, 'Should fail');
+  const json = assertJSON(result.output);
+  assert(json.error.code === 'UNKNOWN_COMMAND', 'Should have UNKNOWN_COMMAND error');
+});
+
+test('no command returns error', () => {
+  const result = run('--json');
+  assert(!result.success, 'Should fail');
+  const json = assertJSON(result.output);
+  assert(json.error.code === 'UNKNOWN_COMMAND', 'Should have UNKNOWN_COMMAND error');
+});
+
+test('errors have suggestion field', () => {
+  const result = run('create --json');
+  const json = assertJSON(result.output);
+  assert(json.error.suggestion, 'Error should have suggestion');
+});
+
+test('success commands return exit code 0', () => {
+  const result = run('info --json');
+  assert(result.exitCode === 0, 'Exit code should be 0');
+});
+
+test('error commands return exit code 1', () => {
+  const result = run('create --json');
+  assert(result.exitCode === 1, 'Exit code should be 1');
+});
+
+test('non-git directory returns error', () => {
+  const result = run('info --json', { cwd: '/tmp' });
+  assert(!result.success, 'Should fail in non-git dir');
+  const json = assertJSON(result.output);
+  assert(json.error.code === 'NOT_GIT_REPO', 'Should have NOT_GIT_REPO error');
+});
+
+// ============================================
+// EDGE CASE: FEATURE NAME HANDLING
+// ============================================
+console.log('\n🔤 Feature Name Edge Cases');
+
+test('create handles empty string feature', () => {
+  const result = run('create "" --json');
+  assert(!result.success, 'Should fail with empty feature');
+  const json = assertJSON(result.output);
+  assert(json.error.code === 'MISSING_FEATURE', 'Should have MISSING_FEATURE error');
+});
+
+test('create handles very long feature name (truncates to 50 chars)', () => {
+  const longName = 'a'.repeat(100);
+  const result = run(`create "${longName}" --dry-run --json`);
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  const branchPart = json.wouldCreate.branch.split('/')[1];
+  assert(branchPart.length <= 50, 'Feature part should be max 50 chars');
+});
+
+test('create handles unicode characters', () => {
+  const result = run('create "测试功能-тест" --dry-run --json');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  // Unicode gets converted to dashes
+  assert(!json.wouldCreate.branch.includes('测'), 'Should not contain unicode');
+});
+
+test('create handles leading/trailing dashes', () => {
+  const result = run('create "---feature---" --dry-run --json');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  assert(!json.wouldCreate.branch.endsWith('/-'), 'Should not end with dash');
+  assert(!json.wouldCreate.branch.includes('//'), 'Should not have double slashes');
+});
+
+test('create handles only special characters', () => {
+  const result = run('create "@#$%^&*()" --dry-run --json');
+  assert(!result.success, 'Should fail when sanitized feature is empty');
+  const json = assertJSON(result.output);
+  assert(json.error.code === 'INVALID_FEATURE_NAME', 'Should report invalid feature name');
+});
+
+test('create handles numbers only', () => {
+  const result = run('create "12345" --dry-run --json');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.branch.includes('12345'), 'Should keep numbers');
+});
+
+test('create handles mixed case camelCase', () => {
+  const result = run('create "myNewFeature" --dry-run --json');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.branch.includes('mynewfeature'), 'Should be lowercase');
+});
+
+// ============================================
+// --no-prefix: MULTI-SEGMENT BRANCH NAMES
+// ============================================
+console.log('\n🔀 --no-prefix Multi-Segment Branch Names');
+
+test('--no-prefix preserves forward slashes in branch name', () => {
+  const result = run('create "dev/feat/999-test-slash-preserve" --no-prefix --dry-run --json');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.branch === 'dev/feat/999-test-slash-preserve', `Should preserve slashes, got: ${json.wouldCreate.branch}`);
+});
+
+test('--no-prefix preserves case with slashes', () => {
+  const result = run('create "User/Fix/MyBug" --no-prefix --dry-run --json');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.branch === 'User/Fix/MyBug', `Should preserve case and slashes, got: ${json.wouldCreate.branch}`);
+});
+
+test('--no-prefix flattens slashes in worktree directory name', () => {
+  const result = run('create "kai/feat/my-feature" --no-prefix --dry-run --json');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  // Worktree path should NOT contain nested directories from branch slashes
+  const worktreeName = json.wouldCreate.worktreePath.split('/').pop();
+  assert(!worktreeName.includes('/'), 'Worktree dir name should not contain slashes');
+  assert(worktreeName.includes('kai-feat-my-feature'), `Should flatten slashes to dashes, got: ${worktreeName}`);
+});
+
+test('--no-prefix collapses consecutive slashes', () => {
+  const result = run('create "kai///feat//my-feature" --no-prefix --dry-run --json');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  assert(!json.wouldCreate.branch.includes('//'), `Should not have consecutive slashes, got: ${json.wouldCreate.branch}`);
+});
+
+test('--no-prefix trims leading/trailing slashes', () => {
+  const result = run('create "/kai/feat/my-feature/" --no-prefix --dry-run --json');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  assert(!json.wouldCreate.branch.startsWith('/'), 'Should not start with slash');
+  assert(!json.wouldCreate.branch.endsWith('/'), 'Should not end with slash');
+});
+
+test('--no-prefix rejects path traversal (..)', () => {
+  const result = run('create "kai/../../../etc/passwd" --no-prefix --dry-run --json');
+  assert(!result.success, 'Should fail with path traversal');
+  const json = assertJSON(result.output);
+  assert(json.error.code === 'INVALID_FEATURE_NAME', 'Should report invalid feature name');
+});
+
+test('--no-prefix still works for simple names (no slashes)', () => {
+  const result = run('create "ND-1377-cleanup-docs" --no-prefix --dry-run --json');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.branch === 'ND-1377-cleanup-docs', `Should work without slashes, got: ${json.wouldCreate.branch}`);
+});
+
+test('--no-prefix preserves dots in branch names', () => {
+  const result = run('create "release/v1.2.3" --no-prefix --dry-run --json');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.branch === 'release/v1.2.3', `Should preserve dots, got: ${json.wouldCreate.branch}`);
+});
+
+// ============================================
+// EDGE CASE: PATH HANDLING
+// ============================================
+console.log('\n📁 Path Handling Edge Cases');
+
+test('create handles path with spaces via --worktree-root', () => {
+  const pathWithSpaces = '/tmp/my worktree dir';
+  const result = run(`create test-spaces --prefix feat --dry-run --json --worktree-root "${pathWithSpaces}"`);
+  assert(result.success, 'Should succeed with quoted path');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.worktreePath.includes('my worktree dir'), 'Should preserve spaces');
+});
+
+test('create handles home directory expansion', () => {
+  // Script uses path.resolve which doesn't expand ~, so this tests current behavior
+  const result = run('create test-home --prefix feat --dry-run --json --worktree-root "~/test-worktrees"');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  // ~/test-worktrees should be resolved relative to cwd, not expanded
+  assert(json.wouldCreate.worktreePath, 'Should have worktree path');
+});
+
+test('create validates file path as worktree root', () => {
+  // /etc/passwd exists but is a file, not directory
+  const result = run('create test-file --prefix feat --json --worktree-root "/etc/passwd"');
+  assert(!result.success, 'Should fail when path is file');
+  const json = assertJSON(result.output);
+  assert(json.error.code === 'INVALID_WORKTREE_ROOT', 'Should have INVALID_WORKTREE_ROOT');
+  assert(json.error.message.includes('not a directory'), 'Should mention not a directory');
+});
+
+test('create handles current directory as worktree root', () => {
+  const result = run('create test-current --prefix feat --dry-run --json --worktree-root "."');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  assert(path.isAbsolute(json.wouldCreate.worktreePath), 'Should resolve to absolute');
+});
+
+// ============================================
+// EDGE CASE: BRANCH PREFIX HANDLING
+// ============================================
+console.log('\n🏷️  Branch Prefix Edge Cases');
+
+test('create uses default prefix when --prefix missing value', () => {
+  // --prefix without value should use 'feat' default
+  const result = run('create test-default-prefix --dry-run --json');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.branch.startsWith('feat/'), 'Should default to feat');
+});
+
+test('create handles invalid prefix gracefully', () => {
+  // Prefix is sanitized before use.
+  const result = run('create test-custom-prefix --prefix custom --dry-run --json');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.branch.startsWith('custom/'), 'Should use custom prefix');
+});
+
+// ============================================
+// EDGE CASE: MONOREPO SCENARIOS
+// ============================================
+console.log('\n📦 Monorepo Edge Cases');
+
+test('create with partial project match in monorepo', () => {
+  if (!fs.existsSync(MONOREPO_DIR)) return;
+  // 'cli' should match 'claudekit-cli'
+  const result = run('create cli test-partial --prefix feat --dry-run --json', { cwd: MONOREPO_DIR });
+  assert(result.success, 'Should succeed with partial match');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.project === 'claudekit-cli', 'Should find claudekit-cli');
+});
+
+test('create detects multiple project matches', () => {
+  if (!fs.existsSync(MONOREPO_DIR)) return;
+  // 'claudekit' matches multiple projects
+  const result = run('create claudekit test-multi --prefix feat --json', { cwd: MONOREPO_DIR });
+  assert(!result.success, 'Should fail with multiple matches');
+  const json = assertJSON(result.output);
+  assert(json.error.code === 'MULTIPLE_PROJECTS_MATCH', 'Should have MULTIPLE_PROJECTS_MATCH error');
+  assert(json.error.matchingProjects.length > 1, 'Should list multiple matches');
+});
+
+test('info shows project env files in monorepo', () => {
+  if (!fs.existsSync(MONOREPO_DIR)) return;
+  const result = run('info --json', { cwd: MONOREPO_DIR });
+  const json = assertJSON(result.output);
+  assert(json.projectEnvFiles !== undefined, 'Should have projectEnvFiles');
+});
+
+// ============================================
+// EDGE CASE: WORKTREE REMOVAL
+// ============================================
+console.log('\n🗑️  Remove Edge Cases');
+
+test('remove matches by full path', () => {
+  const listResult = run('list --json');
+  const listJson = assertJSON(listResult.output);
+  const removable = listJson.worktrees.find(w => !w.isMainWorktree);
+
+  if (removable) {
+    const result = run(`remove "${removable.path}" --dry-run --json`);
+    assert(result.success, 'Should match by full path');
+    const json = assertJSON(result.output);
+    assert(json.wouldRemove.worktreePath === removable.path, 'Should match exact path');
+  }
+});
+
+test('remove matches by branch name', () => {
+  const listResult = run('list --json');
+  const listJson = assertJSON(listResult.output);
+  const removable = listJson.worktrees.find(w => w.branch && !w.isMainWorktree);
+
+  if (removable && removable.branch !== 'detached') {
+    const branchPart = removable.branch.split('/').pop(); // Get last part of branch
+    const result = run(`remove "${branchPart}" --dry-run --json`);
+    // May match or have multiple matches - both are valid behaviors
+    assert(result.output, 'Should have output');
+  }
+});
+
+test('remove is case insensitive', () => {
+  const result = run('remove NONEXISTENT-WORKTREE-XYZ --json');
+  assert(!result.success, 'Should fail');
+  const json = assertJSON(result.output);
+  assert(json.error.code === 'WORKTREE_NOT_FOUND', 'Should search case-insensitively');
+});
+
+// ============================================
+// EDGE CASE: DIRTY STATE HANDLING
+// ============================================
+console.log('\n📝 Dirty State Edge Cases');
+
+test('info provides dirty state details', () => {
+  const result = run('info --json');
+  const json = assertJSON(result.output);
+  assert(typeof json.dirtyState === 'boolean', 'Should have dirtyState');
+  if (json.dirtyState) {
+    assert(json.dirtyDetails, 'Should have dirtyDetails when dirty');
+    assert(typeof json.dirtyDetails.modified === 'number', 'Should have modified count');
+    assert(typeof json.dirtyDetails.staged === 'number', 'Should have staged count');
+    assert(typeof json.dirtyDetails.untracked === 'number', 'Should have untracked count');
+  }
+});
+
+test('create includes warning for dirty state', () => {
+  // This test depends on repo state - if clean, warning won't appear
+  const result = run('create test-dirty-check --dry-run --json');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  // warnings may or may not exist depending on repo state
+  if (json.warnings) {
+    assert(Array.isArray(json.warnings), 'warnings should be array');
+  }
+});
+
+// ============================================
+// EDGE CASE: JSON VS TEXT OUTPUT
+// ============================================
+console.log('\n📤 Output Format Edge Cases');
+
+test('info text output includes all sections', () => {
+  const result = run('info');
+  assert(result.success, 'Should succeed');
+  assert(result.output.includes('Repository Info'), 'Should have repo info');
+  assert(result.output.includes('Type:'), 'Should have type');
+  assert(result.output.includes('Base branch:'), 'Should have base branch');
+  assert(result.output.includes('Worktree location:'), 'Should have worktree location');
+});
+
+test('list text output is readable', () => {
+  const result = run('list');
+  assert(result.success, 'Should succeed');
+  assert(result.output.includes('worktrees'), 'Should mention worktrees');
+});
+
+test('error text output is readable', () => {
+  const result = run('create');
+  assert(!result.success, 'Should fail');
+  assert(result.stderr.includes('Error') || result.output.includes('Error'), 'Should have error text');
+});
+
+// ============================================
+// EDGE CASE: EXISTING BRANCH SCENARIOS
+// ============================================
+console.log('\n🌿 Branch Existence Edge Cases');
+
+test('create dry-run shows if branch exists', () => {
+  const result = run('create test-branch-exist --prefix feat --dry-run --json');
+  assert(result.success, 'Should succeed');
+  const json = assertJSON(result.output);
+  assert(typeof json.wouldCreate.branchExists === 'boolean', 'Should indicate branch existence');
+});
+
+// ============================================
+// EDGE CASE: CONCURRENT/RACE CONDITIONS
+// ============================================
+console.log('\n⚡ Concurrent Access Tests');
+
+test('multiple info calls return consistent data', () => {
+  const result1 = run('info --json');
+  const result2 = run('info --json');
+  assert(result1.success && result2.success, 'Both should succeed');
+  const json1 = assertJSON(result1.output);
+  const json2 = assertJSON(result2.output);
+  assert(json1.repoType === json2.repoType, 'Repo type should be consistent');
+  assert(json1.baseBranch === json2.baseBranch, 'Base branch should be consistent');
+  assert(json1.worktreeRoot === json2.worktreeRoot, 'Worktree root should be consistent');
+});
+
+test('list returns consistent worktree count', () => {
+  const result1 = run('list --json');
+  const result2 = run('list --json');
+  assert(result1.success && result2.success, 'Both should succeed');
+  const json1 = assertJSON(result1.output);
+  const json2 = assertJSON(result2.output);
+  assert(json1.worktrees.length === json2.worktrees.length, 'Worktree count should be consistent');
+});
+
+// ============================================
+// USER SCENARIO: REAL-WORLD WORKFLOWS
+// ============================================
+console.log('\n👤 User Scenario Tests');
+
+test('scenario: new user creates first worktree', () => {
+  // Step 1: Check info
+  const infoResult = run('info --json');
+  assert(infoResult.success, 'Info should succeed');
+  const info = assertJSON(infoResult.output);
+
+  // Step 2: Dry-run create
+  const createResult = run('create add-login-feature --prefix feat --dry-run --json');
+  assert(createResult.success, 'Create dry-run should succeed');
+  const create = assertJSON(createResult.output);
+  assert(create.wouldCreate.branch === 'feat/add-login-feature', 'Branch should be correctly named');
+  assert(create.wouldCreate.baseBranch === info.baseBranch, 'Should use detected base branch');
+});
+
+test('scenario: user fixes bug in submodule', () => {
+  const submodulePath = path.join(MONOREPO_DIR, 'claudekit-engineer');
+  if (!fs.existsSync(submodulePath)) return;
+
+  // From submodule, create a fix branch
+  const result = run('create fix-auth-bug --prefix fix --dry-run --json', { cwd: submodulePath });
+  assert(result.success, 'Should succeed from submodule');
+  const json = assertJSON(result.output);
+  assert(json.wouldCreate.branch.startsWith('fix/'), 'Should have fix prefix');
+  // Worktree should go to superproject
+  assert(json.wouldCreate.worktreeRootSource.includes('superproject') ||
+         json.wouldCreate.worktreeRootSource.includes('monorepo'),
+    'Should use superproject worktrees dir');
+});
+
+test('scenario: user cleans up old worktrees', () => {
+  // List worktrees first
+  const listResult = run('list --json');
+  assert(listResult.success, 'List should succeed');
+  const list = assertJSON(listResult.output);
+
+  // Try to remove a nonexistent worktree (simulating cleanup)
+  const removeResult = run('remove old-feature-xyz --json');
+  assert(!removeResult.success, 'Should fail for nonexistent');
+  const remove = assertJSON(removeResult.output);
+  assert(remove.error.availableWorktrees, 'Should show available worktrees for cleanup');
+});
+
+test('scenario: user with WORKTREE_ROOT env var', () => {
+  const customRoot = '/tmp/custom-worktrees';
+  try {
+    const output = execSync(
+      `WORKTREE_ROOT="${customRoot}" node "${SCRIPT_PATH}" info --json`,
+      { encoding: 'utf-8', cwd: STANDALONE_DIR, stdio: ['pipe', 'pipe', 'pipe'] }
+    );
+    const json = JSON.parse(output.trim());
+    assert(json.worktreeRoot === customRoot, 'Should use env var');
+    assert(json.worktreeRootSource === 'WORKTREE_ROOT env', 'Should indicate env source');
+  } catch (error) {
+    // Skip if env var handling fails
+  }
+});
+
+// ============================================
+// SUMMARY
+// ============================================
+console.log('\n' + '='.repeat(50));
+console.log(`\n📊 Test Results: ${passed} passed, ${failed} failed\n`);
+
+if (failed > 0) {
+  console.log('Failed tests:');
+  results.filter(r => r.status === 'FAIL').forEach(r => {
+    console.log(`  - ${r.name}: ${r.error}`);
+  });
+  process.exit(1);
+} else {
+  console.log('✅ All tests passed!\n');
+  process.exit(0);
+}