@christianmaf80/agentic-workflow 1.2.0-beta.1

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026 Christian Marino Alvarez
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.es.md

@@ -0,0 +1,88 @@
+# @christian-marino-alvarez/agentic-workflow
+
+[English](./README.md) | [Español]
+
+> Sistema portátil de orquestación de flujos agénticos con estricta disciplina de identidad y puertas de control.
+
+## 🚀 Descripción General
+
+**Agentic Workflow** es un framework de orquestación ligero e agnóstico al lenguaje, diseñado para imponer disciplina y seguridad en el desarrollo asistido por agentes de IA. Proporciona un ciclo de vida estructurado para las tareas, puertas de control obligatorias con intervención humana (human-in-the-loop) y un robusto modelo de arquitectura por referencia.
+
+## ✨ Características Principales
+
+- **Protocolo AHRP (Agentic Handover & Reasoning Protocol)**: Impone un flujo estricto de Triple-Puerta para cada tarea (Activación, Aprobación de Razonamiento y Aceptación de Resultados).
+- **Arquitectura por Referencia**: Mantiene tu proyecto limpio referenciando las reglas y workflows del núcleo desde `node_modules`.
+- **Gobernanza de Tolerancia Cero**: Penalizaciones automáticas de rendimiento por violaciones del protocolo.
+- **Independiente y Portátil**: Funciona en cualquier proyecto, siempre que el agente del IDE pueda leer archivos Markdown.
+
+## 📦 Instalación
+
+```bash
+npm install @christian-marino-alvarez/agentic-workflow
+```
+
+## 🛠️ Comandos del CLI
+
+### `init`
+Inicializa el sistema agéntico en el directorio actual.
+- Detecta sistemas heredados y ofrece migración con copias de seguridad automáticas.
+- Crea la estructura `.agent/` (índices, directorios proxy).
+- Genera `AGENTS.md`, el punto de entrada para los asistentes del IDE.
+```bash
+npx agentic-workflow init
+```
+
+### `create <role|workflow> <name>`
+Genera el andamiaje (scaffolding) para un nuevo componente personalizado.
+- **role**: Crea un nuevo rol de agente con reglas de identificación obligatorias.
+- **workflow**: Crea una plantilla de ciclo de trabajo personalizado.
+```bash
+npx agentic-workflow create role neo
+```
+
+### `restore`
+Recupera la configuración de `.agent/` desde una copia de seguridad previa.
+- Los backups se almacenan en `.agent-backups/`.
+- Permite seleccionar versiones antes de un cambio destructivo.
+```bash
+npx agentic-workflow restore
+```
+
+## 🔌 Configuración del Servidor MCP
+
+Para usar el framework con IDEs que soportan el Protocolo de Contexto de Modelo (ej: Cursor, Windsurf), debes añadir el servidor a tu configuración.
+
+### Recomendado (vía NPX)
+Usa `npx` para asegurar que siempre usas la versión correcta de tu proyecto:
+- **Comando**: `npx agentic-workflow mcp`
+
+### Manual (Global/Local)
+Si tienes el paquete instalado localmente, puedes apuntar al binario local:
+- **Comando**: `node ./node_modules/.bin/agentic-workflow mcp`
+
+## 🧠 Conceptos Core
+
+### Ciclos de Vida
+El framework soporta dos flujos principales según la complejidad de la tarea:
+1. **Ciclo de Vida Largo (9 Fases)**: Para funcionalidades complejas que requieren Investigación, Análisis, Planificación y Revisión Arquitectónica formal.
+2. **Ciclo de Vida Corto (3 Fases)**: Para correcciones rápidas o actualizaciones simples, fusionando Aceptación, Implementación y Cierre.
+
+### Protocolo AHRP
+Cada tarea de un agente sigue el **Protocolo de Traspaso y Razonamiento Agéntico**:
+1. **Puerta A (Activación)**: El agente es asignado pero está bloqueado. El desarrollador debe decir `SI`.
+2. **Puerta B (Razonamiento)**: El agente propone un plan. El desarrollador debe aprobar con `SI`.
+3. **Puerta C (Resultados)**: El agente completa el trabajo. El desarrollador valida con `SI`.
+
+### Arquitectura por Referencia
+Para garantizar la estabilidad, la lógica central del framework (reglas y workflows) reside dentro de `node_modules`. El archivo `.agent/index.md` de tu proyecto utiliza rutas absolutas para referenciar estos activos inmutables, protegiendo al framework de modificaciones locales accidentales.
+
+## ⚖️ Gobernanza
+
+Este framework se basa en el principio de **Máxima Disciplina**. Los agentes deben:
+1. Identificarse con un prefijo obligatorio.
+2. Enviar un plan de razonamiento antes de cualquier modificación.
+3. Obtener la aprobación explícita del desarrollador (`SI`) para cada transición.
+
+## 📄 Licencia
+
+Licencia ISC. Consulta [LICENSE](./LICENSE) para más detalles.

