claude-code-conductor 0.0.1

package/conductor/tracks/rename_cli_20260107/spec.md

@@ -0,0 +1,25 @@
+# Specification: Rename to Claude Code Conductor
+
+## 1. Overview
+The project needs to be renamed from `claude-conductor` to `claude-code-conductor` because the former name is already taken on npm. This change will affect the package metadata, the CLI executable command, and user-facing documentation/strings. This is a "Surface Refactor," meaning internal code identifiers will largely remain unchanged to ensure stability.
+
+## 2. Functional Requirements
+1.  **Package Identity:**
+    *   Update `package.json` name to `claude-code-conductor`.
+    *   Update `package.json` description if necessary to reflect the new identity.
+2.  **CLI Command:**
+    *   Replace the `claude-conductor` binary command with `claude-code-conductor`.
+    *   Rename the bin script (e.g., `bin/claude-conductor.ts` -> `bin/claude-code-conductor.ts`).
+    *   Ensure `npm link` or `npm install -g` exposes the new command.
+3.  **User Interface:**
+    *   Update CLI output headers, help text, and welcome messages to read "Claude Code Conductor".
+    *   Update error messages that reference the tool name.
+
+## 3. Documentation
+1.  **README:** Update all references to the installation and usage commands.
+2.  **Conductor Docs:** Update `conductor/` context files (e.g., `product.md`, `tech-stack.md`) if they reference the CLI command explicitly.
+
+## 4. Out of Scope
+1.  Deep refactoring of internal TypeScript classes (e.g., `class ClaudeConductor` will remain as is).
+2.  Renaming of internal source files (other than the main bin entry point).
+3.  Backward compatibility aliases (the old command will be removed).

package/conductor/tracks.md

@@ -0,0 +1,11 @@
+# Project Tracks
+
+This file tracks all major tracks for the project. Each track has its own detailed plan in its respective folder.
+
+
+
+
+---
+
+## [x] Track: Rename claude-conductor to claude-code-conductor
+*Link: [./conductor/tracks/rename_cli_20260107/](./conductor/tracks/rename_cli_20260107/)*

package/conductor/workflow.md

