@iservu-inc/adf-cli 0.13.0 → 0.14.0

package/.context/memory/architecture.md

@@ -0,0 +1,40 @@
+# System Architecture
+
+## Overview
+ADF CLI is a Node.js-based command-line tool designed to orchestrate AI-assisted software development. It functions as a "Conductor," guiding users through requirements gathering, generating framework-specific artifacts, and deploying configurations to various development tools.
+
+## Core Components
+
+### 1. CLI Entry Point (`bin/adf.js`)
+- Uses `commander.js` for argument parsing and command routing.
+- Commands: `init`, `config`, `deploy`, `update`.
+
+### 2. Interview System (`lib/frameworks/`)
+- **Interviewer:** Orchestrates the question-answer flow.
+- **Dynamic Pipeline:** Adapts questions based on real-time answer quality analysis and learned patterns.
+- **Session Manager:** Handles state persistence (resume capability) and data integrity.
+
+### 3. AI Layer (`lib/ai/`)
+- **Unified Client:** Abstracts provider differences (Anthropic, OpenAI, Google Gemini, OpenRouter).
+- **Context Engineering:** Manages prompt construction and context window optimization.
+
+### 4. Learning System (`lib/learning/`)
+- **Tracker:** Records user behaviors (skips, answer length).
+- **Pattern Detector:** Identifies consistent habits.
+- **Decay Manager:** Applies time-based decay to pattern confidence to ensure freshness.
+
+### 5. Generators (`lib/generators/`)
+- **Artifact Generators:** Create PRP, BMAD, and Spec-Kit documents.
+- **Tool Config Generators:** Produce tool-specific configurations (e.g., `.windsurfrules`, `opencode.json`, `AGENTS.md`).
+
+## Data Storage
+
+### Project Local (`.adf/`)
+- **Sessions:** JSON transcripts and outputs of interview sessions.
+- **Learning:** Local user behavior data (never synced remotely).
+- **Config:** API keys (`.env`) and user preferences.
+
+## Design Patterns
+- **Agent-Native:** The repository itself follows the Agent-Native standard (`AGENTS.md` + `.context/`).
+- **Triple-Redundancy:** Critical session data is saved to multiple formats/locations to prevent data loss.
+- **Plugin Architecture:** (Planned) To support custom frameworks and tools.

package/.context/memory/glossary.md

@@ -0,0 +1,19 @@
+# Project Glossary
+
+## Core Terms
+
+- **ADF (Agent Development Framework):** The overarching framework for AI-assisted software development.
+- **Conductor:** The methodology and CLI subsystem for managing project state, tracks, and workflow.
+- **Track:** A unit of work or feature development path (e.g., a feature, bug fix, or chore).
+- **PRP (Product Requirements Prompt):** A framework for "Rapid" requirements gathering.
+- **BMAD (Business, Marketing, Architecture, Design):** A comprehensive framework for large-scale project planning.
+- **Spec-Kit:** A balanced framework generating specifications and plans.
+- **Agent-Native:** A repository structure optimized for reading by AI agents (e.g., `AGENTS.md`, `.context/`).
+- **Learning System:** The ADF subsystem that tracks user behavior (skips, answers) to adapt future interviews.
+- **Pattern Decay:** The algorithm that reduces confidence in learned patterns over time to prevent stale assumptions.
+
+## Directory Structure Terms
+
+- **.adf/:** Internal storage for ADF (sessions, learning data, local config).
+- **.context/:** Deep context storage for Agent-Native documentation (architecture, memory).
+- **conductor/:** Project management files (product guide, tracks, plans).

package/.project/docs/VERSIONING-GUIDE.md

