harness-everything 0.2.2 → 0.4.0

package/scripts/lib/advisory-text.js

@@ -1,7 +1,6 @@
 // Prompt-injection-only guidance for platforms with no hook/execution
 // mechanism (Cursor, Copilot, Codex, Continue, Hermes). Single source of
-// truth for the advisory block - it used to be duplicated verbatim inside
-// installer.js's top level and again inside main().
+// truth for the advisory block.
 const fs = require('fs');
 const path = require('path');
 
@@ -15,7 +14,7 @@ const advisoryInstructions = [
   ``,
   `## 🚦 MANDATORY ENTRY TRIAGE & ROUTING (ALWAYS RUN FIRST)`,
   `Every time you receive a new prompt, you MUST load the \`harness-everything\` skill and immediately do the following:`,
-  `1. Run the Tier Router script: \`node harness-everything/scripts/tier-router.js "<Brief summary of user's prompt>"\` (or simulate its routing logic if terminal is not initialized yet).`,
+  `1. Run \`npx github:dyphn1/Harness-everything next "<Brief summary of user's prompt>"\` (this prints the same routing recommendation tier-router.js produces - it works from any directory and does not depend on where a local copy of the skill was installed). If the terminal is not available yet, simulate its routing logic from the rules below instead of skipping this step.`,
   `2. Output a clear, stylized routing checkpoint block at the VERY BEGINNING of your response to the user:`,
   `   \`\`\`markdown`,
   `   ## 🚦 Harness OS Routing Checkpoint`,
@@ -28,7 +27,8 @@ const advisoryInstructions = [
   `## 🤖 COGNITIVE COMPLIANCE (NO SILENT DEGRADES FOR NEW FEATURES)`,
   `- **Newly Added Features / Extensions**: Copilot is highly prone to treating new feature requests as Tier 1 direct edits. If a task introduces *any* new logic, a new API endpoint, or a new file/module, you **MUST NOT** treat it as Tier 1. It **MUST** be treated as a **Tier 2 (Standard Task)** or **Tier 3 (Macro Task)**.`,
   `- **Tier 2 Activation**: Initialize the \`todo-driven-workflow\` checklist first. Summon Domain Experts based on tech stack. Load and execute the \`tdd\` (Test-Driven Development) skill (write tests first, implement, refactor).`,
-  `- **Tier 3 Activation**: Initialize the \`todo-driven-workflow\` checklist, load \`fable-mode\` and \`fable-discipline\`, run sub-agents via \`create-agent-launcher\`, and write global docs using \`repo-docs\`.`,
+  `- **Tier 3 Activation**: Initialize the \`todo-driven-workflow\` checklist, load \`fable-mode\` and \`fable-discipline\`, run sub-agents via \`multi-agent-workspace\`, and write global docs using \`repo-docs\`.`,
+  `- **Pre-Completion Verification Gate**: Before telling the human the task is done, run \`npx github:dyphn1/Harness-everything verify\` in the project root. If it exits non-zero, fix the failures and run it again before declaring completion. On Claude Code this same check is mechanically enforced by a stop hook; here nothing blocks you from skipping it, so treat it as a real requirement, not a suggestion.`,
   `- **Memory Summarization (Self-Evolve)**: Upon task completion, you **MUST** run the \`self-evolve\` skill (running \`node self-evolve/scripts/self-regression.js\` or writing memories) to record key insights, lessons learned, and error boundaries so your context builds across sessions.`,
   `- **Environment Discovery**: Discover the environment (OS, shell, package manager) before running commands - don't assume.`,
   `- **Rule of 3**: If the same error repeats 3 times in a row, STOP retrying. Explain what's failing and ask the human for direction instead of continuing to guess.`,
@@ -36,13 +36,25 @@ const advisoryInstructions = [
   ``
 ].join('\n');
 
+function hasHarnessMarker(content) {
+  return typeof content === 'string' && content.includes(MARKER);
+}
+
+function assertHarnessOwnedOrAbsent(targetFile, label) {
+  if (!fs.existsSync(targetFile)) return;
+  const content = fs.readFileSync(targetFile, 'utf8');
+  if (!hasHarnessMarker(content)) {
+    throw new Error(`Refusing to overwrite pre-existing non-Harness ${label}: ${targetFile}`);
+  }
+}
+
 function injectAdvisoryText(targetFile, header, label) {
   const dir = path.dirname(targetFile);
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
 
   if (fs.existsSync(targetFile)) {
     const content = fs.readFileSync(targetFile, 'utf8');
-    if (!content.includes(MARKER)) {
+    if (!hasHarnessMarker(content)) {
       fs.appendFileSync(targetFile, advisoryInstructions, 'utf8');
       console.log(`  ✅ Augmented existing ${label} with Harness guidance (advisory-only)`);
     }
@@ -60,11 +72,8 @@ function removeAdvisoryText(targetFile) {
     if (markerIndex !== -1) {
       let cleanContent = content;
       const hashMarkerIndex = content.lastIndexOf('#', markerIndex);
-      if (hashMarkerIndex !== -1) {
-        cleanContent = content.substring(0, hashMarkerIndex).trim() + '\n';
-      } else {
-        cleanContent = content.substring(0, markerIndex).trim() + '\n';
-      }
+      if (hashMarkerIndex !== -1) cleanContent = content.substring(0, hashMarkerIndex).trim() + '\n';
+      else cleanContent = content.substring(0, markerIndex).trim() + '\n';
 
       const lines = cleanContent.trim().split('\n').map(l => l.trim()).filter(l => l !== '');
       if (lines.length === 0 || (lines.length === 1 && (lines[0] === '# Cursor Project Rules' || lines[0] === '# AGENTS.md' || lines[0] === '# Copilot Instructions' || lines[0] === '# .hermes.md'))) {
@@ -80,17 +89,13 @@ function removeAdvisoryText(targetFile) {
   }
 }
 
-// Continue.dev reads project rules as individual Markdown files (with YAML
-// frontmatter) from a `.continue/rules/` folder rather than one shared file,
-// so - unlike the shared-file platforms above - Harness gets its own
-// dedicated `harness.md` rule file instead of appending into an arbitrary
-// pre-existing one.
+// Continue gets a dedicated rule file. If a user already owns that exact
+// path, do not replace it just because Harness chose the same filename.
 function installContinueRule(targetFile, label) {
   const dir = path.dirname(targetFile);
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  if (fs.existsSync(targetFile) && fs.readFileSync(targetFile, 'utf8').includes(MARKER)) {
-    return;
-  }
+  assertHarnessOwnedOrAbsent(targetFile, label);
+  if (fs.existsSync(targetFile) && hasHarnessMarker(fs.readFileSync(targetFile, 'utf8'))) return;
   const content = [
     `---`,
     `name: Harness OS Guidance`,
@@ -107,7 +112,7 @@ function removeContinueRule(targetFile) {
   if (!fs.existsSync(targetFile)) return;
   try {
     const content = fs.readFileSync(targetFile, 'utf8');
-    if (content.includes(MARKER)) {
+    if (hasHarnessMarker(content)) {
       fs.unlinkSync(targetFile);
       console.log(`  ✅ Removed Harness rule file: ${targetFile}`);
     }
@@ -137,13 +142,17 @@ function buildCodexGlobalContent() {
     `---`,
     `# AGENTS.md`,
     ``,
+    `# ${MARKER}`,
     `This file is advisory only - this platform has no hook/execution mechanism to`,
     `enforce it mechanically (unlike Claude Code's hook-based circuit breaker). Treat`,
     `these as strong defaults, not guarantees.`,
     ``,
     `- Discover the environment (OS, shell, package manager) before running commands - don't assume.`,
-    `- Triage tasks: trivial fixes need no plan; standard features need tests; large refactors need`,
-    `  an explicit plan reviewed with the human before implementation.`,
+    `- Triage tasks: run \`npx github:dyphn1/Harness-everything next "<summary>"\` for a routing recommendation`,
+    `  (trivial fixes need no plan; standard features need tests; large refactors need an explicit plan`,
+    `  reviewed with the human before implementation).`,
+    `- Before declaring a task done, run \`npx github:dyphn1/Harness-everything verify\` and fix any failures`,
+    `  it reports - nothing here blocks you from skipping this, so treat it as a real requirement.`,
     `- If the same error repeats 3 times in a row, STOP retrying. Explain what's failing and ask the`,
     `  human for direction instead of continuing to guess.`,
     `- Prefer editing over rewriting; commit logically complete chunks rather than one giant diff.`,
@@ -154,10 +163,12 @@ function buildCodexGlobalContent() {
 module.exports = {
   MARKER,
   advisoryInstructions,
+  hasHarnessMarker,
+  assertHarnessOwnedOrAbsent,
   injectAdvisoryText,
   removeAdvisoryText,
   installContinueRule,
   removeContinueRule,
   buildCopilotGlobalContent,
   buildCodexGlobalContent,
-};
+};

package/scripts/lib/claude-hooks.js

@@ -3,12 +3,25 @@
 const fs = require('fs');
 
 // Every hook this package ships is namespaced "harness:<phase>:<name>" (see
-// hooks/hooks.json) specifically so removal can match on that prefix alone -
-// never on loose text like "does the command mention harness", which could
-// false-positive on someone else's unrelated hook (e.g. a script whose path
-// or name happens to contain "harness").
+// hooks/hooks.json) specifically so removal can match on that prefix alone.
+// To handle legacy installations (pre-0.3.0 or older) where hooks were installed
+// without an "id" field, we also check if any command contains keywords like
+// "harness-everything" or "harness-skills".
 function isHarnessHook(hook) {
-  return !!(hook && hook.id && hook.id.startsWith('harness:'));
+  if (!hook) return false;
+  if (hook.id && hook.id.startsWith('harness:')) {
+    return true;
+  }
+  if (Array.isArray(hook.hooks)) {
+    return hook.hooks.some(h => {
+      return h && typeof h.command === 'string' && (
+        h.command.includes('harness-everything') ||
+        h.command.includes('harness-skills') ||
+        h.command.includes('harness-state')
+      );
+    });
+  }
+  return false;
 }
 
 function mergeHarnessHooks(claudeConfig, resolvedHooks) {

package/scripts/lib/execution-contract.js

@@ -0,0 +1,70 @@
+const path = require('path');
+
+function normalizeCommand(command) {
+  if (Array.isArray(command)) {
+    return command.map((part) => String(part));
+  }
+  if (typeof command !== 'string') return null;
+  return command.trim().replace(/\s+/g, ' ');
+}
+
+function commandsEqual(actual, expected) {
+  const left = normalizeCommand(actual);
+  const right = normalizeCommand(expected);
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) &&
+      left.length === right.length && left.every((part, index) => part === right[index]);
+  }
+  return left !== null && left === right;
+}
+
+function commandTokens(command) {
+  if (typeof command !== 'string') return [];
+  return command.match(/"[^"]*"|'[^']*'|\S+/g) || [];
+}
+
+function commandMatches(actual, expected) {
+  if (commandsEqual(actual, expected)) return true;
+  if (typeof actual !== 'string' || typeof expected !== 'string') return false;
+  const target = expected.trim();
+  if (!target || /\s/.test(target) || !/\.(?:c?js|mjs|py|sh|ps1|bat|cmd)$/i.test(target)) return false;
+  const expectedName = path.basename(target.replace(/\\/g, '/')).toLowerCase();
+  const tokens = commandTokens(actual).map((token) => token.replace(/^['"]|['"]$/g, ''));
+  if (tokens.length < 2) return false;
+  const launcher = path.basename(tokens[0].replace(/\\/g, '/')).toLowerCase();
+  if (!new Set(['node', 'node.exe', 'bun', 'bun.exe', 'deno', 'deno.exe', 'python', 'python.exe', 'python3', 'python3.exe', 'ruby', 'ruby.exe']).has(launcher)) return false;
+  return tokens.slice(1).some((token) => path.basename(token.replace(/\\/g, '/')).toLowerCase() === expectedName);
+}
+
+function normalizeRepoPath(value) {
+  if (typeof value !== 'string') return null;
+  const normalized = value.replace(/\\/g, '/').replace(/^\.\//, '');
+  const segments = normalized.split('/');
+  if (!normalized || normalized === '.' || path.posix.isAbsolute(normalized) || /^[A-Za-z]:\//.test(normalized) || segments.includes('..')) return null;
+  return normalized;
+}
+
+function extractPatchPaths(patchText) {
+  if (typeof patchText !== 'string') return [];
+  const paths = [];
+  const marker = /^\*\*\* (?:Update File|Add File|Delete File|Move to):\s*(.+?)\s*$/gm;
+  for (const match of patchText.matchAll(marker)) {
+    if (!paths.includes(match[1])) paths.push(match[1]);
+  }
+  return paths;
+}
+
+function patchPathsAuthorized(patchText, allowedPaths) {
+  const paths = extractPatchPaths(patchText).map(normalizeRepoPath);
+  const allowed = new Set(Array.from(allowedPaths || []).map(normalizeRepoPath));
+  return paths.length > 0 && paths.every((candidate) => candidate && allowed.has(candidate));
+}
+
+module.exports = {
+  commandMatches,
+  commandsEqual,
+  extractPatchPaths,
+  normalizeCommand,
+  normalizeRepoPath,
+  patchPathsAuthorized,
+};

package/scripts/lib/gitignore.js

@@ -1,80 +1,199 @@
-const fs = require('fs');
-const path = require('path');
-
-function ensureWorkspaceGitignorePatterns(wsRoot, patterns) {
-  const gitignorePath = path.join(wsRoot, '.gitignore');
-  try {
-    let content = '';
-    if (fs.existsSync(gitignorePath)) {
-      content = fs.readFileSync(gitignorePath, 'utf8');
-    }
-
-    const lines = content.split(/\r?\n/);
-    const addedPatterns = [];
-
-    for (const pattern of patterns) {
-      const isIgnored = lines.some(line => {
-        const trimmed = line.trim();
-        return trimmed === pattern ||
-               trimmed === pattern.slice(0, -1) ||
-               (pattern === '.claude/harness-state/' && (trimmed === '.claude/' || trimmed === '.claude'));
-      });
-
-      if (!isIgnored) {
-        addedPatterns.push(pattern);
-      }
-    }
-
-    // Same read-then-append shape as ensureHarnessStateIgnored() in
-    // hooks/scripts/lib/harness-state.js, which runs once per hook
-    // invocation and can race across concurrent processes to leave an
-    // exact-duplicate line behind - see the comment there. Collapsing
-    // duplicates here too keeps both writers self-healing the same file.
-    const seen = new Set();
-    let sawDuplicate = false;
-    const dedupedLines = lines.filter(line => {
-      const trimmed = line.trim();
-      if (trimmed === '' || trimmed.startsWith('#')) return true;
-      if (seen.has(trimmed)) {
-        sawDuplicate = true;
-        return false;
-      }
-      seen.add(trimmed);
-      return true;
-    });
-
-    if (addedPatterns.length > 0 || sawDuplicate) {
-      while (dedupedLines.length > 0 && dedupedLines[dedupedLines.length - 1] === '') {
-        dedupedLines.pop();
-      }
-      const finalLines = dedupedLines.concat(addedPatterns);
-      fs.writeFileSync(gitignorePath, finalLines.join('\n') + '\n', 'utf8');
-      if (addedPatterns.length > 0) {
-        console.log(`  ✅ Added auto-generated directories to .gitignore: ${addedPatterns.join(', ')}`);
-      }
-    }
-  } catch (err) {
-    console.warn(`  ⚠️ Failed to update .gitignore: ${err.message}`);
-  }
-}
-
-// Only ever deletes a directory that is genuinely empty, and never recurses
-// past one of `stopDirs` (workspace root / user home / filesystem root) - so
-// this can only ever tidy up directories Harness itself just emptied out,
-// never reach into a parent that still holds unrelated content.
-function cleanEmptyDirs(dir, stopDirs) {
-  if (!fs.existsSync(dir)) return;
-  if ((stopDirs || []).includes(dir) || dir === path.parse(dir).root) return;
-  try {
-    const files = fs.readdirSync(dir);
-    if (files.length === 0) {
-      fs.rmdirSync(dir);
-      console.log(`  ✅ Cleaned up empty directory: ${dir}`);
-      cleanEmptyDirs(path.dirname(dir), stopDirs);
-    }
-  } catch (e) {
-    // ignore
-  }
-}
-
-module.exports = { ensureWorkspaceGitignorePatterns, cleanEmptyDirs };
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Checks if a target pattern is already covered by a line in an ignore file.
+ * Handles exact matches, trailing slash differences, and parent directory subsumption
+ * (e.g. `.claude/` or `.claude` subsumes `.claude/harness-everything/state/`).
+ */
+function isPatternCoveredByLine(pattern, gitignoreLine) {
+  const normPattern = pattern.trim().replace(/\\/g, '/');
+  const normLine = gitignoreLine.trim().replace(/\\/g, '/');
+
+  if (!normLine || normLine.startsWith('#') || normLine.startsWith('!')) {
+    return false;
+  }
+
+  const cleanLine = normLine.endsWith('/') ? normLine.slice(0, -1) : normLine;
+  const cleanPattern = normPattern.endsWith('/') ? normPattern.slice(0, -1) : normPattern;
+
+  // Exact match or slash variant (e.g. '.claude' vs '.claude/')
+  if (cleanLine === cleanPattern) {
+    return true;
+  }
+
+  // Parent directory check: e.g. '.claude' covers '.claude/harness-everything/'
+  if (cleanPattern.startsWith(cleanLine + '/')) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Resolves the real git directory for a workspace. `.git` is usually a
+ * directory, but in submodules and worktrees it is a FILE containing
+ * `gitdir: <path>` - resolve that pointer so info/exclude lands in the right
+ * place. Returns null when the workspace has no git repository.
+ */
+function resolveGitDir(wsRoot) {
+  const dotGit = path.join(wsRoot, '.git');
+  if (!fs.existsSync(dotGit)) return null;
+  try {
+    if (fs.statSync(dotGit).isDirectory()) return dotGit;
+    const content = fs.readFileSync(dotGit, 'utf8');
+    const m = content.match(/gitdir:\s*(.+)/);
+    if (!m) return null;
+    let gitdir = m[1].trim();
+    if (!path.isAbsolute(gitdir)) gitdir = path.resolve(wsRoot, gitdir);
+    return fs.existsSync(gitdir) ? gitdir : null;
+  } catch (e) {
+    return null;
+  }
+}
+
+const EXCLUDE_BANNER_BEGIN = '# --- Harness OS state (auto-managed; local only) ---';
+const EXCLUDE_BANNER_END = '# --- end Harness OS state ---';
+// Legacy marker written by older installers straight into .gitignore.
+const LEGACY_GITIGNORE_BANNER = '# Harness OS Auto-generated Ignore Rules';
+
+function readExcludeLines(gitDir) {
+  try {
+    return fs.readFileSync(path.join(gitDir, 'info', 'exclude'), 'utf8').split(/\r?\n/);
+  } catch (e) {
+    return null; // no exclude file yet - treat as empty but writable
+  }
+}
+
+function writeExcludeSection(gitDir, patterns) {
+  const infoDir = path.join(gitDir, 'info');
+  fs.mkdirSync(infoDir, { recursive: true });
+  const excludePath = path.join(infoDir, 'exclude');
+  let lines = [];
+  try {
+    lines = fs.readFileSync(excludePath, 'utf8').split(/\r?\n/);
+  } catch (e) {}
+
+  // Drop our previous section (if any), then rebuild it from the requested
+  // patterns - so removals from getIgnorePatterns() propagate on reinstall.
+  const beginIdx = lines.indexOf(EXCLUDE_BANNER_BEGIN);
+  const endIdx = lines.indexOf(EXCLUDE_BANNER_END);
+  if (beginIdx !== -1 && endIdx !== -1) {
+    lines.splice(beginIdx, endIdx - beginIdx + 1);
+  }
+  while (lines.length > 0 && lines[lines.length - 1].trim() === '') lines.pop();
+
+  const section = ['', EXCLUDE_BANNER_BEGIN, ...patterns, EXCLUDE_BANNER_END, ''];
+  fs.writeFileSync(excludePath, lines.concat(section).join('\n'), 'utf8');
+}
+
+/**
+ * Idempotently records Harness state directories as LOCAL-ONLY ignores.
+ *
+ * Patterns go to `<gitdir>/info/exclude`, never the working tree's
+ * .gitignore - installing or self-healing must not produce a diff in the
+ * user's project. Also migrates away the legacy banner block that old
+ * versions appended to .gitignore.
+ */
+function ensureWorkspaceGitignorePatterns(wsRoot, patterns) {
+  const wanted = (patterns || []).filter(Boolean);
+
+  // Migration: strip the legacy banner + its pattern lines from .gitignore.
+  const gitignorePath = path.join(wsRoot, '.gitignore');
+  try {
+    if (fs.existsSync(gitignorePath)) {
+      const content = fs.readFileSync(gitignorePath, 'utf8');
+      if (content.includes(LEGACY_GITIGNORE_BANNER)) {
+        const lines = content.split(/\r?\n/);
+        const start = lines.findIndex(l => l.trim() === LEGACY_GITIGNORE_BANNER);
+        let end = start;
+        // The legacy block ran until the first non-pattern line (blank/comment/other rule).
+        for (let i = start + 1; i < lines.length; i++) {
+          const t = lines[i].trim();
+          if (t === '' || t.startsWith('#')) break;
+          end = i;
+        }
+        lines.splice(start, end - start + 1);
+        while (lines.length > 0 && lines[lines.length - 1].trim() === '') lines.pop();
+        fs.writeFileSync(gitignorePath, lines.join('\n') + '\n', 'utf8');
+      }
+    }
+  } catch (err) {
+    console.warn(`  ⚠️ Failed to migrate legacy .gitignore entries: ${err.message}`);
+  }
+
+  const gitDir = resolveGitDir(wsRoot);
+  if (!gitDir) {
+    // No git repo -> nothing local-only to write into. State dirs are gated
+    // elsewhere (bootstrap refuses unmanaged workspaces), so this is fine.
+    return;
+  }
+
+  try {
+    const existing = readExcludeLines(gitDir) || [];
+    // Skip the write entirely when every wanted pattern is already inside our
+    // managed section OR covered by any ignore line (user's own broader rule).
+    const outside = existing.filter(
+      l => l !== EXCLUDE_BANNER_BEGIN && l !== EXCLUDE_BANNER_END
+    );
+    const missing = wanted.filter(p => !outside.some(line => isPatternCoveredByLine(p, line)));
+    const currentSection =
+      beginEnd(existing).start === -1
+        ? []
+        : existing.slice(beginEnd(existing).start + 1, beginEnd(existing).end);
+    const sameSet =
+      currentSection.filter(l => l.trim() && !l.trim().startsWith('#')).join('\n') ===
+      wanted.join('\n');
+    if (missing.length === 0 && sameSet) return;
+
+    writeExcludeSection(gitDir, wanted);
+    console.log(`  ✅ Recorded local-only ignore rules in .git/info/exclude: ${wanted.join(', ')}`);
+  } catch (err) {
+    console.warn(`  ⚠️ Failed to update .git/info/exclude: ${err.message}`);
+  }
+}
+
+function beginEnd(lines) {
+  return { start: lines.indexOf(EXCLUDE_BANNER_BEGIN), end: lines.indexOf(EXCLUDE_BANNER_END) };
+}
+
+/**
+ * Removes Harness's section from .git/info/exclude (uninstall cleanup).
+ * Never touches user-authored exclude rules.
+ */
+function removeWorkspaceExcludePatterns(wsRoot) {
+  const gitDir = resolveGitDir(wsRoot);
+  if (!gitDir) return;
+  try {
+    const excludePath = path.join(gitDir, 'info', 'exclude');
+    const lines = fs.readFileSync(excludePath, 'utf8').split(/\r?\n/);
+    const { start, end } = beginEnd(lines);
+    if (start === -1 || end === -1) return;
+    lines.splice(start, end - start + 1);
+    while (lines.length > 0 && lines[lines.length - 1].trim() === '') lines.pop();
+    fs.writeFileSync(excludePath, lines.join('\n') + '\n', 'utf8');
+  } catch (err) {
+    // Best-effort
+  }
+}
+
+// Only ever deletes a directory that is genuinely empty, and never recurses
+// past one of `stopDirs` (workspace root / user home / filesystem root) - so
+// this can only ever tidy up directories Harness itself just emptied out,
+// never reach into a parent that still holds unrelated content.
+function cleanEmptyDirs(dir, stopDirs) {
+  if (!fs.existsSync(dir)) return;
+  if ((stopDirs || []).includes(dir) || dir === path.parse(dir).root) return;
+  try {
+    const files = fs.readdirSync(dir);
+    if (files.length === 0) {
+      fs.rmdirSync(dir);
+      console.log(`  ✅ Cleaned up empty directory: ${dir}`);
+      cleanEmptyDirs(path.dirname(dir), stopDirs);
+    }
+  } catch (e) {
+    // ignore
+  }
+}
+
+module.exports = { ensureWorkspaceGitignorePatterns, removeWorkspaceExcludePatterns, resolveGitDir, cleanEmptyDirs };