@paths.design/caws-cli 9.3.0 → 9.3.1

package/dist/commands/verify-acs.js

@@ -39,7 +39,7 @@ function detectTestRunner(projectRoot) {
       if (fs.existsSync(fp)) {
         try {
           if (fs.readFileSync(fp, 'utf8').includes(needle)) return check.runner;
-        } catch (_) {}
+        } catch (_) { /* ignore unreadable config */ }
       }
     }
   }
@@ -123,7 +123,7 @@ function runNodeid(nodeid, runner, projectRoot) {
   try {
     switch (runner) {
       case 'pytest': {
-        const out = execFileSync('python3', ['-m', 'pytest', '-x', '--tb=short', nodeid], {
+        execFileSync('python3', ['-m', 'pytest', '-x', '--tb=short', nodeid], {
           cwd: projectRoot, encoding: 'utf8', timeout: 120000, stdio: ['pipe', 'pipe', 'pipe'],
         });
         return { passed: true, detail: 'tests passed' };
@@ -215,7 +215,7 @@ function checkEvidence(evidence, projectRoot) {
         if (files) {
           return { found: true, detail: `found: ${files.split('\n')[0]}` };
         }
-      } catch (_) {}
+      } catch (_) { /* ignore unreadable config */ }
     }
   }
 
@@ -350,7 +350,7 @@ function loadSpecs(projectRoot, targetSpecId) {
       if (s && !TERMINAL_STATUSES.has(s.status)) {
         specs.push({ path: workingSpec, spec: s });
       }
-    } catch (_) {}
+    } catch (_) { /* ignore unreadable config */ }
   }
 
   if (fs.existsSync(specsDir)) {
@@ -360,7 +360,7 @@ function loadSpecs(projectRoot, targetSpecId) {
         if (s && !TERMINAL_STATUSES.has(s.status)) {
           specs.push({ path: path.join(specsDir, f), spec: s });
         }
-      } catch (_) {}
+      } catch (_) { /* ignore unreadable config */ }
     }
   }
 

package/dist/utils/detection.js