@@ -0,0 +1,127 @@
+# ADF CLI Versioning Guide
+
+## Semantic Versioning Format
+
+**Format:** `<major>.<minor>.<patch>`
+
+**Current Version:** 0.13.0
+
+## Version Number Structure
+
+### Major Release (X.0.0)
+**When to increment:**
+- Breaking API changes
+- Incompatible changes to existing functionality
+- Major architectural changes that affect users
+- Removal of deprecated features
+
+**Example:** 0.x.x → 1.0.0
+
+### Minor Release (0.X.0)
+**When to increment:**
+- New features added
+- New functionality that is backward-compatible
+- Significant enhancements to existing features
+- New tool integrations
+- New commands or options
+
+**Example:** 0.12.x → 0.13.0
+
+**Recent Minor Releases:**
+- 0.13.0 - OpenCode multi-agent integration
+- 0.12.0 - Guide system and multi-tool expansion
+- 0.11.0 - Initial tool deployment system
+
+### Patch Release (0.0.X)
+**When to increment:**
+- Bug fixes
+- Documentation corrections
+- Minor improvements
+- Performance optimizations
+- Dependency updates (non-breaking)
+
+**Example:** 0.13.0 → 0.13.1
+
+**Recent Patch Releases:**
+- 0.12.14 - Windsurf character limit fix
+- 0.12.13 - Guide hallucination fixes
+- 0.12.12 - Guide system improvements
+- 0.12.11 - Missing helper methods fix
+- 0.12.10 - EISDIR and rate limit fixes
+
+## Version Update Checklist
+
+When releasing a new version:
+
+### 1. Update Version Number
+```bash
+# In package.json
+"version": "0.13.1"
+```
+
+### 2. Update CHANGELOG.md
+```markdown
+## [0.13.1] - YYYY-MM-DD
+
+### 🐛 Fixed / ✨ Added / 🚀 Enhanced
+
+- Description of changes
+```
+
+### 3. Commit Changes
+```bash
+git add package.json CHANGELOG.md
+git commit -m "chore: bump version to 0.13.1"
+git push origin development
+```
+
+### 4. Publish to npm
+```bash
+npm publish
+```
+
+### 5. Create Git Tag (Optional)
+```bash
+git tag v0.13.1
+git push origin v0.13.1
+```
+
+## Decision Guide
+
+**Choose the version increment based on changes:**
+
+| Change Type | Version Bump | Example |
+|-------------|-------------|---------|
+| Breaking change | Major (X.0.0) | Remove deprecated API |
+| New feature | Minor (0.X.0) | Add new command or tool |
+| Bug fix | Patch (0.0.X) | Fix deployment error |
+| Typo/docs | Patch (0.0.X) | Fix CHANGELOG typo |
+| Dependency update | Patch (0.0.X) | Update chalk to 5.x |
+
+## Next Version Suggestions
+
+**For next release after 0.13.0:**
+
+- **0.13.1** - Bug fixes, documentation updates, minor improvements
+- **0.14.0** - New features, new tool integrations, significant enhancements
+- **1.0.0** - Production-ready release with stable API
+
+## Pre-Release Versions
+
+For beta/alpha releases:
+- **0.13.0-alpha.1** - Alpha release
+- **0.13.0-beta.1** - Beta release
+- **0.13.0-rc.1** - Release candidate
+
+## Reminder for Next Version
+
+**When bumping version:**
+1. ✅ Update `package.json`
+2. ✅ Update `CHANGELOG.md`
+3. ✅ Commit with message: `chore: bump version to X.X.X`
+4. ✅ Push to remote
+5. ✅ Run `npm publish`
+6. ✅ Create git tag (optional)
+
+**Next likely version: 0.13.1** (for patches/fixes)
+**Or: 0.14.0** (for new features)

package/AGENTS.md

@@ -0,0 +1,53 @@
+---
+name: ADF CLI
+description: The Agent Development Framework CLI tool for AI-assisted software engineering.
+tools:
+  - name: project_context
+    command: npx
+    args: ["@modelcontextprotocol/server-filesystem", ".context"]
+---
+
+# AGENTS.md
+
+> **This is the Agent-Native Manifest for the ADF CLI project.**
+> AI Agents (Windsurf, Cursor, Zed, etc.) must read this file first to understand the operational protocols.
+
+## 1. Operational Protocols (CRITICAL)
+
+### 1.1 Development Workflow
+- **Spec-Driven:** All changes must be tracked in a Conductor Track (`conductor/tracks/`).
+- **TDD:** Write unit tests (`tests/*.test.js`) before implementing functionality.
+- **Commit Style:** Use Conventional Commits (e.g., `feat:`, `fix:`, `docs:`).
+- **Code Coverage:** Maintain >80% coverage.
+
+### 1.2 Context & Memory
+- **Architecture:** Consult [.context/memory/architecture.md](./.context/memory/architecture.md) for system design.
+- **Glossary:** Consult [.context/memory/glossary.md](./.context/memory/glossary.md) for terminology.
+- **Product Vision:** Consult [conductor/product.md](./conductor/product.md).
+
+## 2. Standard Commands
+
+| Action | Command | Description |
+| :--- | :--- | :--- |
+| **Install** | `npm install` | Install dependencies |
+| **Test** | `npm test` | Run all unit tests |
+| **Lint** | `npm run lint` | Run code linting |
+| **Build** | `npm run build` | Build the project (if applicable) |
+| **Link** | `npm link` | Link CLI globally for local testing |
+
+## 3. Project Structure
+
+- `bin/` - CLI entry point (`adf.js`).
+- `lib/` - Source code.
+    - `commands/` - CLI command handlers.
+    - `frameworks/` - Interview logic and frameworks (PRP, BMAD).
+    - `generators/` - Artifact generators.
+    - `ai/` - AI provider integration.
+- `tests/` - Jest unit tests (mirror `lib/` structure).
+- `.context/` - Agent-Native deep context (Memory, Skills).
+- `conductor/` - Project management (Tracks, Plans).
+
+## 4. Key Conventions
+- **No External Database:** All data is stored in JSON/Markdown within `.adf/`.
+- **Triple Redundancy:** Save session data frequently to prevent loss.
+- **Privacy:** Never transmit learning data; keep it local.