package/README.md

@@ -0,0 +1,88 @@
+# @christian-marino-alvarez/agentic-workflow
+
+[English] | [Español](./README.es.md)
+
+> Portable agentic workflow orchestration system with strict identity and gate discipline.
+
+## 🚀 Overview
+
+**Agentic Workflow** is a lightweight, language-agnostic orchestration framework designed to enforce discipline and safety in AI-agent-assisted development. It provides a structured lifecycle for tasks, mandatory human-in-the-loop gates, and a robust architecture-by-reference model.
+
+## ✨ Key Features
+
+- **AHRP (Agentic Handover & Reasoning Protocol)**: Enforces a strict Triple-Gate flow for every task (Activation, Reasoning Approval, and Results Acceptance).
+- **Architecture by Reference**: Keeps your project clean by referencing core rules and workflows from `node_modules`.
+- **Zero-Tolerance Governance**: Automatic performance penalties for protocol violations.
+- **Standalone & Portable**: Works in any project provided the IDE agent can read Markdown files.
+
+## 📦 Installation
+
+```bash
+npm install @christian-marino-alvarez/agentic-workflow
+```
+
+## 🛠️ CLI Commands
+
+### `init`
+Initializes the agentic system in the current directory.
+- Detects legacy systems and offers migration with automatic backups.
+- Creates the `.agent/` structure (indexes, proxy directories).
+- Generates `AGENTS.md`, the entry point for IDE assistants.
+```bash
+npx agentic-workflow init
+```
+
+### `create <role|workflow> <name>`
+Scaffolds a new custom component.
+- **role**: Creates a new agent role with mandatory identification rules.
+- **workflow**: Creates a custom work cycle template.
+```bash
+npx agentic-workflow create role neo
+```
+
+### `restore`
+Recovers the `.agent/` configuration from a previous backup.
+- Backups are stored in `.agent-backups/`.
+- Allows selecting versions before a destructive change.
+```bash
+npx agentic-workflow restore
+```
+
+## 🔌 MCP Server Configuration
+
+To use the framework with IDEs that support the Model Context Protocol (e.g., Cursor, Windsurf), you must add the server to your settings.
+
+### Recommended (via NPX)
+Use `npx` to ensure you are always using the correct version from your project:
+- **Command**: `npx agentic-workflow mcp`
+
+### Manual (Global/Local)
+If you have the package installed locally, you can point to the local binary:
+- **Command**: `node ./node_modules/.bin/agentic-workflow mcp`
+
+## 🧠 Core Concepts
+
+### Lifecycles
+The framework supports two main workflows depending on task complexity:
+1. **Long Lifecycle (9 Phases)**: For complex features requiring Research, Analysis, Planning, and formal Architectural Review.
+2. **Short Lifecycle (3 Phases)**: For quick fixes or simple updates, merging Acceptance, Implementation, and Closure.
+
+### AHRP Protocol
+Every agent task follows the **Agentic Handover & Reasoning Protocol**:
+1. **Gate A (Activation)**: The agent is assigned but blocked. Developer must say `YES`.
+2. **Gate B (Reasoning)**: The agent proposes a plan. Developer must approve with `YES`.
+3. **Gate C (Results)**: The agent completes the work. Developer validates with `YES`.
+
+### Architecture by Reference
+To ensure stability, the framework's core logic (rules and workflows) resides inside `node_modules`. Your project's `.agent/index.md` uses absolute paths to reference these immutable assets, protecting the framework from accidental local modifications.
+
+## ⚖️ Governance
+
+This framework is built on the principle of **Maximum Discipline**. Agents are required to:
+1. Identify themselves with a mandatory prefix.
+2. Submit a reasoning plan before any modification.
+3. Obtain explicit developer approval (`YES`) for every transition.
+
+## 📄 License
+
+ISC License. See [LICENSE](./LICENSE) for details.

