@cleocode/cleo 2026.4.158 → 2026.5.0

package/dist/cli/commands/deps.js

@@ -0,0 +1,170 @@
+/**
+ * CLI deps command for dependency visualization and analysis.
+ *
+ * Fix #69: The critical-path subcommand calls depsCriticalPath() from core
+ * directly instead of dispatching to query:orchestrate.critical.path, which was
+ * removed from the registry in T5615 (merged into orchestrate.analyze).
+ *
+ * @task T4464
+ * @epic T4454
+ */
+import { ExitCode } from '@cleocode/contracts';
+import { depsCriticalPath, resolveProjectRoot } from '@cleocode/core/internal';
+import { defineCommand, showUsage } from 'citty';
+import { dispatchFromCli } from '../../dispatch/adapters/cli.js';
+import { cliOutput } from '../renderers/index.js';
+import { setTreeContext } from '../tree-context.js';
+/** cleo deps overview — overview of all dependencies */
+const overviewCommand = defineCommand({
+    meta: { name: 'overview', description: 'Overview of all dependencies' },
+    async run() {
+        await dispatchFromCli('query', 'tasks', 'depends', { action: 'overview' }, { command: 'deps', operation: 'tasks.depends' });
+    },
+});
+/** cleo deps show <taskId> — show dependencies for a specific task */
+const showCommand = defineCommand({
+    meta: { name: 'show', description: 'Show dependencies for a specific task' },
+    args: {
+        taskId: {
+            type: 'positional',
+            description: 'Task ID to inspect',
+            required: true,
+        },
+        tree: {
+            type: 'boolean',
+            description: 'Show full transitive dependency tree',
+        },
+    },
+    async run({ args }) {
+        await dispatchFromCli('query', 'tasks', 'depends', {
+            taskId: args.taskId,
+            tree: args.tree,
+        }, { command: 'deps', operation: 'tasks.depends' });
+    },
+});
+/** cleo deps waves <epicId> — group tasks into parallelizable execution waves */
+const wavesCommand = defineCommand({
+    meta: { name: 'waves', description: 'Group tasks into parallelizable execution waves' },
+    args: {
+        epicId: {
+            type: 'positional',
+            description: 'Epic ID to compute waves for',
+            required: true,
+        },
+    },
+    async run({ args }) {
+        await dispatchFromCli('query', 'orchestrate', 'waves', { epicId: args.epicId }, { command: 'deps', operation: 'orchestrate.waves' });
+    },
+});
+/** cleo deps critical-path <taskId> — find longest dependency chain from task */
+const criticalPathCommand = defineCommand({
+    meta: { name: 'critical-path', description: 'Find longest dependency chain from task' },
+    args: {
+        taskId: {
+            type: 'positional',
+            description: 'Task ID to trace critical path from',
+            required: true,
+        },
+    },
+    async run({ args }) {
+        const cwd = resolveProjectRoot();
+        try {
+            const result = await depsCriticalPath(args.taskId, cwd);
+            cliOutput(result, { command: 'deps', operation: 'tasks.criticalPath' });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`critical-path: ${msg}`);
+            process.exit(ExitCode.NOT_FOUND);
+        }
+    },
+});
+/** cleo deps impact <taskId> — find all tasks affected by changes to task */
+const impactCommand = defineCommand({
+    meta: { name: 'impact', description: 'Find all tasks affected by changes to task' },
+    args: {
+        taskId: {
+            type: 'positional',
+            description: 'Task ID to analyse impact for',
+            required: true,
+        },
+        depth: {
+            type: 'string',
+            description: 'Maximum depth for impact analysis',
+            default: '10',
+        },
+    },
+    async run({ args }) {
+        await dispatchFromCli('query', 'tasks', 'depends', {
+            taskId: args.taskId,
+            action: 'impact',
+            depth: Number.parseInt(args.depth, 10),
+        }, { command: 'deps', operation: 'tasks.depends' });
+    },
+});
+/** cleo deps cycles — detect circular dependencies */
+const cyclesCommand = defineCommand({
+    meta: { name: 'cycles', description: 'Detect circular dependencies' },
+    async run() {
+        await dispatchFromCli('query', 'tasks', 'depends', { action: 'cycles' }, { command: 'deps', operation: 'tasks.depends' });
+    },
+});
+/**
+ * Root deps command group — dependency visualization and analysis.
+ *
+ * Subcommands: overview, show, waves, critical-path, impact, cycles.
+ */
+export const depsCommand = defineCommand({
+    meta: { name: 'deps', description: 'Dependency visualization and analysis' },
+    subCommands: {
+        overview: overviewCommand,
+        show: showCommand,
+        waves: wavesCommand,
+        'critical-path': criticalPathCommand,
+        impact: impactCommand,
+        cycles: cyclesCommand,
+    },
+    async run({ cmd, rawArgs }) {
+        const firstArg = rawArgs?.find((a) => !a.startsWith('-'));
+        if (firstArg && cmd.subCommands && firstArg in cmd.subCommands)
+            return;
+        await showUsage(cmd);
+    },
+});
+/**
+ * Standalone tree command — task hierarchy tree visualization.
+ *
+ * @remarks
+ * Kept as a separate export so that index.ts can wire it to `cleo tree`.
+ *
+ * Flags:
+ * - `--with-deps`  — inline each task's direct dependency chain below the task line.
+ * - `--blockers`   — render transitive blocker chain + leaf blockers for every
+ *                    blocked task in the tree.
+ */
+export const treeCommand = defineCommand({
+    meta: { name: 'tree', description: 'Task hierarchy tree visualization' },
+    args: {
+        rootId: {
+            type: 'positional',
+            description: 'Root task ID (optional)',
+            required: false,
+        },
+        withDeps: {
+            type: 'boolean',
+            description: 'Inline dependency chain below each task that has deps',
+            default: false,
+        },
+        blockers: {
+            type: 'boolean',
+            description: 'Render transitive blocker chain and leaf blockers below each blocked task',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        // Store flags in the tree context so renderTree can read them.
+        setTreeContext({ withDeps: args.withDeps, withBlockers: args.blockers });
+        await dispatchFromCli('query', 'tasks', 'tree', { taskId: args.rootId, withBlockers: args.blockers }, { command: 'tree', operation: 'tasks.tree' });
+    },
+});
+//# sourceMappingURL=deps.js.map

package/dist/cli/commands/deps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deps.js","sourceRoot":"","sources":["../../../src/cli/commands/deps.ts"],"names":[],"mappings":"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"}

package/dist/cli/commands/detect-drift.d.ts

@@ -0,0 +1,23 @@
+/**
+ * detect-drift command - Documentation drift detection for LLM agents
+ *
+ * @epic T4698
+ * @task T4705
+ * @task T487 — migrated to native citty pattern
+ *
+ * Exit codes:
+ *   0 - No drift detected (all checks pass)
+ *   1 - Warnings only (documentation exists but needs attention)
+ *   2 - Errors detected (missing documentation or critical drift)
+ *
+ * Output: LAFS-compliant JSON envelope for agent consumption
+ */
+/**
+ * Native citty command for `cleo detect-drift`.
+ *
+ * Runs static documentation drift analysis against the TypeScript source of
+ * truth. In user projects only the injection-template check applies; in the
+ * CLEO monorepo all 8 checks are executed.
+ */
+export declare const detectDriftCommand: import("citty").CommandDef<import("citty").ArgsDef>;
+//# sourceMappingURL=detect-drift.d.ts.map

package/dist/cli/commands/detect-drift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-drift.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/detect-drift.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAuDH;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,qDA4a7B,CAAC"}

package/dist/cli/commands/detect-drift.js

@@ -0,0 +1,440 @@
+/**
+ * detect-drift command - Documentation drift detection for LLM agents
+ *
+ * @epic T4698
+ * @task T4705
+ * @task T487 — migrated to native citty pattern
+ *
+ * Exit codes:
+ *   0 - No drift detected (all checks pass)
+ *   1 - Warnings only (documentation exists but needs attention)
+ *   2 - Errors detected (missing documentation or critical drift)
+ *
+ * Output: LAFS-compliant JSON envelope for agent consumption
+ */
+// CLI-only: detect-drift runs local static analysis; session.context.drift is a different operation
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { getErrorMessage } from '@cleocode/contracts';
+import { defineCommand } from 'citty';
+import { CLEO_DIR_NAME, CLEO_INJECTION_MD, TEMPLATES_SUBDIR } from '../paths.js';
+import { cliOutput } from '../renderers/index.js';
+function findProjectRoot() {
+    // Start from CWD, not the CLI file location. When installed via npm,
+    // the CLI bundle is in node_modules — walking up from there finds the
+    // npm package dir instead of the user's project (#78).
+    let currentDir = process.cwd();
+    while (currentDir !== '/') {
+        if (existsSync(join(currentDir, 'package.json'))) {
+            return currentDir;
+        }
+        const parent = dirname(currentDir);
+        if (parent === currentDir)
+            break;
+        currentDir = parent;
+    }
+    return process.cwd();
+}
+/**
+ * Native citty command for `cleo detect-drift`.
+ *
+ * Runs static documentation drift analysis against the TypeScript source of
+ * truth. In user projects only the injection-template check applies; in the
+ * CLEO monorepo all 8 checks are executed.
+ */
+export const detectDriftCommand = defineCommand({
+    meta: {
+        name: 'detect-drift',
+        description: 'Detect documentation drift against TypeScript source of truth',
+    },
+    async run() {
+        const projectRoot = findProjectRoot();
+        // Detect if we're running inside the CLEO source repo vs a user project.
+        // The source-level checks only apply to the CLEO monorepo itself — skip
+        // them in user projects (#78).
+        const isCleoRepo = existsSync(join(projectRoot, 'packages', 'cleo', 'src'));
+        // In the CLEO monorepo, source lives under packages/cleo/src/ not src/.
+        const cleoSrcRoot = isCleoRepo
+            ? join(projectRoot, 'packages', 'cleo', 'src')
+            : join(projectRoot, 'src');
+        const safeRead = (filePath) => {
+            try {
+                return readFileSync(filePath, 'utf-8');
+            }
+            catch {
+                return '';
+            }
+        };
+        if (!isCleoRepo) {
+            // In user projects, only run applicable checks (injection template, config)
+            const userResult = {
+                summary: { totalChecks: 1, passed: 0, warnings: 0, errors: 0, exitCode: 0 },
+                checks: [],
+                recommendations: [],
+            };
+            // Check: agent injection template
+            const injPath = join(projectRoot, CLEO_DIR_NAME, TEMPLATES_SUBDIR, CLEO_INJECTION_MD);
+            if (existsSync(injPath)) {
+                const content = safeRead(injPath);
+                userResult.checks.push({
+                    name: 'Agent injection',
+                    status: content.length > 100 ? 'pass' : 'warn',
+                    message: content.length > 100
+                        ? 'Agent injection template exists'
+                        : 'Template appears incomplete',
+                    issues: [],
+                });
+                userResult.summary.passed = content.length > 100 ? 1 : 0;
+                userResult.summary.warnings = content.length > 100 ? 0 : 1;
+            }
+            else {
+                userResult.checks.push({
+                    name: 'Agent injection',
+                    status: 'warn',
+                    message: 'No injection template found — run `cleo init` to create one',
+                    issues: [],
+                });
+                userResult.summary.warnings = 1;
+            }
+            userResult.summary.exitCode =
+                userResult.summary.errors > 0 ? 2 : userResult.summary.warnings > 0 ? 1 : 0;
+            userResult.recommendations.push('detect-drift source checks only apply to the CLEO monorepo. Run from the cleo source tree for full analysis.');
+            cliOutput(userResult, { command: 'detect-drift' });
+            process.exit(userResult.summary.exitCode);
+        }
+        const result = {
+            summary: {
+                totalChecks: 0,
+                passed: 0,
+                warnings: 0,
+                errors: 0,
+                exitCode: 0,
+            },
+            checks: [],
+            recommendations: [],
+        };
+        const addCheck = (name, status, message, issues = []) => {
+            result.checks.push({ name, status, message, issues });
+            result.summary.totalChecks++;
+            if (status === 'pass')
+                result.summary.passed++;
+            if (status === 'warn') {
+                result.summary.warnings++;
+                result.summary.exitCode = Math.max(result.summary.exitCode, 1);
+            }
+            if (status === 'fail') {
+                result.summary.errors++;
+                result.summary.exitCode = 2;
+            }
+        };
+        // Check 1: Gateway-to-spec sync
+        try {
+            const specPath = join(projectRoot, 'docs', 'specs', 'CLEO-OPERATION-CONSTITUTION.md');
+            const registryPath = join(cleoSrcRoot, 'dispatch', 'registry.ts');
+            const dispatchDomainsDir = join(cleoSrcRoot, 'dispatch', 'domains');
+            if (!existsSync(specPath)) {
+                addCheck('Gateway-to-spec sync', 'fail', 'CLEO-OPERATION-CONSTITUTION.md missing', [
+                    {
+                        severity: 'error',
+                        category: 'spec',
+                        message: 'Operations reference specification not found',
+                        file: specPath,
+                        recommendation: 'Create docs/specs/CLEO-OPERATION-CONSTITUTION.md with canonical operation definitions',
+                    },
+                ]);
+            }
+            else if (!existsSync(registryPath) || !existsSync(dispatchDomainsDir)) {
+                addCheck('Gateway-to-spec sync', 'fail', 'Dispatch registry or domains missing', [
+                    {
+                        severity: 'error',
+                        category: 'implementation',
+                        message: 'Dispatch registry or domains directory not found',
+                        file: registryPath,
+                        recommendation: 'Verify packages/cleo/src/dispatch/registry.ts and packages/cleo/src/dispatch/domains/ exist',
+                    },
+                ]);
+            }
+            else {
+                const specContent = safeRead(specPath);
+                const registryContent = safeRead(registryPath);
+                // Extract operations from spec
+                const specOpsMatch = specContent.match(/## `([a-z_]+)`/g) || [];
+                const specOps = specOpsMatch.map((m) => m.replace(/## `|`/g, ''));
+                // Extract operations from registry
+                const registryOpsMatch = registryContent.match(/operation:\s*'([a-z_.]+)'/g) || [];
+                const registryOps = registryOpsMatch.map((m) => m.replace(/operation:\s*'|'/g, ''));
+                // Find mismatches
+                const specOnly = specOps.filter((op) => !registryOps.includes(op));
+                const gatewayOnly = registryOps.filter((op) => !specOps.includes(op));
+                if (specOnly.length === 0 && gatewayOnly.length === 0) {
+                    addCheck('Gateway-to-spec sync', 'pass', `All ${specOps.length} operations synchronized`);
+                }
+                else {
+                    const issues = [];
+                    if (specOnly.length > 0) {
+                        issues.push({
+                            severity: 'warning',
+                            category: 'spec-coverage',
+                            message: `${specOnly.length} operations in spec but not in gateways: ${specOnly.join(', ')}`,
+                            recommendation: 'Add missing operation handlers to dispatch domains or remove from spec',
+                        });
+                    }
+                    if (gatewayOnly.length > 0) {
+                        issues.push({
+                            severity: 'warning',
+                            category: 'implementation-coverage',
+                            message: `${gatewayOnly.length} operations in gateways but not in spec: ${gatewayOnly.join(', ')}`,
+                            recommendation: 'Document missing operations in CLEO-OPERATIONS-REFERENCE.md',
+                        });
+                    }
+                    addCheck('Gateway-to-spec sync', 'warn', `Found ${specOnly.length + gatewayOnly.length} operation mismatches`, issues);
+                }
+            }
+        }
+        catch (e) {
+            addCheck('Gateway-to-spec sync', 'fail', `Error: ${getErrorMessage(e)}`, [
+                {
+                    severity: 'error',
+                    category: 'system',
+                    message: getErrorMessage(e),
+                    recommendation: 'Check file permissions and paths',
+                },
+            ]);
+        }
+        // Check 2: CLI-to-core sync
+        try {
+            const cliDir = join(cleoSrcRoot, 'cli', 'commands');
+            const coreDir = isCleoRepo
+                ? join(projectRoot, 'packages', 'core', 'src')
+                : join(projectRoot, 'src', 'core');
+            if (!existsSync(cliDir)) {
+                addCheck('CLI-to-core sync', 'fail', 'CLI commands directory missing', [
+                    {
+                        severity: 'error',
+                        category: 'structure',
+                        message: `${cliDir} directory not found`,
+                        recommendation: 'Verify TypeScript source structure is intact',
+                    },
+                ]);
+            }
+            else if (!existsSync(coreDir)) {
+                addCheck('CLI-to-core sync', 'fail', 'Core directory missing', [
+                    {
+                        severity: 'error',
+                        category: 'structure',
+                        message: `${coreDir} directory not found`,
+                        recommendation: 'Verify TypeScript source structure is intact',
+                    },
+                ]);
+            }
+            else {
+                const files = readdirSync(cliDir).filter((f) => f.endsWith('.ts') && !f.includes('.test.'));
+                addCheck('CLI-to-core sync', 'pass', `Found ${files.length} CLI command implementations`);
+            }
+        }
+        catch (e) {
+            addCheck('CLI-to-core sync', 'fail', `Error: ${getErrorMessage(e)}`);
+        }
+        // Check 3: Domain handler coverage
+        try {
+            const domainsDir = join(cleoSrcRoot, 'dispatch', 'domains');
+            if (!existsSync(domainsDir)) {
+                addCheck('Domain handler coverage', 'fail', 'Dispatch domains directory missing', [
+                    {
+                        severity: 'error',
+                        category: 'structure',
+                        message: `${domainsDir} not found`,
+                        recommendation: 'Verify dispatch domain handlers are in place',
+                    },
+                ]);
+            }
+            else {
+                const files = readdirSync(domainsDir).filter((f) => f.endsWith('.ts'));
+                addCheck('Domain handler coverage', 'pass', `Found ${files.length} domain handlers`);
+            }
+        }
+        catch (e) {
+            addCheck('Domain handler coverage', 'fail', `Error: ${getErrorMessage(e)}`);
+        }
+        // Check 4: Capability matrix
+        try {
+            const matrixPath = join(cleoSrcRoot, 'dispatch', 'lib', 'capability-matrix.ts');
+            if (!existsSync(matrixPath)) {
+                addCheck('Capability matrix', 'fail', 'Capability matrix missing', [
+                    {
+                        severity: 'error',
+                        category: 'configuration',
+                        message: `${matrixPath} not found`,
+                        recommendation: 'Create capability matrix to document supported operations',
+                    },
+                ]);
+            }
+            else {
+                addCheck('Capability matrix', 'pass', 'Capability matrix exists');
+            }
+        }
+        catch (e) {
+            addCheck('Capability matrix', 'fail', `Error: ${getErrorMessage(e)}`);
+        }
+        // Check 5: Schema validation
+        try {
+            const schemaPath = join(projectRoot, 'src', 'store', 'schema.ts');
+            if (!existsSync(schemaPath)) {
+                addCheck('Schema validation', 'fail', 'Schema definition missing', [
+                    {
+                        severity: 'error',
+                        category: 'data-model',
+                        message: 'src/store/schema.ts not found',
+                        recommendation: 'Create schema definition for database tables',
+                    },
+                ]);
+            }
+            else {
+                const content = safeRead(schemaPath);
+                const tableCount = (content.match(/CREATE TABLE/g) || []).length;
+                if (tableCount === 0) {
+                    addCheck('Schema validation', 'warn', 'Schema file exists but no CREATE TABLE statements', [
+                        {
+                            severity: 'warning',
+                            category: 'data-model',
+                            message: 'No SQL table definitions found in schema.ts',
+                            recommendation: 'Add CREATE TABLE statements for all database entities',
+                        },
+                    ]);
+                }
+                else {
+                    addCheck('Schema validation', 'pass', `Schema defines ${tableCount} tables`);
+                }
+            }
+        }
+        catch (e) {
+            addCheck('Schema validation', 'fail', `Error: ${getErrorMessage(e)}`);
+        }
+        // Check 6: Canonical identity
+        try {
+            const visionPath = join(projectRoot, 'docs', 'concepts', 'CLEO-VISION.md');
+            const specPath = join(projectRoot, 'docs', 'specs', 'CLEO-PORTABLE-PROJECT-BRAIN-SPEC.md');
+            const issues = [];
+            if (!existsSync(visionPath)) {
+                issues.push({
+                    severity: 'error',
+                    category: 'vision',
+                    message: 'Vision document missing',
+                    file: visionPath,
+                    recommendation: 'Create docs/concepts/CLEO-VISION.md with project vision',
+                });
+            }
+            if (!existsSync(specPath)) {
+                issues.push({
+                    severity: 'error',
+                    category: 'spec',
+                    message: 'Portable Brain spec missing',
+                    file: specPath,
+                    recommendation: 'Create docs/specs/CLEO-PORTABLE-PROJECT-BRAIN-SPEC.md with canonical pillars',
+                });
+            }
+            if (issues.length > 0) {
+                addCheck('Canonical identity', 'fail', 'Canonical documents missing', issues);
+            }
+            else {
+                const specContent = safeRead(specPath);
+                const requiredPillars = [
+                    'Portable Memory',
+                    'Provenance by Default',
+                    'Interoperable Interfaces',
+                    'Deterministic Safety',
+                    'Cognitive Retrieval',
+                ];
+                const missingPillars = requiredPillars.filter((p) => !specContent.includes(p));
+                if (missingPillars.length > 0) {
+                    addCheck('Canonical identity', 'fail', `Missing ${missingPillars.length} canonical pillars`, [
+                        {
+                            severity: 'error',
+                            category: 'vision',
+                            message: `Missing pillars: ${missingPillars.join(', ')}`,
+                            file: specPath,
+                            recommendation: 'Add all five canonical pillars to CLEO-PORTABLE-PROJECT-BRAIN-SPEC.md',
+                        },
+                    ]);
+                }
+                else {
+                    addCheck('Canonical identity', 'pass', 'All canonical pillars documented');
+                }
+            }
+        }
+        catch (e) {
+            addCheck('Canonical identity', 'fail', `Error: ${getErrorMessage(e)}`);
+        }
+        // Check 7: Agent injection template
+        try {
+            const injectionPath = join(projectRoot, CLEO_DIR_NAME, TEMPLATES_SUBDIR, CLEO_INJECTION_MD);
+            if (!existsSync(injectionPath)) {
+                addCheck('Agent injection', 'fail', 'Agent injection template missing', [
+                    {
+                        severity: 'error',
+                        category: 'agent-support',
+                        message: 'CLEO-INJECTION.md not found',
+                        file: injectionPath,
+                        recommendation: 'Create agent injection template or run cleo init',
+                    },
+                ]);
+            }
+            else {
+                const content = safeRead(injectionPath);
+                if (content.length < 100) {
+                    addCheck('Agent injection', 'warn', 'Agent injection template appears incomplete', [
+                        {
+                            severity: 'warning',
+                            category: 'agent-support',
+                            message: 'Template file is unusually short',
+                            recommendation: 'Verify template contains required agent instructions',
+                        },
+                    ]);
+                }
+                else {
+                    addCheck('Agent injection', 'pass', 'Agent injection template exists');
+                }
+            }
+        }
+        catch (e) {
+            addCheck('Agent injection', 'fail', `Error: ${getErrorMessage(e)}`);
+        }
+        // Check 8: Exit codes
+        try {
+            const exitCodesPath = join(cleoSrcRoot, 'dispatch', 'lib', 'exit-codes.ts');
+            if (!existsSync(exitCodesPath)) {
+                addCheck('Exit codes', 'fail', 'Exit codes definition missing', [
+                    {
+                        severity: 'error',
+                        category: 'protocol',
+                        message: `${exitCodesPath} not found`,
+                        recommendation: 'Create exit codes definition for CLI protocol compliance',
+                    },
+                ]);
+            }
+            else {
+                const content = safeRead(exitCodesPath);
+                const codeCount = (content.match(/= \d+/g) || []).length;
+                addCheck('Exit codes', 'pass', `${codeCount} exit codes defined`);
+            }
+        }
+        catch (e) {
+            addCheck('Exit codes', 'fail', `Error: ${getErrorMessage(e)}`);
+        }
+        // Generate top-level recommendations based on findings
+        if (result.summary.errors > 0) {
+            result.recommendations.push('Address all ERROR-level issues before proceeding');
+        }
+        if (result.summary.warnings > 0) {
+            result.recommendations.push('Review WARNING-level issues for documentation improvements');
+        }
+        if (result.summary.errors === 0 && result.summary.warnings === 0) {
+            result.recommendations.push('Documentation is synchronized with implementation');
+        }
+        // Output via LAFS-compliant cliOutput
+        cliOutput(result, { command: 'detect-drift' });
+        // Exit with appropriate code for scripting
+        process.exit(result.summary.exitCode);
+    },
+});
+//# sourceMappingURL=detect-drift.js.map