package/CHANGELOG.md

@@ -5,6 +5,53 @@ All notable changes to `@iservu-inc/adf-cli` will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.14.0] - 2026-01-12
+
+### 🚀 Major Feature - Project Context Synthesis & Adaptive Augmentation
+
+**Minor Release:** Significant enhancement to brownfield project support with intelligent context synthesis and expanded AI-native tool integration.
+
+#### Added
+
+**Project Context Synthesis (Seamless Merge):**
+- ✨ **Adaptive Project Augmentation** - Detects and synthesizes existing `.adf`, BMAD, OpenSpec, and Spec-Kit project files.
+- ✨ **Context Extraction Engine** - Intelligently parses existing PRDs, proposals, and specifications into a unified ADF session.
+- ✨ **AI-Driven Gap Analysis** - Uses LLM to identify logical omissions and vague sections in synthesized context.
+- ✨ **Dynamic Questionnaire** - Generates targeted questions to fill identified "Knowledge Gaps," saving time by skipping redundant interview steps.
+- ✨ **Session Chain Versioning** - Implements a linear history of project augmentations via versioned session folders (e.g., `augmentation_v1`).
+
+**Extended Tool Support:**
+- 🛠️ **Deep IDE Integration** - Added native generators for:
+  - **Kiro** (`.kiro/product.md`, `.kiro/technical.md`)
+  - **Trae** (`.trae/config.json`)
+  - **Codex CLI** (`.codex/config.toml`, `.codex/instructions.md`)
+- 🛠️ **Tool Audit Registry** - New command `adf tools audit` provides a real-time report of supported tools, configuration files, and active features.
+- 🛠️ **Verified Support** - Updated and verified deployment logic for OpenCode, Gemini CLI, Abacus.ai (DeepAgent), and Claude Code.
+
+#### Technical Details
+
+**New Files:**
+- `lib/utils/framework-detector.js` - Multi-framework detection logic
+- `lib/utils/context-extractor.js` - Cross-framework artifact parsing
+- `lib/utils/tool-feature-registry.js` - Centralized tool metadata
+- `lib/analysis/synthesis-engine.js` - Context merging and session creation
+- `lib/analysis/heuristic-gap-analyzer.js` - Mandatory field verification
+- `lib/analysis/ai-gap-analyzer.js` - LLM-powered context verification
+- `lib/analysis/dynamic-question-generator.js` - Targeted interview generation
+- `lib/generators/kiro-generator.js`, `lib/generators/trae-generator.js`, `lib/generators/codex-cli-generator.js` - New IDE config generators
+- `lib/commands/tools.js` - Implementation of the audit command
+
+**Modified Files:**
+- `lib/commands/deploy.js` - Integrated 3 new tool targets
+- `lib/generators/index.js` - Exported new generators
+- `bin/adf.js` - Added `tools` sub-command
+
+#### Impact
+- ✅ Enables "ADF-centric" synthesis of pre-existing development framework data.
+- ✅ Minimizes interview fatigue by only asking for missing information.
+- ✅ Expands deployment reach to 12+ AI-native development environments.
+- ✅ Future-proofs tool support via the Audit Registry.
+
 ## [0.13.0] - 2026-01-03
 
 ### 🚀 Major Feature - OpenCode Multi-Agent Integration

package/bin/adf.js

@@ -21,6 +21,7 @@ const deployCommand = require('../lib/commands/deploy');
 const updateCommand = require('../lib/commands/update');
 const configCommand = require('../lib/commands/config');
 const guideCommand = require('../lib/commands/guide');
+const toolsCommand = require('../lib/commands/tools');
 
 const program = new Command();
 