package/bin/cli.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { initCommand } from '../dist/cli/commands/init.js';
+import { createCommand } from '../dist/cli/commands/create.js';
+import { restoreCommand } from '../dist/cli/commands/restore.js';
+import { runMcpServer } from '../dist/mcp/server.js';
+import { registerMcpCommand } from '../dist/cli/commands/mcp-register.js';
+
+const program = new Command();
+
+program
+    .name('agentic-workflow')
+    .description('Portable agentic orchestration system')
+    .version('1.0.0');
+
+program
+    .command('init')
+    .description('Initialize the agentic system in the current directory')
+    .action(initCommand);
+
+program
+    .command('create')
+    .argument('<type>', 'The type of element to create (role, workflow)')
+    .argument('<name>', 'The name for the new element')
+    .description('Scaffold a new project-specific element')
+    .action(createCommand);
+
+program
+    .command('mcp')
+    .description('Start the Model Context Protocol (MCP) server')
+    .action(runMcpServer);
+
+program
+    .command('mcp:register')
+    .description('Register the MCP server in a config file')
+    .option('--path <path>', 'Write to a specific MCP config path (required)')
+    .action(registerMcpCommand);
+
+program
+    .command('restore')
+    .description('Restore the agentic system from a backup')
+    .action(restoreCommand);
+
+program.parse();

package/dist/artifacts/index.md

@@ -0,0 +1,28 @@
+---
+id: artifacts.index
+owner: architect-agent
+version: 1.0.0
+severity: PERMANENT
+---
+
+# INDEX — Artifacts
+
+## Agent identification (MANDATORY)
+First line of the document:
+`<icon> **<agent-name>**: <message>`
+
+## Objective
+List artifact aliases and their expected paths.
+
+## Aliases (YAML)
+```yaml
+artifacts:
+  candidate:
+    dir: .agent/artifacts/candidate/
+    init: .agent/artifacts/candidate/init.md
+    bootstrap: .agent/artifacts/candidate/bootstrap.md
+    task: .agent/artifacts/candidate/task.md
+```
+
+## Rules
+- Any new artifact alias MUST be added here.

package/dist/cli/commands/create.js