@@ -0,0 +1,333 @@
+# Project Workflow
+
+## Guiding Principles
+
+1. **The Plan is the Source of Truth:** All work must be tracked in `plan.md`
+2. **The Tech Stack is Deliberate:** Changes to the tech stack must be documented in `tech-stack.md` *before* implementation
+3. **Test-Driven Development:** Write unit tests before implementing functionality
+4. **High Code Coverage:** Aim for >80% code coverage for all modules
+5. **User Experience First:** Every decision should prioritize user experience
+6. **Non-Interactive & CI-Aware:** Prefer non-interactive commands. Use `CI=true` for watch-mode tools (tests, linters) to ensure single execution.
+
+## Task Workflow
+
+All tasks follow a strict lifecycle:
+
+### Standard Task Workflow
+
+1. **Select Task:** Choose the next available task from `plan.md` in sequential order
+
+2. **Mark In Progress:** Before beginning work, edit `plan.md` and change the task from `[ ]` to `[~]`
+
+3. **Write Failing Tests (Red Phase):**
+   - Create a new test file for the feature or bug fix.
+   - Write one or more unit tests that clearly define the expected behavior and acceptance criteria for the task.
+   - **CRITICAL:** Run the tests and confirm that they fail as expected. This is the "Red" phase of TDD. Do not proceed until you have failing tests.
+
+4. **Implement to Pass Tests (Green Phase):**
+   - Write the minimum amount of application code necessary to make the failing tests pass.
+   - Run the test suite again and confirm that all tests now pass. This is the "Green" phase.
+
+5. **Refactor (Optional but Recommended):**
+   - With the safety of passing tests, refactor the implementation code and the test code to improve clarity, remove duplication, and enhance performance without changing the external behavior.
+   - Rerun tests to ensure they still pass after refactoring.
+
+6. **Verify Coverage:** Run coverage reports using the project's chosen tools. For example, in a Python project, this might look like:
+   ```bash
+   pytest --cov=app --cov-report=html
+   ```
+   Target: >80% coverage for new code. The specific tools and commands will vary by language and framework.
+
+7. **Document Deviations:** If implementation differs from tech stack:
+   - **STOP** implementation
+   - Update `tech-stack.md` with new design
+   - Add dated note explaining the change
+   - Resume implementation
+
+8. **Commit Code Changes:**
+   - Stage all code changes related to the task.
+   - Propose a clear, concise commit message e.g, `feat(ui): Create basic HTML structure for calculator`.
+   - Perform the commit.
+
+9. **Attach Task Summary with Git Notes:**
+   - **Step 9.1: Get Commit Hash:** Obtain the hash of the *just-completed commit* (`git log -1 --format="%H"`).
+   - **Step 9.2: Draft Note Content:** Create a detailed summary for the completed task. This should include the task name, a summary of changes, a list of all created/modified files, and the core "why" for the change.
+   - **Step 9.3: Attach Note:** Use the `git notes` command to attach the summary to the commit.
+     ```bash
+     # The note content from the previous step is passed via the -m flag.
+     git notes add -m "<note content>" <commit_hash>
+     ```
+
+10. **Get and Record Task Commit SHA:**
+    - **Step 10.1: Update Plan:** Read `plan.md`, find the line for the completed task, update its status from `[~]` to `[x]`, and append the first 7 characters of the *just-completed commit's* commit hash.
+    - **Step 10.2: Write Plan:** Write the updated content back to `plan.md`.
+
+11. **Commit Plan Update:**
+    - **Action:** Stage the modified `plan.md` file.
+    - **Action:** Commit this change with a descriptive message (e.g., `conductor(plan): Mark task 'Create user model' as complete`).
+
+### Phase Completion Verification and Checkpointing Protocol
+
+**Trigger:** This protocol is executed immediately after a task is completed that also concludes a phase in `plan.md`.
+
+1.  **Announce Protocol Start:** Inform the user that the phase is complete and the verification and checkpointing protocol has begun.
+
+2.  **Ensure Test Coverage for Phase Changes:**
+    -   **Step 2.1: Determine Phase Scope:** To identify the files changed in this phase, you must first find the starting point. Read `plan.md` to find the Git commit SHA of the *previous* phase's checkpoint. If no previous checkpoint exists, the scope is all changes since the first commit.
+    -   **Step 2.2: List Changed Files:** Execute `git diff --name-only <previous_checkpoint_sha> HEAD` to get a precise list of all files modified during this phase.
+    -   **Step 2.3: Verify and Create Tests:** For each file in the list:
+        -   **CRITICAL:** First, check its extension. Exclude non-code files (e.g., `.json`, `.md`, `.yaml`).
+        -   For each remaining code file, verify a corresponding test file exists.
+        -   If a test file is missing, you **must** create one. Before writing the test, **first, analyze other test files in the repository to determine the correct naming convention and testing style.** The new tests **must** validate the functionality described in this phase's tasks (`plan.md`).
+
+3.  **Execute Automated Tests with Proactive Debugging:**
+    -   Before execution, you **must** announce the exact shell command you will use to run the tests.
+    -   **Example Announcement:** "I will now run the automated test suite to verify the phase. **Command:** `CI=true npm test`"
+    -   Execute the announced command.
+    -   If tests fail, you **must** inform the user and begin debugging. You may attempt to propose a fix a **maximum of two times**. If the tests still fail after your second proposed fix, you **must stop**, report the persistent failure, and ask the user for guidance.
+
+4.  **Propose a Detailed, Actionable Manual Verification Plan:**
+    -   **CRITICAL:** To generate the plan, first analyze `product.md`, `product-guidelines.md`, and `plan.md` to determine the user-facing goals of the completed phase.
+    -   You **must** generate a step-by-step plan that walks the user through the verification process, including any necessary commands and specific, expected outcomes.
+    -   The plan you present to the user **must** follow this format:
+
+        **For a Frontend Change:**
+        ```
+        The automated tests have passed. For manual verification, please follow these steps:
+
+        **Manual Verification Steps:**
+        1.  **Start the development server with the command:** `npm run dev`
+        2.  **Open your browser to:** `http://localhost:3000`
+        3.  **Confirm that you see:** The new user profile page, with the user's name and email displayed correctly.
+        ```
+
+        **For a Backend Change:**
+        ```
+        The automated tests have passed. For manual verification, please follow these steps:
+
+        **Manual Verification Steps:**
+        1.  **Ensure the server is running.**
+        2.  **Execute the following command in your terminal:** `curl -X POST http://localhost:8080/api/v1/users -d '{"name": "test"}'`
+        3.  **Confirm that you receive:** A JSON response with a status of `201 Created`.
+        ```
+
+5.  **Await Explicit User Feedback:**
+    -   After presenting the detailed plan, ask the user for confirmation: "**Does this meet your expectations? Please confirm with yes or provide feedback on what needs to be changed.**"
+    -   **PAUSE** and await the user's response. Do not proceed without an explicit yes or confirmation.
+
+6.  **Create Checkpoint Commit:**
+    -   Stage all changes. If no changes occurred in this step, proceed with an empty commit.
+    -   Perform the commit with a clear and concise message (e.g., `conductor(checkpoint): Checkpoint end of Phase X`).
+
+7.  **Attach Auditable Verification Report using Git Notes:**
+    -   **Step 8.1: Draft Note Content:** Create a detailed verification report including the automated test command, the manual verification steps, and the user's confirmation.
+    -   **Step 8.2: Attach Note:** Use the `git notes` command and the full commit hash from the previous step to attach the full report to the checkpoint commit.
+
+8.  **Get and Record Phase Checkpoint SHA:**
+    -   **Step 7.1: Get Commit Hash:** Obtain the hash of the *just-created checkpoint commit* (`git log -1 --format="%H"`).
+    -   **Step 7.2: Update Plan:** Read `plan.md`, find the heading for the completed phase, and append the first 7 characters of the commit hash in the format `[checkpoint: <sha>]`.
+    -   **Step 7.3: Write Plan:** Write the updated content back to `plan.md`.
+
+9. **Commit Plan Update:**
+    - **Action:** Stage the modified `plan.md` file.
+    - **Action:** Commit this change with a descriptive message following the format `conductor(plan): Mark phase '<PHASE NAME>' as complete`.
+
+10.  **Announce Completion:** Inform the user that the phase is complete and the checkpoint has been created, with the detailed verification report attached as a git note.
+
+### Quality Gates
+
+Before marking any task complete, verify:
+
+- [ ] All tests pass
+- [ ] Code coverage meets requirements (>80%)
+- [ ] Code follows project's code style guidelines (as defined in `code_styleguides/`)
+- [ ] All public functions/methods are documented (e.g., docstrings, JSDoc, GoDoc)
+- [ ] Type safety is enforced (e.g., type hints, TypeScript types, Go types)
+- [ ] No linting or static analysis errors (using the project's configured tools)
+- [ ] Works correctly on mobile (if applicable)
+- [ ] Documentation updated if needed
+- [ ] No security vulnerabilities introduced
+
+## Development Commands
+
+**AI AGENT INSTRUCTION: This section should be adapted to the project's specific language, framework, and build tools.**
+
+### Setup
+```bash
+# Example: Commands to set up the development environment (e.g., install dependencies, configure database)
+# e.g., for a Node.js project: npm install
+# e.g., for a Go project: go mod tidy
+```
+
+### Daily Development
+```bash
+# Example: Commands for common daily tasks (e.g., start dev server, run tests, lint, format)
+# e.g., for a Node.js project: npm run dev, npm test, npm run lint
+# e.g., for a Go project: go run main.go, go test ./..., go fmt ./...
+```
+
+### Before Committing
+```bash
+# Example: Commands to run all pre-commit checks (e.g., format, lint, type check, run tests)
+# e.g., for a Node.js project: npm run check
+# e.g., for a Go project: make check (if a Makefile exists)
+```
+
+## Testing Requirements
+
+### Unit Testing
+- Every module must have corresponding tests.
+- Use appropriate test setup/teardown mechanisms (e.g., fixtures, beforeEach/afterEach).
+- Mock external dependencies.
+- Test both success and failure cases.
+
+### Integration Testing
+- Test complete user flows
+- Verify database transactions
+- Test authentication and authorization
+- Check form submissions
+
+### Mobile Testing
+- Test on actual iPhone when possible
+- Use Safari developer tools
+- Test touch interactions
+- Verify responsive layouts
+- Check performance on 3G/4G
+
+## Code Review Process
+
+### Self-Review Checklist
+Before requesting review:
+
+1. **Functionality**
+   - Feature works as specified
+   - Edge cases handled
+   - Error messages are user-friendly
+
+2. **Code Quality**
+   - Follows style guide
+   - DRY principle applied
+   - Clear variable/function names
+   - Appropriate comments
+
+3. **Testing**
+   - Unit tests comprehensive
+   - Integration tests pass
+   - Coverage adequate (>80%)
+
+4. **Security**
+   - No hardcoded secrets
+   - Input validation present
+   - SQL injection prevented
+   - XSS protection in place
+
+5. **Performance**
+   - Database queries optimized
+   - Images optimized
+   - Caching implemented where needed
+
+6. **Mobile Experience**
+   - Touch targets adequate (44x44px)
+   - Text readable without zooming
+   - Performance acceptable on mobile
+   - Interactions feel native
+
+## Commit Guidelines
+
+### Message Format
+```
+<type>(<scope>): <description>
+
+[optional body]
+
+[optional footer]
+```
+
+### Types
+- `feat`: New feature
+- `fix`: Bug fix
+- `docs`: Documentation only
+- `style`: Formatting, missing semicolons, etc.
+- `refactor`: Code change that neither fixes a bug nor adds a feature
+- `test`: Adding missing tests
+- `chore`: Maintenance tasks
+
+### Examples
+```bash
+git commit -m "feat(auth): Add remember me functionality"
+git commit -m "fix(posts): Correct excerpt generation for short posts"
+git commit -m "test(comments): Add tests for emoji reaction limits"
+git commit -m "style(mobile): Improve button touch targets"
+```
+
+## Definition of Done
+
+A task is complete when:
+
+1. All code implemented to specification
+2. Unit tests written and passing
+3. Code coverage meets project requirements
+4. Documentation complete (if applicable)
+5. Code passes all configured linting and static analysis checks
+6. Works beautifully on mobile (if applicable)
+7. Implementation notes added to `plan.md`
+8. Changes committed with proper message
+9. Git note with task summary attached to the commit
+
+## Emergency Procedures
+
+### Critical Bug in Production
+1. Create hotfix branch from main
+2. Write failing test for bug
+3. Implement minimal fix
+4. Test thoroughly including mobile
+5. Deploy immediately
+6. Document in plan.md
+
+### Data Loss
+1. Stop all write operations
+2. Restore from latest backup
+3. Verify data integrity
+4. Document incident
+5. Update backup procedures
+
+### Security Breach
+1. Rotate all secrets immediately
+2. Review access logs
+3. Patch vulnerability
+4. Notify affected users (if any)
+5. Document and update security procedures
+
+## Deployment Workflow
+
+### Pre-Deployment Checklist
+- [ ] All tests passing
+- [ ] Coverage >80%
+- [ ] No linting errors
+- [ ] Mobile testing complete
+- [ ] Environment variables configured
+- [ ] Database migrations ready
+- [ ] Backup created
+
+### Deployment Steps
+1. Merge feature branch to main
+2. Tag release with version
+3. Push to deployment service
+4. Run database migrations
+5. Verify deployment
+6. Test critical paths
+7. Monitor for errors
+
+### Post-Deployment
+1. Monitor analytics
+2. Check error logs
+3. Gather user feedback
+4. Plan next iteration
+
+## Continuous Improvement
+
+- Review workflow weekly
+- Update based on pain points
+- Document lessons learned
+- Optimize for user happiness
+- Keep things simple and maintainable

package/dist/bin/claude-code-conductor.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const setup_1 = require("../src/commands/setup");
+const implement_1 = require("../src/commands/implement");
+const status_1 = require("../src/commands/status");
+const init_1 = require("../src/commands/init");
+const program = new commander_1.Command();
+// Read package.json securely
+const packageJsonPath = path_1.default.join(__dirname, '../package.json');
+const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf8'));
+program
+    .version(packageJson.version)
+    .description(chalk_1.default.blue('Claude Code Conductor: A context-driven wrapper for Claude Code'));
+(0, setup_1.registerSetupCommand)(program);
+(0, implement_1.registerImplementCommand)(program);
+(0, status_1.registerStatusCommand)(program);
+(0, init_1.registerInitCommand)(program);
+program.action(() => {
+    console.log(chalk_1.default.green('Welcome to Claude Code Conductor!'));
+    program.help();
+});
+program.parse(process.argv);

package/dist/bin/claude-conductor.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const setup_1 = require("../src/commands/setup");
+const implement_1 = require("../src/commands/implement");
+const status_1 = require("../src/commands/status");
+const init_1 = require("../src/commands/init");
+const program = new commander_1.Command();
+// Read package.json securely
+const packageJsonPath = path_1.default.join(__dirname, '../package.json');
+const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf8'));
+program
+    .version(packageJson.version)
+    .description(chalk_1.default.blue('Conductor: A context-driven wrapper for Claude Code'));
+(0, setup_1.registerSetupCommand)(program);
+(0, implement_1.registerImplementCommand)(program);
+(0, status_1.registerStatusCommand)(program);
+(0, init_1.registerInitCommand)(program);
+program.action(() => {
+    console.log(chalk_1.default.green('Welcome to Conductor!'));
+    program.help();
+});
+program.parse(process.argv);

package/dist/src/commands/implement.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerImplementCommand = registerImplementCommand;
+const chalk_1 = __importDefault(require("chalk"));
+function registerImplementCommand(program) {
+    program
+        .command('implement')
+        .description('Implement a selected track')
+        .action(() => {
+        console.log(chalk_1.default.yellow('Implement command is not yet implemented.'));
+    });
+}

package/dist/src/commands/init.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerInitCommand = registerInitCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const CommandRegistrar_1 = require("../services/CommandRegistrar");
+function registerInitCommand(program) {
+    program
+        .command('init')
+        .description('Initialize Conductor commands in the workspace')
+        .action(async () => {
+        console.log(chalk_1.default.blue('Init command initiated'));
+        try {
+            await CommandRegistrar_1.CommandRegistrar.registerCommands(process.cwd());
+            console.log(chalk_1.default.green('Successfully registered Conductor commands in .claude/commands'));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Failed to register commands:'), error);
+            process.exit(1);
+        }
+    });
+}

package/dist/src/commands/setup.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSetupCommand = registerSetupCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ProjectDiscovery_1 = require("../services/ProjectDiscovery");
+const SetupWizard_1 = require("../services/SetupWizard");
+const FileGenerator_1 = require("../services/FileGenerator");
+function registerSetupCommand(program) {
+    program
+        .command('setup')
+        .description('Initialize or adopt a project into the Conductor workflow')
+        .action(async () => {
+        console.log(chalk_1.default.blue('Setup command initiated'));
+        // 1. Discovery
+        const projectType = await ProjectDiscovery_1.ProjectDiscovery.detectType(process.cwd());
+        console.log(chalk_1.default.green(`Detected Project Type: ${projectType}`));
+        if (projectType === ProjectDiscovery_1.ProjectType.BROWNFIELD) {
+            console.log(chalk_1.default.yellow('Note: Existing project structure detected. Setup will adopt existing files.'));
+        }
+        // 2. Wizard
+        const productDefinition = await SetupWizard_1.SetupWizard.collectProductDefinition();
+        // 3. Generation
+        console.log(chalk_1.default.blue('Generating Conductor files...'));
+        await FileGenerator_1.FileGenerator.generateFiles(process.cwd(), productDefinition);
+        console.log(chalk_1.default.green('Setup complete! Welcome to Claude Code Conductor.'));
+    });
+}

package/dist/src/commands/status.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerStatusCommand = registerStatusCommand;
+const chalk_1 = __importDefault(require("chalk"));
+function registerStatusCommand(program) {
+    program
+        .command('status')
+        .description('Check the status of project tracks')
+        .action(() => {
+        console.log(chalk_1.default.yellow('Status command is not yet implemented.'));
+    });
+}

package/dist/src/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.placeholder = void 0;
+exports.placeholder = true;

package/dist/src/services/CommandRegistrar.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandRegistrar = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+class CommandRegistrar {
+    static async ensureCommandsDir(cwd) {
+        const commandsDir = path_1.default.join(cwd, '.claude/commands');
+        await fs_extra_1.default.ensureDir(commandsDir);
+        return commandsDir;
+    }
+    static async registerCommands(cwd) {
+        const commandsDir = await this.ensureCommandsDir(cwd);
+        const commands = ['setup', 'implement', 'status'];
+        for (const cmd of commands) {
+            const scriptPath = path_1.default.join(commandsDir, `conductor:${cmd}`);
+            const content = `#!/bin/sh\nnpx claude-code-conductor ${cmd} "$@"\n`;
+            await fs_extra_1.default.writeFile(scriptPath, content);
+            await fs_extra_1.default.chmod(scriptPath, '755');
+        }
+    }
+}
+exports.CommandRegistrar = CommandRegistrar;

