ctx-cc 4.1.1 → 4.1.2

package/README.md

@@ -13,7 +13,7 @@
 
 [![npm version](https://img.shields.io/npm/v/ctx-cc.svg?style=flat-square)](https://www.npmjs.com/package/ctx-cc)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
-[![Tests](https://img.shields.io/badge/tests-264%20passing-brightgreen.svg?style=flat-square)](#testing)
+[![Tests](https://img.shields.io/badge/tests-149%20passing-brightgreen.svg?style=flat-square)](#testing)
 [![Zero deps](https://img.shields.io/badge/dependencies-0-brightgreen.svg?style=flat-square)](#)
 
 ```bash
@@ -493,7 +493,7 @@ Options:
 ```bash
 git clone https://github.com/jufjuf/CTX.git
 cd CTX
-npm test    # 264 tests, node:test runner
+npm test    # 149 tests, node:test runner
 ```
 
 **Project structure:**
@@ -504,8 +504,8 @@ ctx-cc/
 ├── skills/          7 skill directories (each contains SKILL.md)
 ├── commands/        26 slash command definitions (.md)
 ├── hooks/           3 enforcement hook scripts (.js)
-├── src/             17 source modules (.js)
-├── test/            19 test files (.test.js)
+├── src/              5 source modules (.js)
+├── test/             8 test files (.test.js)
 ├── templates/       config.json, PRD.json, state templates
 ├── bin/ctx.js       CLI entry point (installer only)
 ├── plugin.json      Marketplace manifest
@@ -518,7 +518,7 @@ ctx-cc/
 
 ```bash
 npm test
-# 264 tests, 0 failures, ~2s
+# 149 tests, 0 failures, ~1s
 ```
 
 **Coverage:**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx-cc",
-  "version": "4.1.1",
+  "version": "4.1.2",
   "description": "CTX 4.0 — Intelligent workflow orchestration for Claude Code. 26 subagents, 7 skills, deterministic hooks. Phase-based lifecycle with autonomous execution.",
   "keywords": [
     "claude",

package/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx",
-  "version": "4.0.0",
+  "version": "4.1.2",
   "description": "CTX — Intelligent workflow orchestration for Claude Code. Specialized agents, phase-based lifecycle, three-stage review gate with OpenAI Codex cross-model review, autonomous execution.",
   "author": "jufjuf",
   "license": "MIT",

package/src/auto.js

@@ -1,287 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { readState, writeState, initState, transitionPhase } from './state.js';
-import { executePipeline } from './pipeline.js';
-import { runReviewGate, isReviewGateEnabled } from './review-gate.js';
-import { selectStory, listPendingStories } from './lifecycle.js';
-import { commitTask } from './commits.js';
-
-const STOP_FILE = 'STOP';
-const AUTO_LOG = 'AUTO-LOG.md';
-
-const DEFAULTS = {
-  maxIterationsPerStory: 5,
-  maxTotalTimeMs: 2 * 60 * 60 * 1000, // 2 hours
-  pipeline: ['plan', 'execute'],
-};
-
-/**
- * Run autonomous execution loop across all P1 stories (or a single story).
- *
- * Options:
- *   ctxDir, projectDir, agentsDir, config
- *   storyId      — single story to process (null = all P1)
- *   retryFailed  — only retry previously failed stories
- *   streaming    — stream agent output
- *   timeout      — per-agent timeout in ms
- *   onEvent      — callback({ type, story, message, ... })
- */
-export async function runAutoLoop({ ctxDir, projectDir, agentsDir, config = {}, storyId = null, retryFailed = false, streaming = true, timeout = 300000, onEvent = null }) {
-  const maxIterations = config.maxIterationsPerStory || DEFAULTS.maxIterationsPerStory;
-  const maxTime = config.maxTotalTimeMs || DEFAULTS.maxTotalTimeMs;
-  const startTime = Date.now();
-
-  // Initialize auto log
-  const logPath = path.join(ctxDir, AUTO_LOG);
-  appendLog(logPath, `# CTX Auto Loop — ${new Date().toISOString()}\n`);
-
-  // Determine stories to process
-  const stories = resolveStories(ctxDir, storyId, retryFailed);
-  if (stories.length === 0) {
-    emit(onEvent, { type: 'no_stories', message: 'No stories to process.' });
-    return { completed: [], failed: [], skipped: [], totalTime: 0 };
-  }
-
-  emit(onEvent, { type: 'start', storyCount: stories.length, maxIterations, maxTime });
-  appendLog(logPath, `\nProcessing ${stories.length} stories. Max ${maxIterations} iterations each.\n`);
-
-  const completed = [];
-  const failed = [];
-  const skipped = [];
-
-  for (const story of stories) {
-    // Check stop file
-    if (shouldStop(ctxDir)) {
-      emit(onEvent, { type: 'stopped', message: 'STOP file detected. Halting after current story.' });
-      appendLog(logPath, `\n⏹ Stopped by STOP file at ${new Date().toISOString()}\n`);
-      skipped.push(...stories.slice(stories.indexOf(story)));
-      break;
-    }
-
-    // Check time limit
-    if (Date.now() - startTime > maxTime) {
-      emit(onEvent, { type: 'timeout', message: `Time limit (${maxTime / 1000 / 60}min) exceeded.` });
-      appendLog(logPath, `\n⏱ Time limit exceeded at ${new Date().toISOString()}\n`);
-      skipped.push(...stories.slice(stories.indexOf(story)));
-      break;
-    }
-
-    emit(onEvent, { type: 'story_start', story: story.id, title: story.title });
-    appendLog(logPath, `\n## ${story.id} — ${story.title}\nStarted: ${new Date().toISOString()}\n`);
-
-    const result = await processStory({
-      story, ctxDir, projectDir, agentsDir, config,
-      maxIterations, streaming, timeout, onEvent, logPath,
-    });
-
-    if (result.success) {
-      completed.push(story.id);
-      appendLog(logPath, `Result: ✓ COMPLETED (${result.iterations} iterations)\n`);
-    } else {
-      failed.push({ id: story.id, reason: result.reason });
-      appendLog(logPath, `Result: ✗ FAILED — ${result.reason}\n`);
-    }
-  }
-
-  // Write summary
-  const totalTime = Date.now() - startTime;
-  const summary = buildSummary(completed, failed, skipped, totalTime);
-  appendLog(logPath, `\n---\n${summary}`);
-
-  emit(onEvent, { type: 'complete', completed, failed, skipped, totalTime });
-
-  // Clean up stop file if it exists
-  cleanupStopFile(ctxDir);
-
-  return { completed, failed, skipped, totalTime };
-}
-
-/**
- * Create a STOP file to gracefully halt the auto loop.
- */
-export function createStopFile(ctxDir) {
-  const stopPath = path.join(ctxDir, STOP_FILE);
-  fs.writeFileSync(stopPath, `Stop requested at ${new Date().toISOString()}\n`);
-}
-
-/**
- * Format auto loop results for display.
- */
-export function formatAutoResult({ completed, failed, skipped, totalTime }) {
-  const lines = [];
-  const mins = Math.round(totalTime / 1000 / 60);
-
-  lines.push(`  Total time: ${mins} minutes`);
-  lines.push('');
-
-  if (completed.length > 0) {
-    lines.push(`  ✓ Completed (${completed.length}):`);
-    for (const id of completed) lines.push(`    ${id}`);
-  }
-
-  if (failed.length > 0) {
-    lines.push(`  ✗ Failed (${failed.length}):`);
-    for (const f of failed) lines.push(`    ${f.id} — ${f.reason}`);
-  }
-
-  if (skipped.length > 0) {
-    lines.push(`  ○ Skipped (${skipped.length}):`);
-    for (const s of skipped) lines.push(`    ${s.id || s}`);
-  }
-
-  if (failed.length > 0) {
-    lines.push('');
-    lines.push('  Retry failed: ctx-cc auto --retry-failed');
-  }
-
-  return lines.join('\n');
-}
-
-// --- internal ---
-
-async function processStory({ story, ctxDir, projectDir, agentsDir, config, maxIterations, streaming, timeout, onEvent, logPath }) {
-  // Select story
-  selectStory(ctxDir, story.id);
-
-  for (let iteration = 1; iteration <= maxIterations; iteration++) {
-    emit(onEvent, { type: 'iteration', story: story.id, iteration, max: maxIterations });
-    appendLog(logPath, `  Iteration ${iteration}/${maxIterations}: `);
-
-    // Run pipeline: plan → execute
-    try {
-      transitionPhase(ctxDir, 'init'); // Reset to init for fresh pipeline
-      const pipeResult = await executePipeline({
-        steps: ['plan', 'execute'],
-        message: `Implement story ${story.id}: ${story.title}\n\n${story.description || ''}\n\nAcceptance criteria:\n${(story.acceptanceCriteria || []).map((c, i) => `${i + 1}. ${c}`).join('\n')}`,
-        ctxDir, projectDir, agentsDir,
-        streaming, timeout,
-      });
-
-      if (pipeResult.failed) {
-        appendLog(logPath, `pipeline failed at ${pipeResult.failed}\n`);
-        if (iteration === maxIterations) {
-          return { success: false, iterations: iteration, reason: `Pipeline failed: ${pipeResult.error}` };
-        }
-        continue; // Retry
-      }
-    } catch (err) {
-      appendLog(logPath, `pipeline error: ${err.message}\n`);
-      if (iteration === maxIterations) {
-        return { success: false, iterations: iteration, reason: err.message };
-      }
-      continue;
-    }
-
-    // Run review gate (if enabled)
-    if (isReviewGateEnabled(config)) {
-      try {
-        const reviewResult = await runReviewGate({
-          ctxDir, projectDir, agentsDir, streaming, timeout, config,
-        });
-
-        if (reviewResult.escalated) {
-          return { success: false, iterations: iteration, reason: 'Review loop exceeded — human review required.' };
-        }
-
-        if (!reviewResult.passed) {
-          appendLog(logPath, `review failed (cycle ${reviewResult.cycle})\n`);
-          if (iteration === maxIterations) {
-            return { success: false, iterations: iteration, reason: `Review failed: ${reviewResult.feedback}` };
-          }
-          continue; // Retry with feedback
-        }
-      } catch (err) {
-        appendLog(logPath, `review error: ${err.message}\n`);
-        // Review errors don't block — continue
-      }
-    }
-
-    // If we get here, story passed
-    appendLog(logPath, `passed\n`);
-
-    // Commit
-    commitTask({
-      projectDir, ctxDir,
-      agentName: 'auto',
-      taskId: story.id,
-      taskTitle: story.title,
-      criteriaIds: story.acceptanceCriteria || [],
-    });
-
-    // Mark story as passed in PRD
-    markStoryPassed(ctxDir, story.id);
-
-    return { success: true, iterations: iteration, reason: null };
-  }
-
-  return { success: false, iterations: maxIterations, reason: `Max iterations (${maxIterations}) exceeded.` };
-}
-
-function resolveStories(ctxDir, storyId, retryFailed) {
-  if (storyId) {
-    // Single story mode
-    try {
-      const prd = JSON.parse(fs.readFileSync(path.join(ctxDir, 'PRD.json'), 'utf-8'));
-      const story = (prd.stories || []).find(s => s.id === storyId);
-      return story ? [story] : [];
-    } catch {
-      return [];
-    }
-  }
-
-  const pending = listPendingStories(ctxDir);
-
-  if (retryFailed) {
-    // Read auto log for failed stories
-    const state = readState(ctxDir);
-    const failedIds = new Set((state?.autoFailedStories || []).map(f => f.id || f));
-    return pending.filter(s => failedIds.has(s.id));
-  }
-
-  // All P1 stories first, then P2, etc.
-  return pending.sort((a, b) => (a.priority || 99) - (b.priority || 99));
-}
-
-function markStoryPassed(ctxDir, storyId) {
-  try {
-    const prdPath = path.join(ctxDir, 'PRD.json');
-    const prd = JSON.parse(fs.readFileSync(prdPath, 'utf-8'));
-    const story = (prd.stories || []).find(s => s.id === storyId);
-    if (story) {
-      story.passes = true;
-      story.verifiedAt = new Date().toISOString();
-      prd.metadata = prd.metadata || {};
-      prd.metadata.passedStories = (prd.metadata.passedStories || 0) + 1;
-      fs.writeFileSync(prdPath, JSON.stringify(prd, null, 2) + '\n');
-    }
-  } catch {}
-}
-
-function shouldStop(ctxDir) {
-  return fs.existsSync(path.join(ctxDir, STOP_FILE));
-}
-
-function cleanupStopFile(ctxDir) {
-  const stopPath = path.join(ctxDir, STOP_FILE);
-  try { fs.unlinkSync(stopPath); } catch {}
-}
-
-function appendLog(logPath, text) {
-  fs.appendFileSync(logPath, text);
-}
-
-function buildSummary(completed, failed, skipped, totalTime) {
-  const mins = Math.round(totalTime / 1000 / 60);
-  return [
-    `## Summary`,
-    `- Completed: ${completed.length}`,
-    `- Failed: ${failed.length}`,
-    `- Skipped: ${skipped.length}`,
-    `- Total time: ${mins} minutes`,
-    `- Finished: ${new Date().toISOString()}`,
-  ].join('\n') + '\n';
-}
-
-function emit(fn, event) {
-  if (fn) fn(event);
-}

package/src/commits.js

@@ -1,94 +0,0 @@
-import { execSync } from 'child_process';
-import { readState, writeState, recordCompletedTask } from './state.js';
-
-/**
- * Create an atomic git commit for a completed task.
- *
- * Checks that there are staged or unstaged changes before committing.
- * Commit message format: ctx(<agent>): <task-title>
- * Body includes acceptance criteria satisfied.
- *
- * Returns { committed: boolean, hash: string|null, error: string|null }
- */
-export function commitTask({ projectDir, ctxDir, agentName, taskId, taskTitle, criteriaIds = [] }) {
-  try {
-    // Check for changes
-    const status = execSync('git status --porcelain', {
-      cwd: projectDir, encoding: 'utf-8', timeout: 5000,
-    }).trim();
-
-    if (!status) {
-      return { committed: false, hash: null, error: 'No changes to commit.' };
-    }
-
-    // Stage all changes (excluding .ctx/ state files to avoid noise)
-    execSync('git add -A -- . ":!.ctx/STATE.json" ":!.ctx/STATE.lock" ":!.ctx/HANDOFF.json"', {
-      cwd: projectDir, timeout: 5000,
-    });
-
-    // Build commit message
-    const subject = `ctx(${agentName}): ${taskTitle}`;
-    const body = buildCommitBody(taskId, criteriaIds);
-    const message = `${subject}\n\n${body}`;
-
-    // Commit
-    execSync(`git commit -m ${shellEscape(message)}`, {
-      cwd: projectDir, encoding: 'utf-8', timeout: 10000,
-    });
-
-    // Get commit hash
-    const hash = execSync('git rev-parse --short HEAD', {
-      cwd: projectDir, encoding: 'utf-8', timeout: 5000,
-    }).trim();
-
-    // Record in state
-    recordCompletedTask(ctxDir, taskId, taskTitle, criteriaIds);
-
-    // Log commit in agent history
-    const state = readState(ctxDir);
-    if (state) {
-      state.lastCommit = { hash, taskId, taskTitle, committedAt: new Date().toISOString() };
-      writeState(ctxDir, state);
-    }
-
-    return { committed: true, hash, error: null };
-  } catch (err) {
-    return { committed: false, hash: null, error: err.message };
-  }
-}
-
-/**
- * Show CTX commit log for the current story.
- */
-export function getCtxCommitLog(projectDir, limit = 20) {
-  try {
-    const log = execSync(`git log --oneline --grep="^ctx(" -${limit} --no-color`, {
-      cwd: projectDir, encoding: 'utf-8', timeout: 5000,
-    }).trim();
-    return log || 'No CTX commits found.';
-  } catch {
-    return 'No CTX commits found.';
-  }
-}
-
-// --- internal ---
-
-function buildCommitBody(taskId, criteriaIds) {
-  const lines = [];
-  if (taskId) lines.push(`Task: ${taskId}`);
-  if (criteriaIds.length > 0) {
-    lines.push('');
-    lines.push('Acceptance criteria satisfied:');
-    for (const id of criteriaIds) {
-      lines.push(`  - ${id}`);
-    }
-  }
-  lines.push('');
-  lines.push('Co-Authored-By: Claude <noreply@anthropic.com>');
-  return lines.join('\n');
-}
-
-function shellEscape(str) {
-  // Use $'...' syntax for strings with newlines
-  return "$'" + str.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n') + "'";
-}

package/src/context.js

@@ -1,241 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { execSync } from 'child_process';
-
-/**
- * Default context profiles per agent category.
- * Each profile lists which context sources the agent receives.
- *
- * Sources:
- *   state    — .ctx/STATE.json
- *   prd      — .ctx/PRD.json (active story only)
- *   plan     — .ctx/phases/<story>/PLAN.md
- *   repoMap  — .ctx/REPO-MAP.md
- *   gitDiff  — git diff (staged + unstaged)
- *   gitLog   — recent commits
- *   fileTree — directory listing
- *   readme   — README.md first 100 lines
- */
-const DEFAULT_PROFILES = {
-  // Planning agents — need requirements and architecture, not code diffs
-  plan:        ['state', 'prd', 'repoMap', 'readme'],
-  predict:     ['state', 'prd', 'repoMap', 'fileTree'],
-  criteria:    ['state', 'prd'],
-  discuss:     ['state', 'prd', 'repoMap'],
-  parallelize: ['state', 'plan'],
-
-  // Execution agents — need the plan and relevant source files
-  execute:     ['state', 'plan', 'repoMap'],
-  debug:       ['state', 'gitDiff', 'gitLog', 'repoMap'],
-
-  // Review agents — need the diff, not the full tree
-  review:      ['state', 'gitDiff', 'prd'],
-  audit:       ['state', 'gitDiff'],
-  verify:      ['state', 'prd', 'gitDiff'],
-
-  // Mapper agents — need filesystem overview
-  map:         ['fileTree', 'readme'],
-  'arch-map':  ['fileTree', 'readme'],
-  'tech-map':  ['fileTree', 'readme'],
-  'quality-map': ['fileTree'],
-  'concerns-map': ['fileTree', 'gitLog'],
-
-  // Knowledge agents
-  research:    ['state', 'prd', 'repoMap'],
-  learn:       ['state', 'repoMap'],
-  design:      ['state', 'prd', 'readme'],
-
-  // Coordination agents
-  handoff:     ['state'],
-  team:        ['state'],
-  qa:          ['state', 'prd', 'readme'],
-};
-
-// Estimated tokens per source (conservative)
-const SOURCE_TOKEN_ESTIMATES = {
-  state: 500,
-  prd: 1000,
-  plan: 1500,
-  repoMap: 2000,
-  gitDiff: 3000,
-  gitLog: 500,
-  fileTree: 1000,
-  readme: 800,
-};
-
-/**
- * Load context manifest from file, or return defaults.
- */
-export function loadContextManifest(ctxDir) {
-  const manifestPath = path.join(ctxDir, 'context-manifest.json');
-  try {
-    return JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-  } catch {
-    return DEFAULT_PROFILES;
-  }
-}
-
-/**
- * Get the context profile for an agent command.
- * Checks: agent frontmatter 'context-profile' → manifest → defaults.
- */
-export function getContextProfile(agentCommand, manifest = DEFAULT_PROFILES) {
-  return manifest[agentCommand] || ['state', 'repoMap']; // fallback: minimal
-}
-
-/**
- * Build context string for an agent based on its profile.
- * Returns { context: string, estimatedTokens: number, warnings: string[] }.
- */
-export function buildContext(agentCommand, projectDir, ctxDir, options = {}) {
-  const manifest = loadContextManifest(ctxDir);
-  const sources = getContextProfile(agentCommand, manifest);
-  const tokenLimit = options.tokenLimit || 100_000;
-
-  const sections = [];
-  let estimatedTokens = 0;
-  const warnings = [];
-
-  for (const source of sources) {
-    const { content, tokens } = loadSource(source, projectDir, ctxDir);
-    if (content) {
-      sections.push(content);
-      estimatedTokens += tokens;
-    }
-  }
-
-  if (estimatedTokens > tokenLimit * 0.8) {
-    warnings.push(`Context payload ~${estimatedTokens} tokens (${Math.round(estimatedTokens / tokenLimit * 100)}% of limit). Consider reducing context sources.`);
-  }
-
-  return {
-    context: sections.join('\n\n---\n\n'),
-    estimatedTokens,
-    warnings,
-  };
-}
-
-/**
- * Estimate token count from a string (chars / 4 approximation).
- */
-export function estimateTokens(text) {
-  return Math.ceil((text || '').length / 4);
-}
-
-// --- Source loaders ---
-
-function loadSource(source, projectDir, ctxDir) {
-  const loaders = {
-    state: () => safeRead(path.join(ctxDir, 'STATE.json'), '## Project State\n```json\n', '\n```'),
-    prd: () => loadPrdStory(ctxDir),
-    plan: () => loadCurrentPlan(ctxDir),
-    repoMap: () => safeRead(path.join(ctxDir, 'REPO-MAP.md'), '## Repository Map\n'),
-    gitDiff: () => loadGitDiff(projectDir),
-    gitLog: () => loadGitLog(projectDir),
-    fileTree: () => loadFileTree(projectDir),
-    readme: () => loadReadme(projectDir),
-  };
-
-  const loader = loaders[source];
-  if (!loader) return { content: null, tokens: 0 };
-
-  try {
-    const content = loader();
-    return { content, tokens: estimateTokens(content) };
-  } catch {
-    return { content: null, tokens: 0 };
-  }
-}
-
-function safeRead(filePath, prefix = '', suffix = '') {
-  try {
-    const content = fs.readFileSync(filePath, 'utf-8');
-    return `${prefix}${content}${suffix}`;
-  } catch {
-    return null;
-  }
-}
-
-function loadPrdStory(ctxDir) {
-  try {
-    const prd = JSON.parse(fs.readFileSync(path.join(ctxDir, 'PRD.json'), 'utf-8'));
-    const current = prd.metadata?.currentStory;
-    if (!current) return `## PRD\nProject: ${prd.project?.name || 'unknown'}\nNo active story.`;
-
-    const story = (prd.stories || []).find(s => s.id === current);
-    if (!story) return null;
-
-    return [
-      `## Active Story: ${story.id} — ${story.title}`,
-      story.description,
-      '',
-      '### Acceptance Criteria',
-      ...(story.acceptanceCriteria || []).map((c, i) => `${i + 1}. ${c}`),
-    ].join('\n');
-  } catch {
-    return null;
-  }
-}
-
-function loadCurrentPlan(ctxDir) {
-  try {
-    const state = JSON.parse(fs.readFileSync(path.join(ctxDir, 'STATE.json'), 'utf-8'));
-    const storyId = state.activeStory;
-    if (!storyId) return null;
-
-    const planPath = path.join(ctxDir, 'phases', storyId, 'PLAN.md');
-    return safeRead(planPath, '## Execution Plan\n');
-  } catch {
-    return null;
-  }
-}
-
-function loadGitDiff(projectDir) {
-  try {
-    const diff = execSync('git diff HEAD --stat --no-color 2>/dev/null && echo "---" && git diff HEAD --no-color 2>/dev/null', {
-      cwd: projectDir, encoding: 'utf-8', timeout: 10000, maxBuffer: 1024 * 1024,
-    }).trim();
-    if (!diff || diff === '---') return null;
-    // Truncate if too large
-    const maxChars = 12000; // ~3000 tokens
-    const truncated = diff.length > maxChars ? diff.slice(0, maxChars) + '\n\n... (diff truncated)' : diff;
-    return `## Git Diff\n\`\`\`diff\n${truncated}\n\`\`\``;
-  } catch {
-    return null;
-  }
-}
-
-function loadGitLog(projectDir) {
-  try {
-    const log = execSync('git log --oneline -10 --no-color 2>/dev/null', {
-      cwd: projectDir, encoding: 'utf-8', timeout: 5000,
-    }).trim();
-    return log ? `## Recent Commits\n\`\`\`\n${log}\n\`\`\`` : null;
-  } catch {
-    return null;
-  }
-}
-
-function loadFileTree(projectDir) {
-  try {
-    const tree = execSync(
-      'find . -type f -not -path "./.git/*" -not -path "./node_modules/*" -not -path "./.ctx/*" -not -path "./.next/*" -not -path "./dist/*" -not -path "./.cache/*" | head -200 | sort',
-      { cwd: projectDir, encoding: 'utf-8', timeout: 5000, maxBuffer: 512 * 1024 }
-    ).trim();
-    return tree ? `## File Tree\n\`\`\`\n${tree}\n\`\`\`` : null;
-  } catch {
-    return null;
-  }
-}
-
-function loadReadme(projectDir) {
-  try {
-    const readme = fs.readFileSync(path.join(projectDir, 'README.md'), 'utf-8');
-    const lines = readme.split('\n').slice(0, 100);
-    return `## README (first 100 lines)\n${lines.join('\n')}`;
-  } catch {
-    return null;
-  }
-}
-
-export { DEFAULT_PROFILES };