@@ -0,0 +1,178 @@
+import { intro, outro, spinner, note } from '@clack/prompts';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { resolveCorePath, resolveInstalledCorePath } from '../../core/mapping/resolver.js';
+/**
+ * Lógica central para la creación de componentes sin dependencias de UI (Clack).
+ * Útil para ser llamada desde el CLI o desde un servidor MCP.
+ */
+export async function performCreate(type, name, force = false) {
+    const cwd = process.cwd();
+    const agentDir = path.join(cwd, '.agent');
+    const typeFolder = type === 'role' ? 'rules/roles' : type === 'workflow' ? 'workflows' : 'tools';
+    const targetDir = path.join(agentDir, typeFolder);
+    const targetPath = path.join(targetDir, `${name}.md`);
+    try {
+        const corePath = (await resolveInstalledCorePath(cwd)) ?? await resolveCorePath();
+        const coreTypeFolder = type === 'role' ? 'rules/roles' : type === 'workflow' ? 'workflows' : 'templates';
+        const reservedPath = path.join(corePath, coreTypeFolder, `${name}.md`);
+        // 1. Reserved Namespace Check
+        try {
+            await fs.access(reservedPath);
+            return { success: false, message: `The name "${name}" is reserved by the core framework.` };
+        }
+        catch {
+            // Name is free in core
+        }
+        // 2. Local Existence Check
+        if (!force) {
+            try {
+                await fs.access(targetPath);
+                return { success: false, message: `A local file named "${name}" already exists in .agent/${typeFolder}/.`, path: targetPath };
+            }
+            catch {
+                // Name is free locally or we create it
+            }
+        }
+        // 3. Create Scaffolding
+        await fs.mkdir(targetDir, { recursive: true });
+        let content = '';
+        if (type === 'role') {
+            content = `---
+id: role.${name}-agent
+type: rule
+owner: architect-agent
+version: 1.0.0
+severity: PERMANENT
+scope: project
+---
+
+# ROLE: ${name}-agent
+
+## Identity
+You are the **${name}-agent**. Explain your purpose and specialty here.
+
+## Execution Rules (PERMANENT)
+1. **Mandatory Identification**: You MUST start ALL your responses with the prefix: \`🤖 **${name}-agent**:\`.
+2. (Add your specific rules here)
+
+## Agentic Discipline (PERMANENT)
+1. (Add your discipline principles here)
+`;
+        }
+        else if (type === 'workflow') {
+            content = `---
+id: workflow.custom.${name}
+description: Description of this custom workflow.
+owner: architect-agent
+version: 1.0.0
+severity: RECOMMENDED
+---
+
+# WORKFLOW: ${name}
+
+## Input (REQUIRED)
+- Pre-requisites
+
+## Mandatory Steps
+1. Step one
+2. Step two
+
+## Output (REQUIRED)
+- Expected result
+`;
+        }
+        await fs.writeFile(targetPath, content);
+        return { success: true, message: `${name} created successfully in .agent/${typeFolder}/`, path: targetPath };
+    }
+    catch (error) {
+        return { success: false, message: `Error during creation: ${error instanceof Error ? error.message : String(error)}` };
+    }
+}
+/**
+ * CLI Command with Clack visual interface.
+ */
+import { select, text, isCancel, cancel } from '@clack/prompts';
+export async function createCommand(type, name) {
+    intro(`Creating New ${type}: ${name}`);
+    const s = spinner();
+    s.start('Validating...');
+    // Try to create first
+    let result = await performCreate(type, name);
+    s.stop('Validation complete.');
+    // Handle conflicts interactively
+    if (!result.success && result.message.includes('reserved')) {
+        const action = await select({
+            message: `The name "${name}" is in use by the CORE. What do you want to do?`,
+            options: [
+                { value: 'rename', label: 'Rename (e.g., custom-neo)' },
+                { value: 'abort', label: 'Cancel operation' }
+            ],
+        });
+        if (isCancel(action) || action === 'abort') {
+            cancel('Operation cancelled.');
+            return process.exit(0);
+        }
+        if (action === 'rename') {
+            const newName = await text({
+                message: 'Enter the new name:',
+                placeholder: `custom-${name}`,
+                validate(value) {
+                    if (value.trim().length === 0)
+                        return 'Name cannot be empty';
+                    return;
+                },
+            });
+            if (isCancel(newName)) {
+                cancel('Operation cancelled.');
+                return process.exit(0);
+            }
+            s.start('Creating with new name...');
+            result = await performCreate(type, newName);
+            s.stop('Done.');
+        }
+    }
+    else if (!result.success && result.message.includes('already exists')) {
+        const action = await select({
+            message: `The local file "${name}" already exists. What do you want to do?`,
+            options: [
+                { value: 'overwrite', label: 'Overwrite existing file' },
+                { value: 'rename', label: 'Rename new file' },
+                { value: 'abort', label: 'Cancel' }
+            ],
+        });
+        if (isCancel(action) || action === 'abort') {
+            cancel('Operation cancelled.');
+            return process.exit(0);
+        }
+        if (action === 'overwrite') {
+            s.start('Overwriting...');
+            result = await performCreate(type, name, true);
+            s.stop('Done.');
+        }
+        else if (action === 'rename') {
+            const newName = await text({
+                message: 'Enter the new name:',
+                validate(value) {
+                    if (value.trim().length === 0)
+                        return 'Required';
+                },
+            });
+            if (isCancel(newName)) {
+                cancel('Operation cancelled.');
+                return process.exit(0);
+            }
+            s.start('Creating...');
+            result = await performCreate(type, newName);
+            s.stop('Done.');
+        }
+    }
+    if (result.success) {
+        note('Remember to register it in the local index if you want to use an alias.', 'Next Step');
+        outro(result.message);
+    }
+    else {
+        note(result.message, 'Error');
+        outro('Process finished with errors.');
+    }
+}

package/dist/cli/commands/init.js

