opencode-plugin-team-agreements 0.2.0 → 0.2.1

package/dist/utils.js

@@ -6,11 +6,601 @@
  * call them as plugin functions. Only the plugin function should be exported
  * from the main entry point.
  */
-import { readFile, access } from "fs/promises";
+import { readFile, access, readdir } from "fs/promises";
 import { join } from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
 export const execAsync = promisify(exec);
+/**
+ * Analyze a project directory to detect languages, frameworks, tools, etc.
+ * Used to tailor team agreement questions to the specific project.
+ */
+export async function analyzeProject(directory) {
+    const analysis = {
+        languages: {
+            typescript: false,
+            javascript: false,
+            python: false,
+            rust: false,
+            go: false,
+            ruby: false,
+            java: false,
+            csharp: false,
+            other: [],
+        },
+        frameworks: {
+            react: false,
+            vue: false,
+            angular: false,
+            nextjs: false,
+            express: false,
+            fastapi: false,
+            django: false,
+            rails: false,
+            springBoot: false,
+            other: [],
+        },
+        ci: {
+            githubActions: false,
+            gitlabCi: false,
+            circleCi: false,
+            jenkins: false,
+            other: [],
+        },
+        testing: {
+            jest: false,
+            vitest: false,
+            mocha: false,
+            pytest: false,
+            rspec: false,
+            goTest: false,
+            hasTestDirectory: false,
+            other: [],
+        },
+        aiTools: {
+            agentsMd: false,
+            claudeMd: false,
+            copilotInstructions: false,
+            cursorRules: false,
+            continueConfig: false,
+            openCodeConfig: false,
+        },
+        database: {
+            prisma: false,
+            sequelize: false,
+            typeorm: false,
+            drizzle: false,
+            sqlalchemy: false,
+            activeRecord: false,
+            hasMigrations: false,
+            other: [],
+        },
+        monitoring: {
+            sentry: false,
+            datadog: false,
+            newRelic: false,
+            prometheus: false,
+            other: [],
+        },
+        characteristics: {
+            isMonorepo: false,
+            isLibrary: false,
+            hasDocker: false,
+            hasFrontend: false,
+            hasBackend: false,
+            hasApi: false,
+            hasDocs: false,
+        },
+        recommendations: {
+            suggestedCategories: [],
+            highlightedTopics: [],
+            skippableTopics: [],
+        },
+    };
+    // Check for various config files and directories
+    const checks = [
+        // Languages
+        {
+            path: "package.json",
+            readContent: true,
+            callback: (exists, content) => {
+                if (exists && content) {
+                    analysis.languages.javascript = true;
+                    try {
+                        const pkg = JSON.parse(content);
+                        // Check for TypeScript
+                        if (pkg.devDependencies?.typescript ||
+                            pkg.dependencies?.typescript) {
+                            analysis.languages.typescript = true;
+                        }
+                        // Check for frameworks
+                        if (pkg.dependencies?.react || pkg.devDependencies?.react) {
+                            analysis.frameworks.react = true;
+                            analysis.characteristics.hasFrontend = true;
+                        }
+                        if (pkg.dependencies?.vue || pkg.devDependencies?.vue) {
+                            analysis.frameworks.vue = true;
+                            analysis.characteristics.hasFrontend = true;
+                        }
+                        if (pkg.dependencies?.["@angular/core"]) {
+                            analysis.frameworks.angular = true;
+                            analysis.characteristics.hasFrontend = true;
+                        }
+                        if (pkg.dependencies?.next || pkg.devDependencies?.next) {
+                            analysis.frameworks.nextjs = true;
+                            analysis.characteristics.hasFrontend = true;
+                            analysis.characteristics.hasBackend = true;
+                        }
+                        if (pkg.dependencies?.express) {
+                            analysis.frameworks.express = true;
+                            analysis.characteristics.hasBackend = true;
+                            analysis.characteristics.hasApi = true;
+                        }
+                        // Check for testing frameworks
+                        if (pkg.devDependencies?.jest || pkg.dependencies?.jest) {
+                            analysis.testing.jest = true;
+                        }
+                        if (pkg.devDependencies?.vitest || pkg.dependencies?.vitest) {
+                            analysis.testing.vitest = true;
+                        }
+                        if (pkg.devDependencies?.mocha || pkg.dependencies?.mocha) {
+                            analysis.testing.mocha = true;
+                        }
+                        // Check for database ORMs
+                        if (pkg.dependencies?.prisma || pkg.devDependencies?.prisma) {
+                            analysis.database.prisma = true;
+                        }
+                        if (pkg.dependencies?.sequelize) {
+                            analysis.database.sequelize = true;
+                        }
+                        if (pkg.dependencies?.typeorm) {
+                            analysis.database.typeorm = true;
+                        }
+                        if (pkg.dependencies?.drizzle || pkg.dependencies?.["drizzle-orm"]) {
+                            analysis.database.drizzle = true;
+                        }
+                        // Check for monitoring
+                        if (pkg.dependencies?.["@sentry/node"] || pkg.dependencies?.["@sentry/react"]) {
+                            analysis.monitoring.sentry = true;
+                        }
+                        if (pkg.dependencies?.["dd-trace"]) {
+                            analysis.monitoring.datadog = true;
+                        }
+                        // Check for monorepo indicators
+                        if (pkg.workspaces || pkg.devDependencies?.lerna || pkg.devDependencies?.nx) {
+                            analysis.characteristics.isMonorepo = true;
+                        }
+                        // Check if it's a library (has main/exports but no bin)
+                        if ((pkg.main || pkg.exports) && !pkg.bin) {
+                            analysis.characteristics.isLibrary = true;
+                        }
+                    }
+                    catch {
+                        // JSON parse failed, still mark as JS project
+                    }
+                }
+            },
+        },
+        { path: "tsconfig.json", callback: (e) => { if (e)
+                analysis.languages.typescript = true; } },
+        { path: "pyproject.toml", callback: (e) => { if (e)
+                analysis.languages.python = true; } },
+        { path: "setup.py", callback: (e) => { if (e)
+                analysis.languages.python = true; } },
+        { path: "requirements.txt", callback: (e) => { if (e)
+                analysis.languages.python = true; } },
+        { path: "Cargo.toml", callback: (e) => { if (e)
+                analysis.languages.rust = true; } },
+        { path: "go.mod", callback: (e) => { if (e)
+                analysis.languages.go = true; } },
+        { path: "Gemfile", callback: (e) => { if (e)
+                analysis.languages.ruby = true; } },
+        { path: "pom.xml", callback: (e) => { if (e)
+                analysis.languages.java = true; } },
+        { path: "build.gradle", callback: (e) => { if (e)
+                analysis.languages.java = true; } },
+        { path: "*.csproj", callback: (e) => { if (e)
+                analysis.languages.csharp = true; } },
+        // CI/CD
+        { path: ".github/workflows", callback: (e) => { if (e)
+                analysis.ci.githubActions = true; } },
+        { path: ".gitlab-ci.yml", callback: (e) => { if (e)
+                analysis.ci.gitlabCi = true; } },
+        { path: ".circleci", callback: (e) => { if (e)
+                analysis.ci.circleCi = true; } },
+        { path: "Jenkinsfile", callback: (e) => { if (e)
+                analysis.ci.jenkins = true; } },
+        // Testing directories
+        { path: "test", callback: (e) => { if (e)
+                analysis.testing.hasTestDirectory = true; } },
+        { path: "tests", callback: (e) => { if (e)
+                analysis.testing.hasTestDirectory = true; } },
+        { path: "__tests__", callback: (e) => { if (e)
+                analysis.testing.hasTestDirectory = true; } },
+        { path: "spec", callback: (e) => { if (e) {
+                analysis.testing.hasTestDirectory = true;
+                analysis.testing.rspec = true;
+            } } },
+        // Python testing
+        { path: "pytest.ini", callback: (e) => { if (e)
+                analysis.testing.pytest = true; } },
+        { path: "conftest.py", callback: (e) => { if (e)
+                analysis.testing.pytest = true; } },
+        // AI Tools
+        { path: "AGENTS.md", callback: (e) => { if (e)
+                analysis.aiTools.agentsMd = true; } },
+        { path: "CLAUDE.md", callback: (e) => { if (e)
+                analysis.aiTools.claudeMd = true; } },
+        { path: ".github/copilot-instructions.md", callback: (e) => { if (e)
+                analysis.aiTools.copilotInstructions = true; } },
+        { path: ".cursorrules", callback: (e) => { if (e)
+                analysis.aiTools.cursorRules = true; } },
+        { path: ".cursor/rules", callback: (e) => { if (e)
+                analysis.aiTools.cursorRules = true; } },
+        { path: ".continue/config.json", callback: (e) => { if (e)
+                analysis.aiTools.continueConfig = true; } },
+        { path: "opencode.json", callback: (e) => { if (e)
+                analysis.aiTools.openCodeConfig = true; } },
+        // Database
+        { path: "prisma", callback: (e) => { if (e)
+                analysis.database.prisma = true; } },
+        { path: "migrations", callback: (e) => { if (e)
+                analysis.database.hasMigrations = true; } },
+        { path: "db/migrate", callback: (e) => { if (e) {
+                analysis.database.hasMigrations = true;
+                analysis.database.activeRecord = true;
+            } } },
+        { path: "alembic", callback: (e) => { if (e) {
+                analysis.database.hasMigrations = true;
+                analysis.database.sqlalchemy = true;
+            } } },
+        // Monitoring
+        { path: "sentry.properties", callback: (e) => { if (e)
+                analysis.monitoring.sentry = true; } },
+        { path: ".sentryclirc", callback: (e) => { if (e)
+                analysis.monitoring.sentry = true; } },
+        { path: "datadog.yaml", callback: (e) => { if (e)
+                analysis.monitoring.datadog = true; } },
+        { path: "newrelic.js", callback: (e) => { if (e)
+                analysis.monitoring.newRelic = true; } },
+        { path: "prometheus.yml", callback: (e) => { if (e)
+                analysis.monitoring.prometheus = true; } },
+        // Characteristics
+        { path: "Dockerfile", callback: (e) => { if (e)
+                analysis.characteristics.hasDocker = true; } },
+        { path: "docker-compose.yml", callback: (e) => { if (e)
+                analysis.characteristics.hasDocker = true; } },
+        { path: "docker-compose.yaml", callback: (e) => { if (e)
+                analysis.characteristics.hasDocker = true; } },
+        { path: "docs", callback: (e) => { if (e)
+                analysis.characteristics.hasDocs = true; } },
+        { path: "documentation", callback: (e) => { if (e)
+                analysis.characteristics.hasDocs = true; } },
+        // Python frameworks
+        {
+            path: "pyproject.toml",
+            readContent: true,
+            callback: (exists, content) => {
+                if (exists && content) {
+                    if (content.includes("fastapi")) {
+                        analysis.frameworks.fastapi = true;
+                        analysis.characteristics.hasBackend = true;
+                        analysis.characteristics.hasApi = true;
+                    }
+                    if (content.includes("django")) {
+                        analysis.frameworks.django = true;
+                        analysis.characteristics.hasBackend = true;
+                    }
+                    if (content.includes("pytest")) {
+                        analysis.testing.pytest = true;
+                    }
+                    if (content.includes("sqlalchemy")) {
+                        analysis.database.sqlalchemy = true;
+                    }
+                }
+            },
+        },
+        // Ruby frameworks
+        {
+            path: "Gemfile",
+            readContent: true,
+            callback: (exists, content) => {
+                if (exists && content) {
+                    if (content.includes("rails")) {
+                        analysis.frameworks.rails = true;
+                        analysis.characteristics.hasBackend = true;
+                    }
+                    if (content.includes("rspec")) {
+                        analysis.testing.rspec = true;
+                    }
+                }
+            },
+        },
+    ];
+    // Run all checks
+    for (const check of checks) {
+        const fullPath = join(directory, check.path);
+        const exists = await fileExists(fullPath);
+        if (check.readContent && exists) {
+            try {
+                const content = await readFile(fullPath, "utf-8");
+                check.callback(exists, content);
+            }
+            catch {
+                check.callback(exists);
+            }
+        }
+        else {
+            check.callback(exists);
+        }
+    }
+    // Check for frontend indicators in directory listing
+    try {
+        const entries = await readdir(directory);
+        if (entries.includes("src") || entries.includes("app") || entries.includes("pages")) {
+            // Could be frontend or backend, need more context
+        }
+        if (entries.includes("public") || entries.includes("static") || entries.includes("assets")) {
+            analysis.characteristics.hasFrontend = true;
+        }
+        if (entries.includes("api") || entries.includes("routes") || entries.includes("controllers")) {
+            analysis.characteristics.hasBackend = true;
+            analysis.characteristics.hasApi = true;
+        }
+    }
+    catch {
+        // Directory read failed, continue with other checks
+    }
+    // Generate recommendations based on analysis
+    analysis.recommendations = generateRecommendations(analysis);
+    return analysis;
+}
+/**
+ * Generate recommendations based on project analysis.
+ */
+function generateRecommendations(analysis) {
+    const recommendations = {
+        suggestedCategories: [
+            "Code & Quality", // Always relevant
+            "Integration & Delivery", // Always relevant
+        ],
+        highlightedTopics: [],
+        skippableTopics: [],
+    };
+    // AI Tools category - highlight if AI tools detected
+    const hasAiTools = Object.values(analysis.aiTools).some(v => v);
+    if (hasAiTools) {
+        recommendations.highlightedTopics.push("AI/LLM Collaboration");
+    }
+    recommendations.suggestedCategories.push("AI/LLM Collaboration");
+    // Operations & QA
+    const hasMonitoring = Object.entries(analysis.monitoring)
+        .filter(([key]) => key !== "other")
+        .some(([, value]) => value === true) || analysis.monitoring.other.length > 0;
+    if (hasMonitoring) {
+        recommendations.highlightedTopics.push("Monitoring & Observability");
+    }
+    if (analysis.characteristics.hasFrontend) {
+        recommendations.highlightedTopics.push("Accessibility");
+        recommendations.highlightedTopics.push("Performance Standards");
+    }
+    recommendations.suggestedCategories.push("Operations & QA");
+    // Documentation
+    if (analysis.characteristics.isLibrary) {
+        recommendations.highlightedTopics.push("Documentation Standards");
+        recommendations.highlightedTopics.push("API Documentation");
+    }
+    recommendations.suggestedCategories.push("Documentation & Knowledge");
+    // Team Process
+    recommendations.suggestedCategories.push("Team Process");
+    // Governance (always)
+    recommendations.suggestedCategories.push("Governance");
+    // Skippable topics based on what's NOT detected
+    const hasDatabase = Object.entries(analysis.database)
+        .filter(([key]) => key !== "other")
+        .some(([, value]) => value === true) || analysis.database.other.length > 0;
+    if (!hasDatabase) {
+        recommendations.skippableTopics.push("Database & Schema Changes");
+    }
+    if (!analysis.characteristics.hasFrontend) {
+        recommendations.skippableTopics.push("Accessibility & Internationalization");
+    }
+    const hasCi = Object.entries(analysis.ci)
+        .filter(([key]) => key !== "other")
+        .some(([, value]) => value === true) || analysis.ci.other.length > 0;
+    if (!hasCi) {
+        recommendations.highlightedTopics.push("Continuous Integration (not yet set up)");
+    }
+    return recommendations;
+}
+/**
+ * Format project analysis results as markdown for the LLM.
+ */
+export function formatProjectAnalysis(analysis) {
+    const lines = [
+        "## Project Analysis Results",
+        "",
+        "I've analyzed your project and detected the following:",
+        "",
+    ];
+    // Languages
+    const detectedLanguages = Object.entries(analysis.languages)
+        .filter(([key, value]) => key !== "other" && value === true)
+        .map(([key]) => key.charAt(0).toUpperCase() + key.slice(1));
+    if (analysis.languages.other.length > 0) {
+        detectedLanguages.push(...analysis.languages.other);
+    }
+    if (detectedLanguages.length > 0) {
+        lines.push("### Languages");
+        lines.push(detectedLanguages.map(l => `- ${l}`).join("\n"));
+        lines.push("");
+    }
+    // Frameworks
+    const detectedFrameworks = Object.entries(analysis.frameworks)
+        .filter(([key, value]) => key !== "other" && value === true)
+        .map(([key]) => {
+        const names = {
+            react: "React",
+            vue: "Vue.js",
+            angular: "Angular",
+            nextjs: "Next.js",
+            express: "Express",
+            fastapi: "FastAPI",
+            django: "Django",
+            rails: "Ruby on Rails",
+            springBoot: "Spring Boot",
+        };
+        return names[key] || key;
+    });
+    if (analysis.frameworks.other.length > 0) {
+        detectedFrameworks.push(...analysis.frameworks.other);
+    }
+    if (detectedFrameworks.length > 0) {
+        lines.push("### Frameworks");
+        lines.push(detectedFrameworks.map(f => `- ${f}`).join("\n"));
+        lines.push("");
+    }
+    // CI/CD
+    const detectedCi = Object.entries(analysis.ci)
+        .filter(([key, value]) => key !== "other" && value === true)
+        .map(([key]) => {
+        const names = {
+            githubActions: "GitHub Actions",
+            gitlabCi: "GitLab CI",
+            circleCi: "CircleCI",
+            jenkins: "Jenkins",
+        };
+        return names[key] || key;
+    });
+    if (detectedCi.length > 0) {
+        lines.push("### CI/CD");
+        lines.push(detectedCi.map(c => `- ${c}`).join("\n"));
+        lines.push("");
+    }
+    else {
+        lines.push("### CI/CD");
+        lines.push("- No CI/CD detected (consider setting up)");
+        lines.push("");
+    }
+    // Testing
+    const detectedTesting = Object.entries(analysis.testing)
+        .filter(([key, value]) => key !== "other" && key !== "hasTestDirectory" && value === true)
+        .map(([key]) => {
+        const names = {
+            jest: "Jest",
+            vitest: "Vitest",
+            mocha: "Mocha",
+            pytest: "pytest",
+            rspec: "RSpec",
+            goTest: "Go test",
+        };
+        return names[key] || key;
+    });
+    if (detectedTesting.length > 0 || analysis.testing.hasTestDirectory) {
+        lines.push("### Testing");
+        if (detectedTesting.length > 0) {
+            lines.push(detectedTesting.map(t => `- ${t}`).join("\n"));
+        }
+        if (analysis.testing.hasTestDirectory) {
+            lines.push("- Test directory detected");
+        }
+        lines.push("");
+    }
+    // AI Tools
+    const detectedAiTools = [];
+    if (analysis.aiTools.agentsMd)
+        detectedAiTools.push("AGENTS.md");
+    if (analysis.aiTools.claudeMd)
+        detectedAiTools.push("CLAUDE.md");
+    if (analysis.aiTools.copilotInstructions)
+        detectedAiTools.push("GitHub Copilot instructions");
+    if (analysis.aiTools.cursorRules)
+        detectedAiTools.push("Cursor rules");
+    if (analysis.aiTools.continueConfig)
+        detectedAiTools.push("Continue config");
+    if (analysis.aiTools.openCodeConfig)
+        detectedAiTools.push("OpenCode config");
+    if (detectedAiTools.length > 0) {
+        lines.push("### AI Tools Configuration");
+        lines.push(detectedAiTools.map(t => `- ${t}`).join("\n"));
+        lines.push("");
+    }
+    // Database
+    const detectedDatabase = [];
+    if (analysis.database.prisma)
+        detectedDatabase.push("Prisma");
+    if (analysis.database.sequelize)
+        detectedDatabase.push("Sequelize");
+    if (analysis.database.typeorm)
+        detectedDatabase.push("TypeORM");
+    if (analysis.database.drizzle)
+        detectedDatabase.push("Drizzle");
+    if (analysis.database.sqlalchemy)
+        detectedDatabase.push("SQLAlchemy");
+    if (analysis.database.activeRecord)
+        detectedDatabase.push("Active Record");
+    if (analysis.database.hasMigrations && detectedDatabase.length === 0) {
+        detectedDatabase.push("Migrations detected");
+    }
+    if (detectedDatabase.length > 0) {
+        lines.push("### Database");
+        lines.push(detectedDatabase.map(d => `- ${d}`).join("\n"));
+        lines.push("");
+    }
+    // Monitoring
+    const detectedMonitoring = [];
+    if (analysis.monitoring.sentry)
+        detectedMonitoring.push("Sentry");
+    if (analysis.monitoring.datadog)
+        detectedMonitoring.push("Datadog");
+    if (analysis.monitoring.newRelic)
+        detectedMonitoring.push("New Relic");
+    if (analysis.monitoring.prometheus)
+        detectedMonitoring.push("Prometheus");
+    if (detectedMonitoring.length > 0) {
+        lines.push("### Monitoring");
+        lines.push(detectedMonitoring.map(m => `- ${m}`).join("\n"));
+        lines.push("");
+    }
+    // Project Characteristics
+    const characteristics = [];
+    if (analysis.characteristics.isMonorepo)
+        characteristics.push("Monorepo");
+    if (analysis.characteristics.isLibrary)
+        characteristics.push("Library/Package");
+    if (analysis.characteristics.hasDocker)
+        characteristics.push("Docker");
+    if (analysis.characteristics.hasFrontend)
+        characteristics.push("Frontend");
+    if (analysis.characteristics.hasBackend)
+        characteristics.push("Backend");
+    if (analysis.characteristics.hasApi)
+        characteristics.push("API");
+    if (analysis.characteristics.hasDocs)
+        characteristics.push("Documentation folder");
+    if (characteristics.length > 0) {
+        lines.push("### Project Characteristics");
+        lines.push(characteristics.map(c => `- ${c}`).join("\n"));
+        lines.push("");
+    }
+    // Recommendations
+    lines.push("### Recommendations");
+    lines.push("");
+    lines.push("**Suggested categories to discuss:**");
+    lines.push(analysis.recommendations.suggestedCategories.map(c => `- ${c}`).join("\n"));
+    lines.push("");
+    if (analysis.recommendations.highlightedTopics.length > 0) {
+        lines.push("**Topics to highlight (particularly relevant to this project):**");
+        lines.push(analysis.recommendations.highlightedTopics.map(t => `- ${t}`).join("\n"));
+        lines.push("");
+    }
+    if (analysis.recommendations.skippableTopics.length > 0) {
+        lines.push("**Topics that may be skippable (not detected in project):**");
+        lines.push(analysis.recommendations.skippableTopics.map(t => `- ${t}`).join("\n"));
+        lines.push("");
+    }
+    return lines.join("\n");
+}
 export const PLUGIN_REPO = "jwilger/opencode-plugin-team-agreements";
 // Using array join to avoid esbuild/tsc issues with ## at start of lines in template literals
 export const COMMAND_TEMPLATE = [
@@ -20,142 +610,453 @@ export const COMMAND_TEMPLATE = [
     "",
     "## Overview",
     "",
-    "Team agreements are stored in `AGENTS.md` in the project root. This file is automatically loaded by OpenCode, Claude Code, and other compatible agentic tools - no configuration needed.",
+    "Team agreements are stored in TWO locations:",
+    "",
+    "1. **`docs/TEAM_AGREEMENTS.md`** - Comprehensive documentation of all team agreements (reference material for humans)",
+    "2. **`AGENTS.md`** - Only the rules that LLMs need to always have in context when working on the codebase",
     "",
-    "## Step 1: Analyze Existing Files",
+    "The split ensures:",
+    "- Human team members have complete reference documentation",
+    "- LLM context isn't bloated with procedures they don't need constantly (deployment procedures, post-mortem processes, meeting cadences, etc.)",
+    "- LLMs can still reference the full docs when needed",
     "",
-    "First, check for existing agent instruction files:",
+    "This is a comprehensive interview covering 7 categories of software development practices. The full interview typically takes 25-40 minutes, but you can skip topics or pause and resume later.",
     "",
-    "1. **Read `AGENTS.md`** (if it exists) - OpenCode's native format",
-    "2. **Read `CLAUDE.md`** (if it exists) - Claude Code's native format",
+    "## Step 1: Analyze Project & Existing Files",
     "",
-    "Analyze their contents to understand:",
-    "- What sections/topics already exist?",
-    "- Is there existing team agreement content?",
-    "- What's the overall structure and style?",
+    "**First, use the `analyze_project` tool** to detect:",
+    "- Languages, frameworks, and tools in use",
+    "- CI/CD, testing, and monitoring setup",
+    "- AI tools already configured",
+    "- Project characteristics (monorepo, library, frontend/backend)",
+    "",
+    "Then check for existing files:",
+    "1. **Read `docs/TEAM_AGREEMENTS.md`** (if it exists) - Full team agreements",
+    "2. **Read `AGENTS.md`** (if it exists) - LLM-specific rules",
+    "3. **Read `CLAUDE.md`** (if it exists) - Claude Code specific rules",
     "",
     "## Step 2: Determine the Scenario",
     "",
     "Based on what you find, you'll be in one of these scenarios:",
     "",
-    "### Scenario A: No existing files",
-    "- You'll create a new `AGENTS.md` with team agreements",
+    "### Scenario A: No existing team agreements",
+    "- You'll create `docs/TEAM_AGREEMENTS.md` with full documentation",
+    "- You'll create/update `AGENTS.md` with LLM-relevant rules only",
     "",
-    "### Scenario B: AGENTS.md exists (no CLAUDE.md)",
+    "### Scenario B: docs/TEAM_AGREEMENTS.md exists",
     "- Present the user with options:",
     "  - **Review**: Display current content",
     "  - **Amend**: Modify or add to specific sections",
-    "  - **Add Team Agreements**: Integrate new agreement sections into the existing structure",
+    "  - **Regenerate AGENTS.md**: Re-extract LLM-relevant rules",
+    "",
+    "### Scenario C: Only AGENTS.md/CLAUDE.md exist (legacy setup)",
+    "- Explain the new split approach",
+    "- Offer to migrate: create `docs/TEAM_AGREEMENTS.md` as comprehensive docs",
+    "- Update AGENTS.md to contain only LLM-relevant rules",
+    "- If CLAUDE.md exists, ensure it imports AGENTS.md and keep Claude-specific rules",
+    "",
+    "## Step 3: Present Categories Based on Analysis",
+    "",
+    "Show the project analysis results and present the 7 categories:",
+    "",
+    "```",
+    "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+    "TEAM AGREEMENTS INTERVIEW",
+    "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+    "",
+    "Based on your project analysis, here are the categories we'll cover:",
+    "",
+    "1. Code & Quality (4 topics) - How code is written",
+    "2. Integration & Delivery (4 topics) - How code flows",
+    "3. Operations & QA (4 topics) - How code runs",
+    "4. Documentation & Knowledge (3 topics) - How knowledge is captured",
+    "5. AI/LLM Collaboration (6 topics) - How humans and AI work together",
+    "6. Team Process (3 topics) - How the team works",
+    "7. Governance (2 topics) - How agreements evolve",
+    "",
+    "Estimated time: 25-40 minutes (you can pause anytime)",
+    "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+    "```",
+    "",
+    "Based on the project analysis, highlight which categories/topics are particularly relevant or potentially skippable. Ask if they want to proceed with all categories or skip any.",
+    "",
+    "## Step 4: Gather Team Agreements",
+    "",
+    "Guide through each category ONE question at a time. Show progress at the start of each category:",
+    "",
+    "```",
+    "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+    "Category X of 7: [Category Name]",
+    "Topics: [list topics in this category]",
+    "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+    "```",
     "",
-    "### Scenario C: CLAUDE.md exists (no AGENTS.md)",
-    "- Analyze the CLAUDE.md content",
-    '- Ask the user: "I found a CLAUDE.md file. I\'ll migrate universal rules to AGENTS.md and keep any Claude-specific rules in CLAUDE.md. Does that sound good?"',
-    "- Create AGENTS.md with the universal content + team agreements",
-    "- Update CLAUDE.md to import AGENTS.md (add `@AGENTS.md` at the top)",
-    "- Keep only Claude-specific rules in CLAUDE.md",
+    "### Interview Style Guidelines",
     "",
-    "### Scenario D: Both files exist",
-    "- Analyze both files for:",
-    "  - **Universal rules** (apply to all agents) → belong in AGENTS.md",
-    "  - **Claude-specific rules** → stay in CLAUDE.md",
-    "- Ask the user about any ambiguous content",
-    "- Ensure CLAUDE.md imports AGENTS.md",
-    "- Integrate team agreements into AGENTS.md",
+    "- Ask **ONE question at a time** - don't overwhelm",
+    "- **Discuss trade-offs** when relevant (e.g., strictness vs flexibility)",
+    "- **Use WebFetch** to research best practices when helpful",
+    "- Confirm understanding before moving on",
+    "- Capture the **why** behind decisions, not just the what",
+    "- Allow skipping topics with \"skip\" or \"not applicable\"",
+    "- Allow pausing with \"let's continue later\" (summarize progress)",
     "",
-    "## Step 3: Gather Team Agreements",
+    "---",
     "",
-    "If establishing new agreements (or the user wants to add/amend), guide them through these core topics ONE question at a time:",
+    "## CATEGORY 1: CODE & QUALITY",
     "",
-    "### Core Topics",
+    "### 1.1 Programming Languages & Tech Stack",
     "",
-    "#### a. Programming Languages",
+    "Questions to explore:",
     "- What programming language(s) will be used in this project?",
     "- What is each language used for? (e.g., TypeScript for frontend, Rust for backend)",
-    "- Are there specific versions or language-specific style guides to follow?",
+    "- Are there specific version requirements?",
+    "- Are there language-specific style guides to follow? (e.g., PEP 8, StandardJS, Google Style)",
+    "- What build tools and package managers are used?",
+    "- (If monorepo) How are packages/modules organized?",
+    "",
+    "### 1.2 Code Quality Standards",
     "",
-    "#### b. Code Quality Standards",
+    "Questions to explore:",
     '- What does "great code" look like for this team?',
     "- How should we prioritize: readability vs. performance vs. simplicity?",
-    "- Are there required patterns or anti-patterns to follow/avoid?",
-    "- What about error handling conventions?",
-    "- Naming conventions for files, functions, variables, types?",
-    "",
-    "#### c. Commit Message Conventions",
-    "- What format should commit messages follow? (Conventional Commits, custom, freeform)",
-    "- Are there required elements? (ticket numbers, scope, breaking change indicators)",
-    "- Any rules on length, tense, capitalization?",
-    "- Should commits be atomic (one logical change per commit)?",
-    "",
-    "#### d. Integration Workflow",
-    "- Trunk-based development or feature branches?",
-    "- Pull request requirements? (reviews, approvals, CI checks)",
-    "- Who can merge to main/trunk?",
-    "- What CI checks must pass before integration?",
-    "- Any branch naming conventions?",
-    "",
-    "#### e. Testing Requirements",
+    "- Are there required design patterns? (SOLID, Clean Architecture, DDD, etc.)",
+    "- Are there anti-patterns to explicitly avoid?",
+    "- Error handling conventions? (throw vs return, error types, logging)",
+    "- Naming conventions for files, functions, variables, types, constants?",
+    "- Complexity limits? (max function length, cyclomatic complexity)",
+    "- Code comments philosophy? (when to comment, what to avoid)",
+    "",
+    "### 1.3 Code Review Process",
+    "",
+    "Questions to explore:",
+    "- What should code reviewers focus on? (correctness, style, security, performance)",
+    "- What's the expected turnaround time for reviews?",
+    "- Minimum number of approvers required?",
+    "- How should disagreements in review be handled?",
+    "- Are there PR size guidelines? (max lines, max files)",
+    "- Should authors self-review before requesting review?",
+    "- Review comment etiquette? (suggestions vs demands, tone)",
+    "- Are there things reviewers should NOT focus on? (let linters handle)",
+    "",
+    "### 1.4 Testing Requirements",
+    "",
+    "Questions to explore:",
     '- What testing is required before code is considered "done"?',
-    "- Are there coverage thresholds?",
-    "- What types of tests? (unit, integration, e2e, property-based)",
-    "- When should tests be written? (TDD, after implementation, etc.)",
+    "- Are there coverage thresholds? (line, branch, function)",
+    "- What types of tests are required? (unit, integration, e2e, smoke, contract)",
+    "- When should tests be written? (TDD, before PR, alongside implementation)",
+    "- Test naming conventions?",
+    "- Test data management? (factories, fixtures, mocking strategies)",
+    "- What makes a good test? (isolation, determinism, clarity)",
+    "- Security testing requirements?",
+    "- Performance testing requirements?",
+    "- Accessibility testing requirements? (if frontend)",
+    "",
+    "---",
+    "",
+    "## CATEGORY 2: INTEGRATION & DELIVERY",
+    "",
+    "### 2.1 Version Control & Branching",
+    "",
+    "Questions to explore:",
+    "- What branching strategy? (trunk-based, GitHub Flow, GitFlow)",
+    "- Branch naming conventions?",
+    "- Commit message format? (Conventional Commits, custom, freeform)",
+    "- Required commit message elements? (ticket numbers, scope, type)",
+    "- Rules on length, tense, capitalization for commits?",
+    "- Should commits be atomic? (one logical change per commit)",
+    "- Squash, merge, or rebase for PRs?",
+    "- Protected branches configuration?",
+    "",
+    "### 2.2 Continuous Integration",
+    "",
+    "Questions to explore:",
+    "- What CI checks are required before merge?",
+    "- Build requirements?",
+    "- Lint and format checks?",
+    "- Test requirements in CI?",
+    "- Who (if anyone) can bypass CI?",
+    "- How should flaky tests be handled?",
+    "- CI timeout limits?",
+    "",
+    "### 2.3 Deployment & Release",
+    "",
+    "Questions to explore:",
+    "- Deployment strategy? (blue-green, canary, rolling, direct)",
+    "- Environment management? (dev, staging, prod)",
+    "- Feature flags usage?",
+    "- Rollback procedures?",
+    "- Release cadence? (continuous, weekly, on-demand)",
+    "- Versioning scheme? (semver, calver, other)",
+    "- Release notes requirements?",
+    "- Hotfix procedures?",
+    "- Who can deploy? Who approves production deploys?",
+    "- Deploy freeze periods?",
+    "",
+    "### 2.4 Database & Schema Changes",
+    "",
+    "(Skip if no database detected)",
+    "",
+    "Questions to explore:",
+    "- Migration strategy?",
+    "- Schema change review process?",
+    "- Data migration testing requirements?",
+    "- Rollback procedures for migrations?",
+    "- Database naming conventions?",
+    "- Query performance standards?",
+    "",
+    "---",
+    "",
+    "## CATEGORY 3: OPERATIONS & QA",
+    "",
+    "### 3.1 Security Practices",
+    "",
+    "Questions to explore:",
+    "- Security review requirements for sensitive code?",
+    "- Secret management approach?",
+    "- Dependency vulnerability scanning?",
+    "- Authentication/authorization patterns to follow?",
+    "- Input validation requirements?",
+    "- Security incident response process?",
+    "- OWASP guidelines awareness?",
+    "",
+    "When discussing security, consider using WebFetch to look up current OWASP top 10 or relevant security guidelines.",
+    "",
+    "### 3.2 Monitoring & Observability",
+    "",
+    "Questions to explore:",
+    "- Logging standards? (what to log, format, levels)",
+    "- Metrics and alerting requirements?",
+    "- On-call procedures?",
+    "- Incident severity levels?",
+    "- Post-mortem/retrospective process?",
+    "- Runbook requirements?",
+    "- Error tracking approach?",
+    "",
+    "### 3.3 Performance Standards",
     "",
-    "#### f. Amendment Process",
+    "(Highlight for frontend-heavy projects)",
+    "",
+    "Questions to explore:",
+    "- Performance budgets? (load time, bundle size, memory)",
+    "- Load testing requirements?",
+    "- Profiling practices?",
+    "- Caching strategies?",
+    "- Performance regression testing?",
+    "",
+    "### 3.4 Accessibility & Internationalization",
+    "",
+    "(Primarily for user-facing applications)",
+    "",
+    "Questions to explore:",
+    "- WCAG compliance level? (A, AA, AAA)",
+    "- Accessibility testing requirements?",
+    "- Screen reader testing?",
+    "- Keyboard navigation requirements?",
+    "- Language/locale support?",
+    "- RTL support considerations?",
+    "- Translation workflow?",
+    "",
+    "---",
+    "",
+    "## CATEGORY 4: DOCUMENTATION & KNOWLEDGE",
+    "",
+    "### 4.1 Documentation Standards",
+    "",
+    "Questions to explore:",
+    "- README standards? (what must be included)",
+    "- API documentation requirements?",
+    "- Architecture documentation?",
+    "- In-code documentation? (JSDoc, docstrings, when to use)",
+    "- Changelog maintenance?",
+    "- Runbook/playbook requirements?",
+    "- Where does documentation live?",
+    "- Documentation review process?",
+    "",
+    "### 4.2 Architecture Decision Records (ADRs)",
+    "",
+    "Questions to explore:",
+    "- When should an ADR be written?",
+    "- ADR format/template?",
+    "- Review process for ADRs?",
+    "- Where are ADRs stored?",
+    "- How are superseded ADRs handled?",
+    "",
+    "### 4.3 Dependency Management",
+    "",
+    "Questions to explore:",
+    "- Dependency approval process?",
+    "- Version pinning strategy? (exact, range, floating)",
+    "- Upgrade cadence?",
+    "- License compliance requirements?",
+    "- Security vulnerability response time?",
+    "- Internal vs external package policies?",
+    "- Dependency audit process?",
+    "",
+    "---",
+    "",
+    "## CATEGORY 5: AI/LLM COLLABORATION",
+    "",
+    "This category is particularly important for teams using AI coding assistants like OpenCode, Claude Code, GitHub Copilot, Cursor, etc.",
+    "",
+    "### 5.1 AI Tools & Policies",
+    "",
+    "Questions to explore:",
+    "- What AI coding tools does the team use or approve?",
+    "- Is there an official stance on AI usage? (encouraged, allowed with guidelines, restricted)",
+    "- Are there tasks where AI should NOT be used? (security-sensitive, licensed code, etc.)",
+    "- How should AI tool usage be communicated or tracked?",
+    "- Data privacy considerations with AI tools?",
+    "",
+    "### 5.2 Autonomy Boundaries",
+    "",
+    "Questions to explore:",
+    "- What can AI agents do autonomously without asking?",
+    "  - Create/modify files?",
+    "  - Run tests?",
+    "  - Make commits?",
+    "  - Create pull requests?",
+    "  - Merge code?",
+    "  - Deploy?",
+    "  - Install dependencies?",
+    "- What always requires human confirmation?",
+    "- Are there files/directories AI should never touch?",
+    "- Can AI access external resources? (web, APIs, MCP servers)",
+    "- Git operations permissions? (push, force push, branch deletion)",
+    "",
+    "### 5.3 AI Code Generation Standards",
+    "",
+    "Questions to explore:",
+    "- What quality standards apply to AI-generated code? (same as human, stricter, different)",
+    "- Should AI-generated code be clearly marked or attributed?",
+    "- Are there specific review requirements for AI-generated code?",
+    "- How should AI-generated tests be validated?",
+    "- Policy on accepting AI suggestions without modification?",
+    "- AI code that requires extra scrutiny? (security, data handling)",
+    "",
+    "### 5.4 Context & Session Management",
+    "",
+    "Questions to explore:",
+    "- How should context be structured in AGENTS.md?",
+    "- What information should AI always have access to?",
+    "- Session handoff summary requirements? (what to include when ending a session)",
+    "- How should AI communicate progress during long tasks?",
+    "- Information to preserve between sessions?",
+    "- How to handle context limits and compaction?",
+    "- Project-specific knowledge AI should know?",
+    "",
+    "### 5.5 Human Oversight & Escalation",
+    "",
+    "Questions to explore:",
+    "- What triggers should cause AI to stop and ask for human input?",
+    "- Self-verification requirements? (run tests, check lints before committing)",
+    "- How should AI handle suspected errors in its own output?",
+    "- Handling uncertainty or ambiguous requirements?",
+    "- Escalation path when AI gets stuck?",
+    "- Maximum scope of changes AI can make without checking in?",
+    "- How should AI flag concerns or potential issues?",
+    "",
+    "### 5.6 Learning & Improvement",
+    "",
+    "Questions to explore:",
+    "- How should effective AI prompts/patterns be shared with the team?",
+    "- Is there a team prompt library or best practices doc?",
+    "- How should AI mistakes be documented for learning?",
+    "- Retrospectives on AI effectiveness?",
+    "- How to update AGENTS.md as AI capabilities evolve?",
+    "- Feedback loop for improving AI collaboration?",
+    "",
+    "---",
+    "",
+    "## CATEGORY 6: TEAM PROCESS",
+    "",
+    "### 6.1 Development Methodology",
+    "",
+    "Questions to explore:",
+    "- What agile/methodology practices are used? (Scrum, Kanban, XP, none)",
+    "- Sprint/iteration cadence?",
+    "- Definition of Done?",
+    "- Definition of Ready?",
+    "- Estimation approach? (story points, t-shirt sizes, no estimates)",
+    "- Meeting cadence? (standups, planning, retros)",
+    "- WIP (work-in-progress) limits?",
+    "",
+    "### 6.2 Planning & Work Breakdown",
+    "",
+    "Questions to explore:",
+    "- How is work broken down? (epics → stories → tasks)",
+    "- Story/task sizing guidelines?",
+    "- Spike guidelines? (when, how long, expected output)",
+    "- Technical debt handling? (tracking, prioritization)",
+    "- Prioritization framework?",
+    "- How are blockers escalated?",
+    "",
+    "### 6.3 Communication & Collaboration",
+    "",
+    "Questions to explore:",
+    "- Async vs sync communication preferences?",
+    "- Response time expectations?",
+    "- Decision documentation requirements?",
+    "- Knowledge sharing practices?",
+    "- Onboarding process for new team members?",
+    "- Pair programming / mob programming practices?",
+    "",
+    "---",
+    "",
+    "## CATEGORY 7: GOVERNANCE",
+    "",
+    "### 7.1 Amendment Process",
+    "",
+    "Questions to explore:",
     "- How can these agreements be changed?",
-    "- Who has authority to propose/approve changes?",
+    "- Who has authority to propose changes?",
     "- What's the review/approval process for amendments?",
     "- How should changes be communicated to the team?",
+    "- How often should agreements be reviewed?",
     "",
-    "### Gathering Style",
+    "### 7.2 Open-Ended",
     "",
-    "For each topic:",
-    "- Ask ONE question at a time",
-    "- Discuss trade-offs when relevant",
-    "- Confirm understanding before moving on",
-    "- Record the team's decision clearly",
+    'After completing all categories, ask:',
+    "",
+    '"Is there anything else you\'d like to include in your team agreements that we haven\'t covered?"',
     "",
-    "### Additional Topics",
+    "Allow free-form additions. If the user suggests a topic that seems generally useful, offer to file a GitHub issue to suggest it for the plugin:",
     "",
-    "After the core topics, ask:",
-    '"Are there any additional topics you\'d like to establish agreements for?"',
+    '"Would you like me to suggest this topic to be included in future versions of the team-agreements plugin? I can file a GitHub issue for you."',
     "",
-    "Suggest potential additional topics if helpful:",
-    "- **Architecture decisions** - How to document and track ADRs",
-    "- **Dependency management** - How to evaluate and approve new dependencies",
-    "- **Documentation standards** - What must be documented, where, in what format",
-    "- **LLM autonomy boundaries** - What can LLMs do without asking? What requires human approval?",
-    "- **Session handoff protocols** - How to summarize work for the next session/agent",
-    "- **Code review process** - What reviewers should look for, turnaround expectations",
-    "- **Planning and work breakdown** - How to break down work into tasks",
-    "- **Information sharing** - How to share context across sessions and team members",
+    "If yes, use the `suggest_team_agreement_topic` tool.",
     "",
-    "Continue asking about each additional topic the user wants to cover.",
+    "---",
+    "",
+    "## Step 5: Generate Documents",
     "",
-    'After discussing additional topics, ask: "Would you like to suggest any of these additional topics',
-    "(or others you thought of) to be included as standard topics in the team-agreements plugin?",
-    'I can file a GitHub issue for you if you\'d like."',
+    "After gathering all agreements, generate both documents:",
     "",
-    "If the user wants to suggest a topic, use the `suggest_team_agreement_topic` tool to file an issue.",
+    "### 5a. Create/Update docs/TEAM_AGREEMENTS.md",
     "",
-    "## Step 4: Intelligent Merging",
+    "- Create the `docs/` directory if it doesn't exist",
+    "- Write the comprehensive documentation with ALL agreements",
+    "- Preserve existing content if updating (intelligent merging)",
+    "- Match existing document tone and style",
     "",
-    "When writing to AGENTS.md, **intelligently merge** with existing content:",
+    "### 5b. Extract LLM-Relevant Rules to AGENTS.md",
     "",
-    "1. **Preserve existing structure** - Don't reorganize content the user already has",
-    "2. **Add new sections** - Place team agreement sections in logical locations",
-    "3. **Avoid duplication** - If similar content exists, enhance rather than duplicate",
-    "4. **Maintain voice** - Match the existing document's tone and style",
-    "5. **Use clear section headers** - Make team agreements easy to find",
+    "- Extract only rules that affect day-to-day coding",
+    "- Keep it concise - LLMs don't need verbose explanations",
+    "- If AGENTS.md has other content (project description, architecture), preserve it",
+    "- Add a reference to docs/TEAM_AGREEMENTS.md for complete details",
     "",
     "### Merging Guidelines",
     "",
-    '- If AGENTS.md has a "Code Standards" section and you\'re adding "Code Quality Standards", merge them',
-    "- If AGENTS.md describes the project structure, keep that and add team agreements as a new section",
-    "- Use `## Team Agreements` as a parent section if adding multiple agreement topics to an existing file",
-    "- If the file is empty or minimal, create a well-structured document from scratch",
+    "When updating existing files:",
+    "- **Preserve existing structure** - Don't reorganize content the user already has",
+    "- **Avoid duplication** - If similar content exists, enhance rather than duplicate",
+    "- **Maintain voice** - Match the existing document's tone and style",
     "",
-    "## Step 5: Handle CLAUDE.md Coordination",
+    "## Step 6: Handle CLAUDE.md Coordination",
     "",
-    "If CLAUDE.md exists or was created:",
+    "If CLAUDE.md exists or Claude-specific rules are needed:",
     "",
     "1. Ensure it has `@AGENTS.md` at the top to import the shared rules",
     "2. Keep only Claude-specific content in CLAUDE.md, such as:",
@@ -163,32 +1064,22 @@ export const COMMAND_TEMPLATE = [
     "   - Claude-specific tool usage preferences",
     "   - Anything that shouldn't apply to other agents",
     "",
-    "Example CLAUDE.md after coordination:",
-    "```markdown",
-    "@AGENTS.md",
-    "",
-    "# Claude-Specific Instructions",
-    "",
-    "[Any rules that only apply to Claude Code, not other agents]",
-    "```",
-    "",
-    "## Step 6: Offer Enforcement Setup",
+    "## Step 7: Offer Enforcement Setup",
     "",
     "After generating/updating the agreements, use the `detect_enforcement_mechanisms` tool to check what enforcement is already in place, then offer to set up automatic enforcement for agreements that can be enforced programmatically.",
     "",
     "### Enforcement Mechanisms",
     "",
-    "#### Pre-commit Hooks (husky, lefthook, pre-commit)",
-    "Ideal for: Commit message validation, code formatting, linting, test execution",
-    "",
-    "#### CI Workflows (GitHub Actions, etc.)",
-    "Ideal for: Test coverage, build verification, security scanning, PR checks",
-    "",
-    "#### GitHub Rulesets / Branch Protection",
-    "Ideal for: PR requirements, review policies, merge restrictions",
-    "",
-    "#### Linting Rules (.eslintrc, biome.json, etc.)",
-    "Ideal for: Code style, naming conventions, import organization",
+    "| Agreement Type | Enforcement Options |",
+    "|----------------|---------------------|",
+    "| Commit messages | commitlint, husky/lefthook hooks |",
+    "| Code formatting | Prettier, Biome, pre-commit hooks |",
+    "| Linting | ESLint, Biome, language-specific linters |",
+    "| Testing | CI workflows, pre-push hooks |",
+    "| Coverage | CI workflows with coverage gates |",
+    "| Security | Dependabot, Snyk, CodeQL, CI workflows |",
+    "| PR requirements | GitHub branch protection, rulesets |",
+    "| Documentation | CI checks for README, API docs |",
     "",
     "### When Offering Enforcement",
     "",
@@ -199,52 +1090,202 @@ export const COMMAND_TEMPLATE = [
     "",
     "## Output Format",
     "",
-    "When creating or updating AGENTS.md, integrate team agreements appropriately. If creating from scratch or the file is minimal, use this structure:",
+    "You will create/update TWO files:",
+    "",
+    "### 1. docs/TEAM_AGREEMENTS.md (Comprehensive Documentation)",
+    "",
+    "This is the full reference document for the team. Include ALL agreements from ALL categories.",
     "",
     "```markdown",
-    "# Project Name",
+    "# Team Agreements",
     "",
-    "[Brief project description if not already present]",
+    "This document defines how our team collaborates on this codebase.",
+    "*Last updated: [date]*",
     "",
-    "## Team Agreements",
+    "> **For LLM Agents:** The rules you need to follow are in `AGENTS.md`.",
+    "> This document is comprehensive reference material. Consult it when you need",
+    "> detailed information about deployment, processes, or other team practices.",
     "",
-    "This section defines how our team (humans and LLM agents) collaborates on this codebase.",
+    "## Code & Quality",
     "",
-    "### Programming Languages",
-    "[Agreements about languages and their usage]",
+    "### Languages & Tech Stack",
+    "[Full details...]",
     "",
     "### Code Quality Standards",
-    "[Agreements about what makes good code]",
+    "[Full details...]",
     "",
-    "### Commit Message Conventions",
-    "[Agreements about commit message format]",
-    "",
-    "### Integration Workflow",
-    "[Agreements about how code gets integrated]",
+    "### Code Review Process",
+    "[Full details including turnaround times, disagreement resolution, etc.]",
     "",
     "### Testing Requirements",
-    "[Agreements about testing]",
+    "[Full details...]",
+    "",
+    "## Integration & Delivery",
+    "",
+    "### Version Control & Branching",
+    "[Full details...]",
+    "",
+    "### Continuous Integration",
+    "[Full details...]",
+    "",
+    "### Deployment & Release",
+    "[Full details including environments, rollback procedures, hotfixes, etc.]",
+    "",
+    "### Database & Schema Changes",
+    "[Full details if applicable...]",
+    "",
+    "## Operations & QA",
+    "",
+    "### Security Practices",
+    "[Full details...]",
+    "",
+    "### Monitoring & Observability",
+    "[Full details including on-call, incident response, post-mortems, etc.]",
+    "",
+    "### Performance Standards",
+    "[Full details if applicable...]",
+    "",
+    "### Accessibility & Internationalization",
+    "[Full details if applicable...]",
+    "",
+    "## Documentation & Knowledge",
+    "",
+    "### Documentation Standards",
+    "[Full details...]",
+    "",
+    "### Architecture Decision Records",
+    "[Full details...]",
+    "",
+    "### Dependency Management",
+    "[Full details...]",
+    "",
+    "## AI/LLM Collaboration",
+    "",
+    "### AI Tools & Policies",
+    "[Full details...]",
+    "",
+    "### Autonomy Boundaries",
+    "[Full details - what AI can/cannot do autonomously...]",
+    "",
+    "### AI Code Generation Standards",
+    "[Full details...]",
+    "",
+    "### Context & Session Management",
+    "[Full details...]",
+    "",
+    "### Human Oversight & Escalation",
+    "[Full details...]",
+    "",
+    "### Learning & Improvement",
+    "[Full details...]",
+    "",
+    "## Team Process",
+    "",
+    "### Development Methodology",
+    "[Full details...]",
+    "",
+    "### Planning & Work Breakdown",
+    "[Full details...]",
+    "",
+    "### Communication & Collaboration",
+    "[Full details...]",
+    "",
+    "## Governance",
     "",
     "### Amendment Process",
-    "[Agreements about changing these agreements]",
+    "[Full details...]",
+    "```",
     "",
-    "### Additional Topics",
-    "[Any additional topics the team added]",
+    "### 2. AGENTS.md (LLM Context Rules)",
+    "",
+    "This file contains ONLY the rules that LLMs need constantly in context. Extract rules that affect day-to-day coding work.",
+    "",
+    "**What to include in AGENTS.md:**",
+    "- Code quality standards and patterns",
+    "- Testing requirements",
+    "- Commit message format",
+    "- Code review expectations",
+    "- Branching/PR conventions",
+    "- AI autonomy boundaries",
+    "- AI code generation standards",
+    "- Escalation triggers",
+    "",
+    "**What NOT to include in AGENTS.md (keep only in docs/TEAM_AGREEMENTS.md):**",
+    "- Deployment procedures (reference when needed)",
+    "- On-call and incident procedures",
+    "- Post-mortem processes",
+    "- Meeting cadences and ceremonies",
+    "- Detailed release procedures",
+    "- Onboarding processes",
+    "- Communication preferences",
     "",
-    "---",
-    "*Team agreements last updated: [date]*",
+    "```markdown",
+    "# Agent Instructions",
+    "",
+    "This file contains rules for LLM agents working on this codebase.",
+    "For complete team agreements, see `docs/TEAM_AGREEMENTS.md`.",
+    "",
+    "## Code Standards",
+    "",
+    "[Concise code quality rules...]",
+    "[Naming conventions...]",
+    "[Error handling patterns...]",
+    "",
+    "## Testing",
+    "",
+    "[What tests are required...]",
+    "[Coverage requirements...]",
+    "",
+    "## Version Control",
+    "",
+    "[Commit message format...]",
+    "[Branch naming...]",
+    "[PR requirements...]",
+    "",
+    "## Code Review",
+    "",
+    "[What reviewers look for...]",
+    "[Self-review checklist...]",
+    "",
+    "## AI Autonomy",
+    "",
+    "[What you can do without asking...]",
+    "[What requires human approval...]",
+    "[Files/areas to avoid...]",
+    "",
+    "## AI Code Standards",
+    "",
+    "[Quality requirements for AI-generated code...]",
+    "[When to run tests...]",
+    "[Verification requirements...]",
+    "",
+    "## Escalation",
+    "",
+    "[When to stop and ask...]",
+    "[How to flag concerns...]",
+    "```",
+    "",
+    "### 3. CLAUDE.md Coordination (if applicable)",
+    "",
+    "If CLAUDE.md exists or Claude-specific rules are needed:",
+    "- Ensure it imports AGENTS.md: `@AGENTS.md` at the top",
+    "- Keep only Claude-specific behavior/preferences in CLAUDE.md",
     "```",
     "",
     "## Important Guidelines",
     "",
     "- Be conversational and collaborative",
-    "- ONE question at a time - don't overwhelm",
+    "- **ONE question at a time** - don't overwhelm",
     "- Respect the user's expertise and preferences",
     "- If the user provides a specific request in their message, address that first",
-    "- The core topics are a starting point, not an exhaustive list",
+    "- Allow skipping entire categories or individual topics",
+    "- Support pausing and resuming the interview",
+    "- Show progress indicators at category transitions",
+    "- Use WebFetch to research best practices when relevant",
     '- Capture the "why" behind decisions, not just the "what"',
     "- When merging, preserve the user's existing content and style",
     "- Always explain what you're about to do before making file changes",
+    "- The AI/LLM Collaboration category is particularly important - don't rush through it",
 ].join("\n");
 /**
  * Check if a file exists at the given path.