@@ -471,6 +472,15 @@ ${chalk.cyan.bold('Security Notes:')}
 `)
   .action(configCommand);
 
+// adf tools
+const tools = program.command('tools');
+tools.description('Manage and audit tool integrations');
+
+tools
+  .command('audit')
+  .description('Audit all supported tools and features')
+  .action(toolsCommand);
+
 // Handle unknown commands
 program.on('command:*', () => {
   console.error(chalk.red(`\nInvalid command: ${program.args.join(' ')}`));

package/conductor/archive/context_synthesis_20260112/metadata.json

@@ -0,0 +1,8 @@
+{
+  "track_id": "context_synthesis_20260112",
+  "type": "feature",
+  "status": "new",
+  "created_at": "2026-01-12T12:35:00Z",
+  "updated_at": "2026-01-12T12:35:00Z",
+  "description": "Project Context Synthesis: Adaptive Project Augmentation for Existing .adf, BMAD, OpenSpec, and Spec-Kit Projects, including Extended Tool Support (Kiro, Trae, Codex CLI, etc.)"
+}

package/conductor/archive/context_synthesis_20260112/plan.md

@@ -0,0 +1,40 @@
+# Implementation Plan: Project Context Synthesis (Adaptive Augmentation)
+
+## Phase 1: Core Synthesis Engine [checkpoint: 3c7c462]
+- [x] Task: Implement `FrameworkDetector` utility to scan for `.adf`, `BMAD`, `OpenSpec`, and `Spec-Kit` markers. [commit: c6e6af7]
+    - [x] Subtask: Create unit tests for detector with mock project structures.
+    - [x] Subtask: Implement detection logic for each framework.
+- [x] Task: Create `ContextExtractor` to parse markdown artifacts from detected frameworks. [commit: 3d8ca9e]
+    - [x] Subtask: Write tests for parsing BMAD PRDs and OpenSpec proposals.
+    - [x] Subtask: Implement markdown parsing and data extraction logic.
+- [x] Task: Implement `SynthesisEngine` to merge extracted data into a unified ADF session structure. [commit: 772430d]
+    - [x] Subtask: Write tests for merging overlapping data from different frameworks.
+    - [x] Subtask: Implement merge logic and "Session Chain" versioning (copying base context to new session).
+- [x] Task: Conductor - User Manual Verification 'Core Synthesis Engine' (Protocol in workflow.md) [commit: 3c7c462]
+
+## Phase 2: Adaptive Augmentation (Gap Analysis) [checkpoint: d4e776e]
+- [x] Task: Implement `HeuristicGapAnalyzer` to identify missing mandatory framework artifacts. [commit: 8dcbb35]
+    - [x] Subtask: Write tests for heuristic checks across different framework levels.
+    - [x] Subtask: Implement requirement mapping logic.
+- [x] Task: Implement `AIGapAnalyzer` using LLM to identify logical omissions in synthesized context. [commit: bf77067]
+    - [x] Subtask: Write tests for AI analysis prompts and response parsing.
+    - [x] Subtask: Implement AI analysis logic using the existing AI client.
+- [x] Task: Create `DynamicQuestionGenerator` to produce a targeted questionnaire based on identified gaps. [commit: f186e1b]
+    - [x] Subtask: Write tests for question generation from gap reports.
+    - [x] Subtask: Implement dynamic questionnaire generation logic.
+- [x] Task: Conductor - User Manual Verification 'Adaptive Augmentation' (Protocol in workflow.md) [commit: d4e776e]
+
+## Phase 3: Extended Tool Support & Feature Registry [checkpoint: 8906f2b]
+- [x] Task: Implement `KiroGenerator` and `TraeGenerator`. [commit: 044247e]
+    - [x] Subtask: Write tests for Kiro and Trae configuration output.
+    - [x] Subtask: Implement generators using the identified templates.
+- [x] Task: Implement `CodexCLIGenerator` and update existing generators (Gemini, OpenCode, DeepAgent). [commit: d59c0b9]
+    - [x] Subtask: Write tests for Codex CLI (TOML) and updated generator features.
+    - [x] Subtask: Implement/Update generators with deep feature integration.
+- [x] Task: Create `ToolFeatureRegistry` and `adf tools audit` command. [commit: ee23b7b]
+    - [x] Subtask: Write tests for tool auditing and feature tracking.
+    - [x] Subtask: Implement registry logic and the CLI sub-menu.
+- [x] Task: Update `deploy` command to support all new tools and the augmentation workflow. [commit: 98273fd]
+    - [x] Subtask: Write integration tests for multi-tool deployment from augmented context.
+    - [x] Subtask: Update `lib/commands/deploy.js` with new tool mappings.
+- [x] Task: Conductor - User Manual Verification 'Extended Tool Support' (Protocol in workflow.md) [commit: 8906f2b]

package/conductor/archive/context_synthesis_20260112/spec.md

@@ -0,0 +1,43 @@
+# Specification: Project Context Synthesis (Adaptive Augmentation)
+
+## 1. Overview
+**Goal:** Enable the "Project Context Synthesis" feature to intelligently detect and augment existing development projects (.adf, BMAD, OpenSpec, Spec-Kit). This allows users to enhance project requirements and tool support without restarting the full interview process.
+
+**Scope:** 
+- Automated detection of existing framework indicators.
+- Synthesis of found context into a unified ADF session.
+- AI-driven "Knowledge Gap" analysis.
+- Implementation of extended tool support for Kiro, Trae, Codex CLI, etc.
+- A new "Tool Feature Update Registry" for future-proofing.
+
+## 2. Functional Requirements
+
+### 2.1 Project Detection & Synthesis (Seamless Merge)
+- **Framework Detection:** Scan for indicators of `.adf`, `BMAD`, `OpenSpec`, and `Spec-Kit`.
+- **Context Extraction:** Parse existing markdown artifacts from detected frameworks to populate the initial knowledge graph.
+- **Synthesis Engine:** Merge extracted data into a new `.adf` session folder following the "Session Chain" versioning approach.
+
+### 2.2 Adaptive Augmentation (The "Gap" System)
+- **Heuristic Check:** Identify missing mandatory artifacts based on the selected framework level.
+- **AI Gap Analysis:** Use the LLM to identify logical omissions or vague sections in the synthesized context.
+- **Dynamic Questionnaire:** Generate and present only the questions needed to fill the identified gaps.
+
+### 2.3 Extended Tool Support & Registry
+- **New Generators:** Implement generators for Kiro, Trae, and Codex CLI.
+- **Updated Generators:** Ensure full compliance and deep feature integration for OpenCode, Gemini CLI, Abacus.ai, and Claude Code.
+- **Tool Feature Update Registry:** Implement a new CLI sub-menu (`adf tools audit`) to manually check and define the latest features for each supported tool.
+
+### 2.4 Versioning (Session Chain)
+- Every augmentation creates a new session folder (e.g., `YYYY-MM-DD_augmentation_v1`).
+- The system must carry forward all prior context to the new session while preserving the original historical record.
+
+##  acceptance Criteria
+- [ ] Successfully detects a project containing only OpenSpec or BMAD files and creates a valid `.adf` structure.
+- [ ] Correctly identifies "Knowledge Gaps" in a project that has a PRD but no Technical Specification.
+- [ ] Generates valid configuration files for Kiro and Trae during the `deploy` command.
+- [ ] Allows users to resume an augmented session if interrupted.
+- [ ] The `adf tools audit` command successfully lists features and version support for all 10+ target tools.
+
+## 4. Out of Scope
+- Automatic conversion of existing code logic between different programming languages.
+- Modification of non-framework related project files (e.g., `src/`, `package-lock.json`).

package/conductor/archive/verify_opencode_20260111/metadata.json

@@ -0,0 +1,8 @@
+{
+  "track_id": "verify_opencode_20260111",
+  "type": "feature",
+  "status": "new",
+  "created_at": "2026-01-11T16:37:00Z",
+  "updated_at": "2026-01-11T16:37:00Z",
+  "description": "Verify and Enhance OpenCode CLI Integration"
+}

package/conductor/archive/verify_opencode_20260111/plan.md

@@ -0,0 +1,34 @@
+# Implementation Plan: Verify and Enhance OpenCode CLI Integration
+
+## Phase 1: Audit & Analysis [checkpoint: d2a2020]
+- [x] Task: Review `opencode-generator.js` against OpenCode CLI documentation.
+    - [x] Subtask: Analyze current implementation in `lib/generators/opencode-generator.js`.
+    - [x] Subtask: Compare against latest OpenCode docs (https://opencode.ai/docs/cli/).
+    - [x] Subtask: Document identified gaps or deprecated patterns.
+- [x] Task: Conductor - User Manual Verification 'Audit & Analysis' (Protocol in workflow.md)
+
+## Phase 2: Test Enhancement (TDD)
+- [~] Task: Update and Expand Unit Tests.
+    - [ ] Subtask: Review existing tests in `tests/opencode-generator.test.js` (if exists) or create new.
+    - [ ] Subtask: Write failing tests for identified gaps (Validation, AGENTS.md support).
+    - [ ] Subtask: Ensure tests cover edge cases (missing params, invalid configs).
+- [ ] Task: Conductor - User Manual Verification 'Test Enhancement (TDD)' (Protocol in workflow.md)
+
+## Phase 3: Implementation & Refactoring [checkpoint: daee799]
+- [x] Task: Implement/Update Validation Logic. [commit: a27fe6d]
+    - [x] Subtask: Update `opencode-generator.js` to validate config before generation.
+    - [x] Subtask: Implement specific checks for OpenCode requirements.
+    - [x] Subtask: Run tests to verify implementation (Red-Green-Refactor).
+- [x] Task: Enhance Integration Logic. [commit: aba1a88]
+    - [x] Subtask: Ensure seamless integration with `deploy.js`.
+    - [x] Subtask: Add any missing hooks for post-deployment actions.
+- [x] Task: Conductor - User Manual Verification 'Implementation & Refactoring' (Protocol in workflow.md)
+
+## Phase 4: Final Verification
+- [x] Task: Manual Deployment Verification.
+    - [x] Subtask: Run `adf deploy opencode` in a local test project.
+    - [x] Subtask: Verify the generated output file structure and content.
+- [x] Task: Final Code Quality Check.
+    - [x] Subtask: Run full test suite `npm test`.
+    - [x] Subtask: Check code coverage report.
+- [x] Task: Conductor - User Manual Verification 'Final Verification' (Protocol in workflow.md)

package/conductor/archive/verify_opencode_20260111/spec.md

@@ -0,0 +1,25 @@
+# Specification: Verify and Enhance OpenCode CLI Integration
+
+## 1. Goal
+Ensure the `opencode-generator.js` is fully compatible with the latest OpenCode CLI standards, robustly handles edge cases, and correctly generates the required configuration artifacts.
+
+## 2. Context
+The ADF CLI currently supports multiple tools including OpenCode. We need to verify the current implementation against the latest documentation (https://opencode.ai/docs/cli/) and ensure the generator aligns with the project's "Agent-Native" architecture.
+
+## 3. Requirements
+
+### 3.1 Functional Requirements
+*   **Audit Existing Generator:** Review `lib/generators/opencode-generator.js` for deprecated patterns or missing features.
+*   **Validation Logic:** Implement robust validation for generated configurations to prevent invalid deployments.
+*   **Deployment Hooks:** Ensure the generator correctly interacts with the deployment pipeline (`lib/commands/deploy.js`).
+*   **AGENTS.md Compliance:** Ensure the generator respects and utilizes the `AGENTS.md` standard if present.
+
+### 3.2 Non-Functional Requirements
+*   **Test Coverage:** Maintain >80% test coverage for the generator.
+*   **Error Handling:** Provide clear, actionable error messages for validation failures.
+
+## 4. Success Criteria
+*   [ ] `opencode-generator.js` passes all existing and new unit tests.
+*   [ ] Generated configuration files are valid according to OpenCode CLI specs.
+*   [ ] `adf deploy opencode` works seamlessly in a test environment.
+*   [ ] Code coverage for `opencode-generator.js` is >= 80%.

package/conductor/code_styleguides/javascript.md

@@ -0,0 +1,51 @@
+# Google JavaScript Style Guide Summary
+
+This document summarizes key rules and best practices from the Google JavaScript Style Guide.
+
+## 1. Source File Basics
+- **File Naming:** All lowercase, with underscores (`_`) or dashes (`-`). Extension must be `.js`.
+- **File Encoding:** UTF-8.
+- **Whitespace:** Use only ASCII horizontal spaces (0x20). Tabs are forbidden for indentation.
+
+## 2. Source File Structure
+- New files should be ES modules (`import`/`export`).
+- **Exports:** Use named exports (`export {MyClass};`). **Do not use default exports.**
+- **Imports:** Do not use line-wrapped imports. The `.js` extension in import paths is mandatory.
+
+## 3. Formatting
+- **Braces:** Required for all control structures (`if`, `for`, `while`, etc.), even single-line blocks. Use K&R style ("Egyptian brackets").
+- **Indentation:** +2 spaces for each new block.
+- **Semicolons:** Every statement must be terminated with a semicolon.
+- **Column Limit:** 80 characters.
+- **Line-wrapping:** Indent continuation lines at least +4 spaces.
+- **Whitespace:** Use single blank lines between methods. No trailing whitespace.
+
+## 4. Language Features
+- **Variable Declarations:** Use `const` by default, `let` if reassignment is needed. **`var` is forbidden.**
+- **Array Literals:** Use trailing commas. Do not use the `Array` constructor.
+- **Object Literals:** Use trailing commas and shorthand properties. Do not use the `Object` constructor.
+- **Classes:** Do not use JavaScript getter/setter properties (`get name()`). Provide ordinary methods instead.
+- **Functions:** Prefer arrow functions for nested functions to preserve `this` context.
+- **String Literals:** Use single quotes (`'`). Use template literals (`` ` ``) for multi-line strings or complex interpolation.
+- **Control Structures:** Prefer `for-of` loops. `for-in` loops should only be used on dict-style objects.
+- **`this`:** Only use `this` in class constructors, methods, or in arrow functions defined within them.
+- **Equality Checks:** Always use identity operators (`===` / `!==`).
+
+## 5. Disallowed Features
+- `with` keyword.
+- `eval()` or `Function(...string)`.
+- Automatic Semicolon Insertion.
+- Modifying builtin objects (`Array.prototype.foo = ...`).
+
+## 6. Naming
+- **Classes:** `UpperCamelCase`.
+- **Methods & Functions:** `lowerCamelCase`.
+- **Constants:** `CONSTANT_CASE` (all uppercase with underscores).
+- **Non-constant Fields & Variables:** `lowerCamelCase`.
+
+## 7. JSDoc
+- JSDoc is used on all classes, fields, and methods.
+- Use `@param`, `@return`, `@override`, `@deprecated`.
+- Type annotations are enclosed in braces (e.g., `/** @param {string} userName */`).
+
+*Source: [Google JavaScript Style Guide](https://google.github.io/styleguide/jsguide.html)*

package/conductor/product-guidelines.md

@@ -0,0 +1,26 @@
+# Product Guidelines: ADF CLI
+
+## 1. Tone & Voice
+**Adaptive Personality:**
+*   **Context-Aware:** The CLI's tone must dynamically adjust to the specific scenario, project parameters, and user intent.
+*   **Scenario-Based Adaptation:**
+    *   *Quick/Rapid Projects:* Adopt a **Professional & Concise** tone. fast, direct, and efficient.
+    *   *Complex/BMAD Projects:* Shift to a **Technical & Analytical** tone, focusing on precision, data, and architectural depth.
+    *   *Learning/New Users:* Utilize a **Collaborative & Supportive** tone to guide them through the framework.
+*   **Goal:** Maximize the "return on time investment" by matching the communication style to the user's immediate cognitive load and task requirements.
+
+## 2. Visual Identity & Output Standards
+**Markdown-Centric Core:**
+*   **Absolute Core:** All documentation and artifacts MUST be generated in **GitHub Flavored Markdown (GFM)**.
+*   **Rationale:** Chosen for its flexibility, rich feature set, mobile-friendly visualization, and massive ecosystem support.
+*   **Structure:**
+    *   Use clear visual hierarchy (H1-H6) to make documents scannable.
+    *   Leverage tables, task lists, and blockquotes for structured data.
+
+**Diagramming & Visualization:**
+*   **Mermaid.js Standard:** All graphs, flowcharts, sequence diagrams, and architecture maps MUST be generated using **Mermaid text-based syntax**.
+*   **Integration:** Mermaid blocks must be embedded directly within the Markdown files for seamless rendering in supported viewers (GitHub, VS Code, etc.).
+
+## 3. Interaction Principles
+*   **Dynamic Flow:** The interface should never feel static. It must react to the user's answers, skipping unnecessary steps and diving deeper where complexity is detected.
+*   **Quality over Quantity:** Focus on extracting high-value information rather than forcing completion of a fixed checklist.

package/conductor/product.md

@@ -0,0 +1,25 @@
+# Product Guide: ADF CLI
+
+## 1. Initial Concept
+**Vision:**
+Create the definitive AI-driven requirements gathering tool that transforms vague ideas into comprehensive, actionable development documentation through intelligent conversation, learning from user behavior, and seamlessly integrating with development workflows.
+
+**Core Value Proposition:**
+1.  **Efficiency:** Maximizes return on time investment by adapting the interview process to the user's needs, using smart filtering to skip irrelevant questions (saving 40-60% time on specialized projects).
+2.  **Actionability:** Generates high-quality, framework-specific artifacts (PRD, Specs, Implementation Plans) and tool-specific configurations (e.g., `.windsurfrules`, `.cursorrules`) that are ready for immediate use.
+3.  **Intelligence:** Features a learning system that tracks user patterns (skips, preferences), detects habits, and dynamically modifies future interactions to reduce friction and improve relevance.
+4.  **Reliability:** Ensures zero data loss with triple-redundant saves and robust session resumption capabilities.
+
+**Target Audience:**
+*   **Primary:** Individual Developers (starting new projects), Development Teams (needing structured requirements), and AI-Assisted Development Practitioners.
+*   **Secondary:** Project Managers (creating PRDs), Technical Leads (planning architecture), and Open Source Maintainers.
+
+**Key Features:**
+*   **Dynamic Questionnaire:** AI-driven interview system that adapts questions based on answer quality, project context, and identified knowledge gaps.
+*   **Project Context Synthesis:** Adaptive project augmentation that intelligently detects existing framework indicators (.adf, BMAD, OpenSpec, Spec-Kit) and merges them into a unified context.
+*   **Learning System:** Tracks user behavior (skips, answers) to detect patterns and generate learned rules that streamline future sessions.
+*   **Artifact Generation:** Automated creation of structured documents (PRP, BMAD, Spec-Kit) and IDE configurations.
+*   **Multi-Provider AI Support:** Integrates with Anthropic, OpenAI, Google Gemini, and OpenRouter.
+*   **Tool Integration:** Deploys directly to 12+ AI-native tools including Windsurf, Cursor, VS Code, Zed, Antigravity, Kiro, Trae, Codex CLI, and more.
+*   **Tool Audit Registry:** Built-in capability to audit supported tool features and integration status.
+*   **Resilience:** Robust session management with resume capability and fault tolerance.

package/conductor/setup_state.json

@@ -0,0 +1 @@
+{"last_successful_step": "3.3_initial_track_generated"}

package/conductor/tech-stack.md

@@ -0,0 +1,28 @@
+# Technology Stack: ADF CLI
+
+## 1. Core Runtime & Language
+*   **Runtime:** Node.js (>=18.0.0)
+*   **Language:** JavaScript (ESM/CommonJS hybrid)
+
+## 2. Frameworks & UI
+*   **CLI Framework:** `commander` (Command routing and argument parsing with sub-command support)
+*   **Interactive UI:** `inquirer` (Multi-select, autocomplete prompts)
+*   **Visual Feedback:** `chalk` (Terminal styling), `ora` (Progress spinners)
+*   **Configuration Formats:** Support for JSON, TOML, and Markdown-based tool configurations.
+
+## 3. AI & Analysis
+*   **Multi-Provider Integration:**
+    *   Anthropic: `@anthropic-ai/sdk`
+    *   OpenAI: `openai`
+    *   Google Gemini: `@google/generative-ai`
+    *   OpenRouter: `node-fetch` (Standard API interface)
+*   **Context Engineering:** Custom Dynamic Pipeline and Knowledge Graph system.
+
+## 4. Infrastructure & Utilities
+*   **File Management:** `fs-extra` (Atomic writes, directory management)
+*   **Environment:** `dotenv` (Secure API key management)
+*   **Identity:** `uuid` (Session and project identification)
+
+## 5. Quality & Standards
+*   **Testing:** `jest` (Unit testing and coverage)
+*   **Architecture Standard:** AGENTS.md (Agent-Native Manifest compliance)

package/conductor/tracks/bootstrap_agents_20260111/metadata.json

@@ -0,0 +1,8 @@
+{
+  "track_id": "bootstrap_agents_20260111",
+  "type": "chore",
+  "status": "new",
+  "created_at": "2026-01-11T18:23:00Z",
+  "updated_at": "2026-01-11T18:23:00Z",
+  "description": "Bootstrap Agent-Native Documentation"
+}

package/conductor/tracks/bootstrap_agents_20260111/plan.md

@@ -0,0 +1,17 @@
+# Implementation Plan: Bootstrap Agent-Native Documentation
+
+## Phase 1: Artifact Generation [checkpoint: 9f9b348]
+- [x] Task: Create `.context/` directory structure. [commit: 0cd6c96]
+    - [x] Subtask: Create `.context/memory/` and `.context/skills/`.
+    - [x] Subtask: Create `.context/memory/glossary.md` with key terms.
+    - [x] Subtask: Create `.context/memory/architecture.md` based on `CLAUDE.md`.
+- [x] Task: Create `AGENTS.md`. [commit: f313bd1]
+    - [x] Subtask: Draft `AGENTS.md` content with Operational Rules and Commands.
+    - [x] Subtask: Ensure it references `.context/memory/architecture.md`.
+- [x] Task: Conductor - User Manual Verification 'Artifact Generation' (Protocol in workflow.md)
+
+## Phase 2: Verification
+- [x] Task: Verify Agent Access.
+    - [x] Subtask: Simulate an agent reading `AGENTS.md` and following the references.
+    - [x] Subtask: Ensure all paths in `AGENTS.md` are valid.
+- [x] Task: Conductor - User Manual Verification 'Verification' (Protocol in workflow.md)