@@ -203,17 +203,8 @@ function detectCAWSSetup(cwd = process.cwd()) {
  * @returns {string} Project root directory path
  */
 function findProjectRoot(startDir = process.cwd()) {
-  // Walk up looking for .caws/ directory
-  let dir = path.resolve(startDir);
-  const root = path.parse(dir).root;
-  while (dir !== root) {
-    if (fs.existsSync(path.join(dir, '.caws'))) {
-      return dir;
-    }
-    dir = path.dirname(dir);
-  }
-
-  // Fallback: try git root
+  // In a monorepo, nested packages may have their own .caws/ (scaffold debris).
+  // The git root's .caws/ is authoritative — check it first.
   try {
     const { execFileSync } = require('child_process');
     const gitRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], {
@@ -225,7 +216,17 @@ function findProjectRoot(startDir = process.cwd()) {
       return gitRoot;
     }
   } catch {
-    // Not a git repo or git not available
+    // Not a git repo or git not available — fall through
+  }
+
+  // Walk up looking for .caws/ directory (non-git projects)
+  let dir = path.resolve(startDir);
+  const root = path.parse(dir).root;
+  while (dir !== root) {
+    if (fs.existsSync(path.join(dir, '.caws'))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
   }
 
   // Final fallback: cwd

package/dist/worktree/worktree-manager.js

@@ -101,6 +101,106 @@ function saveRegistry(root, registry) {
   fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2));
 }
 
+/**
+ * Discover git worktrees under .caws/worktrees/ that are not in the registry.
+ * @param {string} root - Repository root
+ * @param {Object} registry - Current registry object
+ * @returns {Array<{ name: string, path: string, branch: string }>}
+ */
+function discoverUnregisteredWorktrees(root, registry) {
+  const unregistered = [];
+  try {
+    const output = execFileSync('git', ['worktree', 'list', '--porcelain'], {
+      cwd: root,
+      encoding: 'utf8',
+      stdio: 'pipe',
+    });
+    let worktreesDir;
+    try {
+      worktreesDir = fs.realpathSync(path.resolve(root, WORKTREES_DIR));
+    } catch {
+      // Directory might not exist yet
+      worktreesDir = path.resolve(root, WORKTREES_DIR);
+    }
+
+    const blocks = output.split('\n\n').filter(Boolean);
+    for (const block of blocks) {
+      const lines = block.split('\n');
+      const wtLine = lines.find((l) => l.startsWith('worktree '));
+      const branchLine = lines.find((l) => l.startsWith('branch '));
+      if (!wtLine) continue;
+
+      const wtPath = wtLine.replace('worktree ', '');
+      let resolvedPath;
+      try {
+        resolvedPath = fs.realpathSync(wtPath);
+      } catch {
+        resolvedPath = path.resolve(wtPath);
+      }
+
+      // Only consider worktrees under .caws/worktrees/
+      if (!resolvedPath.startsWith(worktreesDir + path.sep)) continue;
+
+      const name = path.basename(resolvedPath);
+      if (registry.worktrees[name]) continue;
+
+      const branch = branchLine
+        ? branchLine.replace('branch refs/heads/', '')
+        : `${BRANCH_PREFIX}${name}`;
+      unregistered.push({ name, path: resolvedPath, branch });
+    }
+  } catch {
+    // git worktree list failed
+  }
+  return unregistered;
+}
+
+/**
+ * Auto-register an unregistered worktree. Infers baseBranch via merge-base.
+ * @param {string} root - Repository root
+ * @param {Object} registry - Registry object (mutated in place)
+ * @param {{ name: string, path: string, branch: string }} discovered
+ * @returns {Object} The registered entry
+ */
+function autoRegisterWorktree(root, registry, discovered) {
+  let baseBranch = 'main';
+  try {
+    execFileSync(
+      'git',
+      ['merge-base', discovered.branch, 'main'],
+      { cwd: root, encoding: 'utf8', stdio: 'pipe' }
+    );
+  } catch {
+    try {
+      execFileSync(
+        'git',
+        ['merge-base', discovered.branch, 'master'],
+        { cwd: root, encoding: 'utf8', stdio: 'pipe' }
+      );
+      baseBranch = 'master';
+    } catch {
+      // Keep 'main' as default
+    }
+  }
+
+  const entry = {
+    name: discovered.name,
+    path: discovered.path,
+    branch: discovered.branch,
+    baseBranch,
+    scope: null,
+    specId: null,
+    owner: null,
+    createdAt: new Date().toISOString(),
+    status: 'active',
+    autoRegistered: true,
+  };
+
+  registry.worktrees[discovered.name] = entry;
+  saveRegistry(root, registry);
+  return entry;
+}
+
 /**
  * Create a new git worktree with scope isolation
  * @param {string} name - Worktree name
@@ -308,6 +408,25 @@ function listWorktrees() {
     };
   });
 
+  // Append unregistered worktrees discovered from git
+  const unregistered = discoverUnregisteredWorktrees(root, registry);
+  for (const discovered of unregistered) {
+    const lastCommit = getLastCommitInfo(discovered.branch, root);
+    entries.push({
+      name: discovered.name,
+      path: discovered.path,
+      branch: discovered.branch,
+      baseBranch: null,
+      scope: null,
+      specId: null,
+      owner: null,
+      createdAt: null,
+      status: 'unregistered',
+      lastCommit,
+      merged: false,
+    });
+  }
+
   return entries;
 }
 
@@ -323,9 +442,17 @@ function destroyWorktree(name, options = {}) {
   const registry = loadRegistry(root);
   const { deleteBranch = false, force = false } = options;
 
-  const entry = registry.worktrees[name];
+  let entry = registry.worktrees[name];
   if (!entry) {
-    throw new Error(`Worktree '${name}' not found in registry`);
+    // Fallback: scan git for unregistered worktree and auto-register
+    const unregistered = discoverUnregisteredWorktrees(root, registry);
+    const discovered = unregistered.find((u) => u.name === name);
+    if (discovered) {
+      console.log(chalk.yellow(`Worktree '${name}' not in registry but found in git. Auto-registering.`));
+      entry = autoRegisterWorktree(root, registry, discovered);
+    } else {
+      throw new Error(`Worktree '${name}' not found in registry or git worktree list`);
+    }
   }
 
   // Ownership check: refuse to destroy another agent's active worktree without --force
@@ -438,9 +565,17 @@ function mergeWorktree(name, options = {}) {
   const registry = loadRegistry(root);
   const { dryRun = false, deleteBranch = true, message } = options;
 
-  const entry = registry.worktrees[name];
+  let entry = registry.worktrees[name];
   if (!entry) {
-    throw new Error(`Worktree '${name}' not found in registry`);
+    // Fallback: scan git for unregistered worktree and auto-register
+    const unregistered = discoverUnregisteredWorktrees(root, registry);
+    const discovered = unregistered.find((u) => u.name === name);
+    if (discovered) {
+      console.log(chalk.yellow(`Worktree '${name}' not in registry but found in git. Auto-registering.`));
+      entry = autoRegisterWorktree(root, registry, discovered);
+    } else {
+      throw new Error(`Worktree '${name}' not found in registry or git worktree list`);
+    }
   }
 
   const baseBranch = entry.baseBranch || 'main';
@@ -469,7 +604,7 @@ function mergeWorktree(name, options = {}) {
   let conflicts = [];
   try {
     // New-style merge-tree: takes two branches, computes merge-base automatically
-    const mergeTreeResult = execFileSync(
+    execFileSync(
       'git',
       ['merge-tree', '--write-tree', baseBranch, entry.branch],
       { cwd: root, encoding: 'utf8', stdio: 'pipe' }
@@ -624,6 +759,8 @@ module.exports = {
   getRepoRoot,
   getLastCommitInfo,
   isBranchMerged,
+  discoverUnregisteredWorktrees,
+  autoRegisterWorktree,
   WORKTREES_DIR,
   REGISTRY_FILE,
   BRANCH_PREFIX,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paths.design/caws-cli",
-  "version": "9.3.0",
+  "version": "9.3.1",
   "description": "CAWS CLI - Coding Agent Workflow System command-line tools for spec management, quality gates, and AI-assisted development",
   "main": "dist/index.js",
   "bin": {