package/dist/src/services/FileGenerator.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileGenerator = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+class FileGenerator {
+    static async generateFiles(cwd, definition) {
+        const conductorDir = path_1.default.join(cwd, 'conductor');
+        await fs_extra_1.default.ensureDir(conductorDir);
+        // 1. product.md
+        const productContent = `# Product: ${definition.productName}
+
+## Description
+${definition.productDescription}
+`;
+        await fs_extra_1.default.outputFile(path_1.default.join(conductorDir, 'product.md'), productContent);
+        // 2. tech-stack.md
+        const techStackContent = `# Tech Stack
+
+${definition.techStack}
+`;
+        await fs_extra_1.default.outputFile(path_1.default.join(conductorDir, 'tech-stack.md'), techStackContent);
+        // 3. product-guidelines.md
+        const guidelinesContent = `# Product Guidelines
+
+## Tone & Style
+${definition.guidelines}
+`;
+        await fs_extra_1.default.outputFile(path_1.default.join(conductorDir, 'product-guidelines.md'), guidelinesContent);
+        // 4. setup_state.json
+        const state = {
+            setupComplete: true,
+            generatedAt: new Date().toISOString(),
+            productName: definition.productName
+        };
+        await fs_extra_1.default.outputJSON(path_1.default.join(conductorDir, 'setup_state.json'), state, { spaces: 2 });
+    }
+}
+exports.FileGenerator = FileGenerator;