@@ -0,0 +1,212 @@
+import { intro, outro, spinner, confirm, note } from '@clack/prompts';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { detectAgentSystem } from '../../core/migration/detector.js';
+import { transformMarkdownContent } from '../../core/migration/transformer.js';
+import { resolveCorePath, resolveInstalledCorePath } from '../../core/mapping/resolver.js';
+import { performBackup } from '../../core/utils/backup.js';
+export async function initCommand() {
+    intro('Agentic Workflow Initialization');
+    const cwd = process.cwd();
+    const agentDir = path.join(cwd, '.agent');
+    // 1. Existing System Detection
+    const systemType = await detectAgentSystem(cwd);
+    if (systemType === 'legacy') {
+        const shouldUpdate = await confirm({
+            message: 'A legacy .agent system has been detected. Do you want to migrate it to the latest portable version?',
+        });
+        if (!shouldUpdate || typeof shouldUpdate === 'symbol') {
+            outro('Initialization cancelled by user.');
+            return;
+        }
+        const sBackup = spinner();
+        sBackup.start('Creating backup...');
+        const resultBackup = await performBackup(cwd);
+        if (resultBackup) {
+            sBackup.stop(`Backup created at: ${path.relative(cwd, resultBackup)}`);
+        }
+        else {
+            sBackup.stop('No backup was required.');
+        }
+    }
+    else if (systemType === 'current') {
+        note('The system is already updated to the latest version.', 'Information');
+        const reinit = await confirm({
+            message: 'Do you want to force a re-initialization by reference? (A backup will be created)',
+        });
+        if (!reinit || typeof reinit === 'symbol') {
+            outro('Process finished.');
+            return;
+        }
+        const sBackup = spinner();
+        sBackup.start('Creating backup...');
+        const resultBackup = await performBackup(cwd);
+        sBackup.stop(`Backup created at: ${path.relative(cwd, resultBackup)}`);
+    }
+    // 2. Cleanup Legacy Files (Enforce Purity)
+    const sCleanup = spinner();
+    sCleanup.start('Cleaning up redundant legacy core files...');
+    await cleanupLegacyFiles(agentDir);
+    sCleanup.stop('Local environment cleaned (Core references only).');
+    const s = spinner();
+    s.start('Configuring Agentic Core Reference...');
+    try {
+        // Resolve absolute path to core package in node_modules
+        const corePath = (await resolveInstalledCorePath(cwd)) ?? await resolveCorePath();
+        // 1. Create .agent structure (Only project-specific directories)
+        await fs.mkdir(agentDir, { recursive: true });
+        // Create mirror directories (empty by default)
+        const mirrorDirs = ['rules/roles', 'rules/constitution', 'workflows', 'templates', 'artifacts', 'metrics'];
+        for (const dir of mirrorDirs) {
+            await fs.mkdir(path.join(agentDir, dir), { recursive: true });
+        }
+        // 2. Create Root Index with ABSOLUTE references to Core
+        const indexContent = transformMarkdownContent(`# INDEX — .agent (Root)
+
+## Objective
+Global entry point for the agentic system. It uses absolute references to the core to ensure immutability and ease of update.
+
+## Aliases (YAML)
+\`\`\`yaml
+agent:
+  core:
+    root: "${corePath}"
+    artifacts: "${path.join(corePath, 'artifacts/index.md')}"
+    rules: "${path.join(corePath, 'rules/index.md')}"
+    workflows: "${path.join(corePath, 'workflows/index.md')}"
+    templates: "${path.join(corePath, 'templates/index.md')}"
+  
+  domains:
+    workflows:
+      index: .agent/workflows/index.md
+    artifacts:
+      index: .agent/artifacts/index.md
+    rules:
+      index: .agent/rules/index.md
+    roles:
+      index: .agent/rules/roles/index.md
+    templates:
+      index: .agent/templates/index.md
+\`\`\`
+`, {
+            id: 'agent.index',
+            owner: 'architect-agent',
+            version: '1.3.0',
+            severity: 'PERMANENT',
+            description: 'Core Reference System'
+        });
+        await fs.writeFile(path.join(agentDir, 'index.md'), indexContent);
+        // 3. Create local domain indices (Proxy/Extension indices)
+        await fs.writeFile(path.join(agentDir, 'rules', 'index.md'), '# LOCAL RULES\n\nYou can add project-specific rules here.');
+        await fs.writeFile(path.join(agentDir, 'rules', 'constitution', 'index.md'), '# LOCAL CONSTITUTION\n\nYou can add project-specific constitutions here.');
+        await fs.writeFile(path.join(agentDir, 'rules', 'roles', 'index.md'), '# LOCAL ROLES\n\nYou can add custom roles here (e.g., neo-agent).');
+        await fs.writeFile(path.join(agentDir, 'workflows', 'index.md'), '# LOCAL WORKFLOWS\n\nYou can add your own custom workflows here.');
+        await fs.writeFile(path.join(agentDir, 'artifacts', 'index.md'), '# LOCAL ARTIFACTS\n\nYou can add custom artifact aliases here.');
+        // 4. Create AGENTS.md (The "Portal" for IDE Agents)
+        const agentsMdContent = `# AGENTS
+
+This project uses the **Portable Agentic Workflow** framework.
+
+## Getting Started
+To initialize the agentic session, the agent MUST first read the index files:
+1. Read the master index: \`.agent/index.md\`
+2. Follow the Core references in \`node_modules\` described in that index.
+
+## Main Workflow
+Execute the core initialization workflow:
+- \`${path.join(corePath, 'workflows/init.md')}\`
+
+## Rules and Discipline
+The core rules reside at:
+- \`${path.join(corePath, 'rules/index.md')}\`
+`;
+        await fs.writeFile(path.join(cwd, 'AGENTS.md'), agentsMdContent);
+        // 5. Create MCP Configuration for Antigravity/IDE
+        const sMcp = spinner();
+        sMcp.start('Configuring MCP Server for IDE...');
+        const mcpConfigDir = path.join(cwd, '.antigravity');
+        await fs.mkdir(mcpConfigDir, { recursive: true });
+        const mcpConfig = {
+            mcpServers: {
+                "agentic-workflow": {
+                    command: "node",
+                    args: [path.join(corePath, '../bin/cli.js'), "mcp"],
+                    env: {},
+                    disabled: false
+                }
+            }
+        };
+        await fs.writeFile(path.join(mcpConfigDir, 'task_mcp_config.json'), JSON.stringify(mcpConfig, null, 2));
+        sMcp.stop('MCP Server configured (.antigravity/task_mcp_config.json)');
+        s.stop('Configuration complete.');
+        note(`Core located at: ${corePath}\nAbsolute references have been configured for the IDE.`, 'Architecture by Reference');
+        outro('Agentic System initialized successfully\nYour core is now protected in node_modules.');
+    }
+    catch (error) {
+        s.stop('Initialization failed.');
+        console.error(error);
+        process.exit(1);
+    }
+}
+/**
+ * Removes legacy core files that should now be consumed by reference.
+ */
+async function cleanupLegacyFiles(agentDir) {
+    const coreFileNames = [
+        // Roles
+        'architect.md', 'qa.md', 'driver.md', 'researcher.md',
+        'module.md', 'surface.md', 'tooling.md', 'neo.md',
+        // Constitution
+        'GEMINI.location.md', 'agent-system.md', 'agents-behavior.md',
+        'clean-code.md', 'project-architecture.md', 'extensio-architecture.md',
+        'drivers.md', 'modules.md', 'pages.md', 'shards.md',
+        // Lifecycle Long
+        'phase-0-acceptance-criteria.md', 'phase-1-research.md', 'phase-2-analysis.md',
+        'phase-3-planning.md', 'phase-4-implementation.md', 'phase-5-verification.md',
+        'phase-6-results-acceptance.md', 'phase-7-evaluation.md', 'phase-8-commit-push.md',
+        // Lifecycle Short
+        'short-phase-1-brief.md', 'short-phase-2-implementation.md', 'short-phase-3-closure.md',
+        // Command specific
+        'init.md', 'analysis.md', 'planning.md', 'verification.md',
+        'results-acceptance.md', 'review.md', 'changelog.md',
+        'subtask-implementation.md', 'supplemental-report.md', 'todo-item.md',
+        // Templates
+        'acceptance.md', 'agent-scores.md', 'agent-task.md', 'brief.md', 'closure.md',
+        'driver-create.md', 'driver-delete.md', 'driver-refactor.md',
+        'module-create.md', 'module-delete.md', 'module-refactor.md',
+        'research.md', 'task-metrics.md', 'task.md',
+        // Driver & Module Workflows
+        'create.md', 'delete.md', 'refactor.md', 'pages.create.md', 'shards.create.md'
+    ];
+    const targetDirs = [
+        'rules/roles',
+        'rules/constitution',
+        'workflows',
+        'templates',
+        'workflows/drivers',
+        'workflows/modules',
+        'workflows/tasklifecycle-long',
+        'workflows/tasklifecycle-short'
+    ];
+    for (const relDir of targetDirs) {
+        const dirPath = path.join(agentDir, relDir);
+        try {
+            const stats = await fs.stat(dirPath);
+            if (!stats.isDirectory())
+                continue;
+            const files = await fs.readdir(dirPath);
+            for (const file of files) {
+                // Never delete index files
+                if (file === 'index.md')
+                    continue;
+                // Delete if it matches a known core filename
+                if (coreFileNames.includes(file)) {
+                    await fs.unlink(path.join(dirPath, file));
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist, skip
+        }
+    }
+}