package/dist/src/services/ProjectDiscovery.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectDiscovery = exports.ProjectType = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+var ProjectType;
+(function (ProjectType) {
+    ProjectType["GREENFIELD"] = "GREENFIELD";
+    ProjectType["BROWNFIELD"] = "BROWNFIELD";
+})(ProjectType || (exports.ProjectType = ProjectType = {}));
+const BROWNFIELD_INDICATORS = [
+    '.git',
+    'package.json',
+    'pom.xml',
+    'build.gradle',
+    'build.gradle.kts',
+    'requirements.txt',
+    'Pipfile',
+    'pyproject.toml',
+    'Cargo.toml',
+    'go.mod',
+    'composer.json',
+    'Gemfile',
+    'mix.exs',
+    'Makefile',
+    'README.md', // Presence of README often indicates an initialized project
+    'README.txt'
+];
+class ProjectDiscovery {
+    static async detectType(cwd) {
+        // Check for specific indicator files/directories
+        for (const indicator of BROWNFIELD_INDICATORS) {
+            const exists = await fs_extra_1.default.pathExists(path_1.default.join(cwd, indicator));
+            if (exists) {
+                return ProjectType.BROWNFIELD;
+            }
+        }
+        // Also check if directory is not empty (ignoring system files like .DS_Store if we wanted to be robust, but strict empty check is usually fine for "Greenfield")
+        // For now, if no indicators are found, we assume Greenfield. 
+        // Ideally, we might check if *any* file exists, but "Greenfield" usually implies we are setting up completely new structure.
+        // However, the spec says "Check for .git... Check for package.json... If no indicators, classify as Greenfield".
+        return ProjectType.GREENFIELD;
+    }
+}
+exports.ProjectDiscovery = ProjectDiscovery;