@kynetic-ai/spec 0.1.2 → 0.4.0

package/dist/cli/commands/validate.js

@@ -1,9 +1,10 @@
-import * as path from 'node:path';
-import chalk from 'chalk';
-import { initContext, validate, loadAllTasks, loadAllItems, AlignmentIndex, ReferenceIndex, fixFiles, findTaskFiles, expandIncludePattern, loadMetaContext, validateConventions, } from '../../parser/index.js';
-import { output, error } from '../output.js';
-import { validation as validationStrings } from '../../strings/index.js';
-import { EXIT_CODES } from '../exit-codes.js';
+import * as path from "node:path";
+import chalk from "chalk";
+import { AlignmentIndex, checkACSchemaReferences, expandIncludePattern, findTaskFiles, fixFiles, initContext, loadAllItems, loadAllTasks, loadMetaContext, ReferenceIndex, validate, validateConventions, } from "../../parser/index.js";
+import { validateSkills, } from "../../parser/validate-skills.js";
+import { validation as validationStrings } from "../../strings/index.js";
+import { EXIT_CODES } from "../exit-codes.js";
+import { error, output } from "../output.js";
 /**
  * Check for stale status mismatches between specs and tasks
  * AC: @stale-status-detection ac-1, ac-2, ac-3
@@ -14,39 +15,39 @@ function checkStaleness(items, tasks, refIndex) {
     // Check if task with dependencies is pending but all dependencies are completed
     for (const task of tasks) {
         // Only check pending/in_progress tasks with dependencies
-        if (task.status !== 'pending' && task.status !== 'in_progress')
+        if (task.status !== "pending" && task.status !== "in_progress")
             continue;
         if (!task.depends_on || task.depends_on.length === 0)
             continue;
         // Resolve all dependency tasks
         const depTasks = task.depends_on
-            .map(depRef => {
+            .map((depRef) => {
             const result = refIndex.resolve(depRef);
             if (!result.ok)
                 return null;
-            return tasks.find(t => t._ulid === result.ulid);
+            return tasks.find((t) => t._ulid === result.ulid);
         })
             .filter((t) => t !== null);
         if (depTasks.length === 0)
             continue;
         // Check if all dependencies are completed and their linked specs are implemented
-        const allDepsDone = depTasks.every(depTask => {
-            if (depTask.status !== 'completed')
+        const allDepsDone = depTasks.every((depTask) => {
+            if (depTask.status !== "completed")
                 return false;
             // If the dep task has a spec_ref, check if that spec is implemented
             if (depTask.spec_ref) {
                 const result = refIndex.resolve(depTask.spec_ref);
                 if (!result.ok)
                     return true; // Missing spec ref doesn't block
-                const spec = items.find(item => item._ulid === result.ulid);
-                return spec?.status?.implementation === 'implemented';
+                const spec = items.find((item) => item._ulid === result.ulid);
+                return spec?.status?.implementation === "implemented";
             }
             return true;
         });
         if (allDepsDone) {
             const taskRef = task.slugs[0] || refIndex.shortUlid(task._ulid);
             warnings.push({
-                type: 'parent-pending-children-done',
+                type: "parent-pending-children-done",
                 message: `Task @${taskRef} is ${task.status} but all dependencies are completed. Consider completing or reviewing.`,
                 refs: [task._ulid],
             });
@@ -55,11 +56,16 @@ function checkStaleness(items, tasks, refIndex) {
     // AC: @stale-status-detection ac-2 (spec-implemented-no-task)
     // Check if spec is implemented but has no completed tasks
     for (const item of items) {
-        if (item.status?.implementation !== 'implemented')
+        if (item.status?.implementation !== "implemented")
+            continue;
+        // AC: @trait-retrospective ac-1
+        // Skip retrospective specs from staleness warnings
+        const isRetrospective = item.traits?.includes("@trait-retrospective");
+        if (isRetrospective)
             continue;
         // Find completed tasks that reference this spec
-        const completedTasks = tasks.filter(task => {
-            if (task.status !== 'completed' || !task.spec_ref)
+        const completedTasks = tasks.filter((task) => {
+            if (task.status !== "completed" || !task.spec_ref)
                 return false;
             const result = refIndex.resolve(task.spec_ref);
             return result.ok && result.ulid === item._ulid;
@@ -67,7 +73,7 @@ function checkStaleness(items, tasks, refIndex) {
         if (completedTasks.length === 0) {
             const specRef = item.slugs[0] || refIndex.shortUlid(item._ulid);
             warnings.push({
-                type: 'spec-implemented-no-task',
+                type: "spec-implemented-no-task",
                 message: `Spec @${specRef} is implemented but has no completed tasks. Verify implementation or link existing task.`,
                 refs: [item._ulid],
             });
@@ -76,7 +82,7 @@ function checkStaleness(items, tasks, refIndex) {
     // AC: @stale-status-detection ac-3 (task-done-spec-not-started)
     // Check if task is completed but spec is still not_started
     for (const task of tasks) {
-        if (task.status !== 'completed')
+        if (task.status !== "completed")
             continue;
         if (!task.spec_ref)
             continue;
@@ -84,19 +90,41 @@ function checkStaleness(items, tasks, refIndex) {
         const result = refIndex.resolve(task.spec_ref);
         if (!result.ok)
             continue;
-        const spec = items.find(item => item._ulid === result.ulid);
+        const spec = items.find((item) => item._ulid === result.ulid);
         if (!spec)
             continue;
-        if (spec.status?.implementation === 'not_started') {
+        if (spec.status?.implementation === "not_started") {
             const taskRef = task.slugs[0] || refIndex.shortUlid(task._ulid);
             const specRef = spec.slugs[0] || refIndex.shortUlid(spec._ulid);
             warnings.push({
-                type: 'task-done-spec-not-started',
+                type: "task-done-spec-not-started",
                 message: `Task @${taskRef} completed but spec @${specRef} is not_started. Update spec status.`,
                 refs: [task._ulid, spec._ulid],
             });
         }
     }
+    // AC: @validation ac-1
+    // Check for manual_only parents blocking eligible children
+    for (const parentTask of tasks) {
+        if (parentTask.automation !== "manual_only")
+            continue;
+        // Find tasks that depend on this parent
+        const dependentTasks = tasks.filter((t) => t.depends_on?.some((depRef) => {
+            const result = refIndex.resolve(depRef);
+            return result.ok && result.ulid === parentTask._ulid;
+        }));
+        // Filter for eligible children
+        const eligibleChildren = dependentTasks.filter((t) => t.automation === "eligible");
+        if (eligibleChildren.length > 0) {
+            const parentRef = parentTask.slugs[0] || refIndex.shortUlid(parentTask._ulid);
+            const childRefs = eligibleChildren.map((c) => `@${c.slugs[0] || refIndex.shortUlid(c._ulid)}`);
+            warnings.push({
+                type: "automation-blocking",
+                message: `Task @${parentRef} is manual_only and blocks ${eligibleChildren.length} eligible child task(s): ${childRefs.join(", ")}`,
+                refs: [parentTask._ulid, ...eligibleChildren.map((c) => c._ulid)],
+            });
+        }
+    }
     return warnings;
 }
 /**
@@ -105,14 +133,15 @@ function checkStaleness(items, tasks, refIndex) {
  */
 function formatStalenessWarnings(warnings, verbose) {
     if (warnings.length === 0) {
-        console.log(chalk.green('Staleness: OK'));
+        console.log(chalk.green("Staleness: OK"));
         return;
     }
     console.log(chalk.yellow(`\nStaleness warnings: ${warnings.length}`));
     // Group by type
-    const parentPending = warnings.filter(w => w.type === 'parent-pending-children-done');
-    const specNoTask = warnings.filter(w => w.type === 'spec-implemented-no-task');
-    const taskDoneSpecNot = warnings.filter(w => w.type === 'task-done-spec-not-started');
+    const parentPending = warnings.filter((w) => w.type === "parent-pending-children-done");
+    const specNoTask = warnings.filter((w) => w.type === "spec-implemented-no-task");
+    const taskDoneSpecNot = warnings.filter((w) => w.type === "task-done-spec-not-started");
+    const automationBlocking = warnings.filter((w) => w.type === "automation-blocking");
     if (parentPending.length > 0) {
         console.log(chalk.yellow(`  Parent pending, children done: ${parentPending.length}`));
         const shown = verbose ? parentPending : parentPending.slice(0, 3);
@@ -143,6 +172,50 @@ function formatStalenessWarnings(warnings, verbose) {
             console.log(chalk.gray(`    ... and ${taskDoneSpecNot.length - 3} more`));
         }
     }
+    if (automationBlocking.length > 0) {
+        console.log(chalk.yellow(`  Automation blocking: ${automationBlocking.length}`));
+        const shown = verbose ? automationBlocking : automationBlocking.slice(0, 3);
+        for (const w of shown) {
+            console.log(chalk.yellow(`    ! ${w.message}`));
+        }
+        if (!verbose && automationBlocking.length > 3) {
+            console.log(chalk.gray(`    ... and ${automationBlocking.length - 3} more`));
+        }
+    }
+}
+/**
+ * Format AC schema drift warnings for display
+ */
+function formatDriftWarnings(warnings, verbose) {
+    // Filter to only drift warnings
+    const driftWarnings = warnings.filter((w) => w.type === "ac_schema_field_mismatch");
+    if (driftWarnings.length === 0) {
+        console.log(chalk.green("AC Schema Drift: OK"));
+        return;
+    }
+    console.log(chalk.yellow(`\nAC Schema Drift warnings: ${driftWarnings.length}`));
+    // Group by item
+    const byItem = new Map();
+    for (const w of driftWarnings) {
+        const existing = byItem.get(w.itemRef) || [];
+        existing.push(w);
+        byItem.set(w.itemRef, existing);
+    }
+    const itemEntries = [...byItem.entries()];
+    const shown = verbose ? itemEntries : itemEntries.slice(0, 5);
+    for (const [itemRef, itemWarnings] of shown) {
+        const firstWarning = itemWarnings[0];
+        console.log(chalk.yellow(`  ${itemRef} - ${firstWarning.itemTitle}`));
+        for (const w of itemWarnings) {
+            console.log(chalk.yellow(`    ! ${w.message}`));
+            if (w.details) {
+                console.log(chalk.gray(`      ${w.details}`));
+            }
+        }
+    }
+    if (!verbose && itemEntries.length > 5) {
+        console.log(chalk.gray(`  ... and ${itemEntries.length - 5} more items with drift`));
+    }
 }
 /**
  * Format convention validation results for display
@@ -150,7 +223,7 @@ function formatStalenessWarnings(warnings, verbose) {
  */
 function formatConventionValidationResult(result) {
     if (result.valid && result.skipped.length === 0) {
-        console.log(chalk.green('Conventions: OK'));
+        console.log(chalk.green("Conventions: OK"));
         return;
     }
     // AC: @convention-definitions ac-4
@@ -176,28 +249,62 @@ function formatConventionValidationResult(result) {
         }
     }
     else {
-        console.log(chalk.green('\nConventions: OK'));
+        console.log(chalk.green("\nConventions: OK"));
     }
     // Stats
     console.log(chalk.gray(`\nConventions checked: ${result.stats.conventionsChecked}`));
     console.log(chalk.gray(`Conventions skipped: ${result.stats.conventionsSkipped}`));
 }
+/**
+ * Format skill validation results for display
+ */
+function formatSkillValidationResult(result, verbose) {
+    if (result.filesChecked === 0) {
+        console.log(chalk.gray("Skills: No skill files found"));
+        return;
+    }
+    if (result.valid) {
+        console.log(chalk.green(`Skills: OK (${result.filesChecked} files checked)`));
+        return;
+    }
+    console.log(chalk.red(`\nSkill validation errors: ${result.errors.length}`));
+    console.log(chalk.gray(`Files checked: ${result.filesChecked}`));
+    // Group errors by file
+    const errorsByFile = new Map();
+    for (const err of result.errors) {
+        const existing = errorsByFile.get(err.file) || [];
+        existing.push(err);
+        errorsByFile.set(err.file, existing);
+    }
+    for (const [file, errors] of errorsByFile.entries()) {
+        console.log(chalk.yellow(`\n  ${file}:`));
+        const shown = verbose ? errors : errors.slice(0, 5);
+        for (const err of shown) {
+            const location = err.line ? `:${err.line}` : "";
+            console.log(chalk.red(`    ✗ ${err.type}${location}`));
+            console.log(chalk.gray(`      ${err.message}`));
+        }
+        if (!verbose && errors.length > 5) {
+            console.log(chalk.gray(`    ... and ${errors.length - 5} more`));
+        }
+    }
+}
 /**
  * Format completeness warnings for display
  * AC: @spec-completeness ac-4
  */
 function formatCompletenessWarnings(warnings, verbose) {
     if (warnings.length === 0) {
-        console.log(chalk.green('Completeness: OK'));
+        console.log(chalk.green("Completeness: OK"));
         return;
     }
     console.log(chalk.yellow(`\nCompleteness warnings: ${warnings.length}`));
     // Group by type
-    const missingAC = warnings.filter(w => w.type === 'missing_acceptance_criteria');
-    const missingDesc = warnings.filter(w => w.type === 'missing_description');
-    const statusMismatch = warnings.filter(w => w.type === 'status_inconsistency');
-    const missingTestCoverage = warnings.filter(w => w.type === 'missing_test_coverage');
-    const automationNoSpec = warnings.filter(w => w.type === 'automation_eligible_no_spec');
+    const missingAC = warnings.filter((w) => w.type === "missing_acceptance_criteria");
+    const missingDesc = warnings.filter((w) => w.type === "missing_description");
+    const statusMismatch = warnings.filter((w) => w.type === "status_inconsistency");
+    const missingTestCoverage = warnings.filter((w) => w.type === "missing_test_coverage");
+    const automationNoSpec = warnings.filter((w) => w.type === "automation_eligible_no_spec");
     // AC: @spec-completeness ac-4
     // Show summary with counts by issue type
     if (missingAC.length > 0) {
@@ -231,7 +338,9 @@ function formatCompletenessWarnings(warnings, verbose) {
     }
     if (missingTestCoverage.length > 0) {
         console.log(chalk.yellow(`  Missing test coverage: ${missingTestCoverage.length}`));
-        const shown = verbose ? missingTestCoverage : missingTestCoverage.slice(0, 3);
+        const shown = verbose
+            ? missingTestCoverage
+            : missingTestCoverage.slice(0, 3);
         for (const w of shown) {
             console.log(chalk.yellow(`    ! ${w.itemRef} - ${w.itemTitle}`));
             if (w.details) {
@@ -260,14 +369,14 @@ function formatCompletenessWarnings(warnings, verbose) {
  */
 function formatAlignmentWarnings(warnings, verbose) {
     if (warnings.length === 0) {
-        console.log(chalk.green('Alignment: OK'));
+        console.log(chalk.green("Alignment: OK"));
         return;
     }
     console.log(chalk.yellow(`\nAlignment warnings: ${warnings.length}`));
     // Group by type
-    const orphaned = warnings.filter(w => w.type === 'orphaned_spec');
-    const mismatches = warnings.filter(w => w.type === 'status_mismatch');
-    const stale = warnings.filter(w => w.type === 'stale_implementation');
+    const orphaned = warnings.filter((w) => w.type === "orphaned_spec");
+    const mismatches = warnings.filter((w) => w.type === "status_mismatch");
+    const stale = warnings.filter((w) => w.type === "stale_implementation");
     if (orphaned.length > 0) {
         console.log(chalk.yellow(`  Orphaned specs (no tasks): ${orphaned.length}`));
         const shown = verbose ? orphaned : orphaned.slice(0, 3);
@@ -297,15 +406,15 @@ function formatAlignmentWarnings(warnings, verbose) {
  */
 function formatFixResult(result) {
     if (result.fixesApplied.length === 0) {
-        console.log(chalk.gray('\nNo auto-fixable issues found.'));
+        console.log(chalk.gray("\nNo auto-fixable issues found."));
         return;
     }
     console.log(chalk.cyan(`\n✓ Applied ${result.fixesApplied.length} fix(es) to ${result.filesModified} file(s):`));
     for (const fix of result.fixesApplied) {
         const typeLabel = {
-            ulid_regenerated: 'ULID regenerated',
-            timestamp_added: 'Timestamp added',
-            status_added: 'Status added',
+            ulid_regenerated: "ULID regenerated",
+            timestamp_added: "Timestamp added",
+            status_added: "Status added",
         }[fix.type];
         const shortFile = path.basename(fix.file);
         console.log(chalk.cyan(`  ✓ ${shortFile}:${fix.path} - ${typeLabel}`));
@@ -324,9 +433,9 @@ async function collectFixableFiles(ctx) {
     const files = [];
     // Task files (exclude test fixtures)
     const taskFiles = await findTaskFiles(ctx.rootDir);
-    const specTaskFiles = await findTaskFiles(path.join(ctx.rootDir, 'spec'));
+    const specTaskFiles = await findTaskFiles(path.join(ctx.rootDir, "spec"));
     const allTaskFiles = [...new Set([...taskFiles, ...specTaskFiles])];
-    files.push(...allTaskFiles.filter(f => !f.includes('fixtures') && !f.includes('test')));
+    files.push(...allTaskFiles.filter((f) => !f.includes("fixtures") && !f.includes("test")));
     // Spec files from includes
     if (ctx.manifest && ctx.manifestPath) {
         const manifestDir = path.dirname(ctx.manifestPath);
@@ -337,9 +446,9 @@ async function collectFixableFiles(ctx) {
         }
     }
     // Inbox file
-    const inboxPath = path.join(ctx.rootDir, 'spec', 'kynetic.inbox.yaml');
+    const inboxPath = path.join(ctx.rootDir, "spec", "kynetic.inbox.yaml");
     try {
-        await import('node:fs/promises').then(fs => fs.access(inboxPath));
+        await import("node:fs/promises").then((fs) => fs.access(inboxPath));
         files.push(inboxPath);
     }
     catch {
@@ -353,12 +462,12 @@ async function collectFixableFiles(ctx) {
 function formatValidationResult(result, verbose) {
     // Header
     if (result.valid) {
-        console.log(chalk.green.bold('✓ Validation passed'));
+        console.log(chalk.green.bold("✓ Validation passed"));
     }
     else {
-        console.log(chalk.red.bold('✗ Validation failed'));
+        console.log(chalk.red.bold("✗ Validation failed"));
     }
-    console.log(chalk.gray('─'.repeat(40)));
+    console.log(chalk.gray("─".repeat(40)));
     console.log(`Files checked: ${result.stats.filesChecked}`);
     console.log(`Items checked: ${result.stats.itemsChecked}`);
     console.log(`Tasks checked: ${result.stats.tasksChecked}`);
@@ -379,7 +488,7 @@ function formatValidationResult(result, verbose) {
         }
     }
     else {
-        console.log(chalk.green('\nSchema: OK'));
+        console.log(chalk.green("\nSchema: OK"));
     }
     // Reference errors
     if (result.refErrors.length > 0) {
@@ -394,7 +503,7 @@ function formatValidationResult(result, verbose) {
         }
     }
     else {
-        console.log(chalk.green('References: OK'));
+        console.log(chalk.green("References: OK"));
     }
     // Reference warnings (deprecated targets)
     if (result.refWarnings.length > 0) {
@@ -446,18 +555,20 @@ function formatValidationResult(result, verbose) {
  */
 export function registerValidateCommand(program) {
     program
-        .command('validate')
-        .description('Validate spec files')
-        .option('--schema', 'Check schema conformance only')
-        .option('--refs', 'Check reference resolution only')
-        .option('--orphans', 'Find orphaned items only')
-        .option('--alignment', 'Check spec-task alignment')
-        .option('--completeness', 'Check spec completeness (missing AC, descriptions, status inconsistencies)')
-        .option('--conventions', 'Validate conventions')
-        .option('--staleness', 'Check for stale status mismatches between specs and tasks')
-        .option('--fix', 'Auto-fix issues where possible (invalid ULIDs, missing timestamps)')
-        .option('-v, --verbose', 'Show detailed output')
-        .option('--strict', 'Treat orphans and staleness warnings as errors')
+        .command("validate")
+        .description("Validate spec files")
+        .option("--schema", "Check schema conformance only")
+        .option("--refs", "Check reference resolution only")
+        .option("--orphans", "Find orphaned items only")
+        .option("--alignment", "Check spec-task alignment")
+        .option("--completeness", "Check spec completeness (missing AC, descriptions, status inconsistencies)")
+        .option("--conventions", "Validate conventions")
+        .option("--staleness", "Check for stale status mismatches between specs and tasks")
+        .option("--skills", "Validate skill files (.claude/skills/*/SKILL.md)")
+        .option("--drift", "Check AC field references against actual schema (catches spec prose drift)")
+        .option("--fix", "Auto-fix issues where possible (invalid ULIDs, missing timestamps)")
+        .option("-v, --verbose", "Show detailed output")
+        .option("--strict", "Treat orphans and staleness warnings as errors")
         .action(async (options) => {
         try {
             const ctx = await initContext();
@@ -466,13 +577,29 @@ export function registerValidateCommand(program) {
                 console.log(validationStrings.initHint);
                 process.exit(EXIT_CODES.ERROR);
             }
+            // Track warnings from all sources for exit code determination
+            let additionalWarningCount = 0;
             // Determine which checks to run
-            const runAll = !options.schema && !options.refs && !options.orphans && !options.alignment && !options.completeness && !options.conventions;
+            const runAll = !options.schema &&
+                !options.refs &&
+                !options.orphans &&
+                !options.alignment &&
+                !options.completeness &&
+                !options.conventions &&
+                !options.skills;
+            // AC: @config-validation ac-4 — CLI --strict overrides config strict_refs
+            // If --strict is passed, use strict behavior regardless of config
+            // Otherwise, use config value (which defaults to false)
+            const strictRefs = options.strict ? true : ctx.config.validation.strict_refs;
+            const requireAcceptance = ctx.config.validation.require_acceptance;
             const validateOptions = {
                 schema: runAll || options.schema,
                 refs: runAll || options.refs,
                 orphans: runAll || options.orphans,
                 completeness: runAll || options.completeness,
+                // AC: @config-validation ac-2 ac-3 ac-4 — wire config into validation
+                strictRefs,
+                requireAcceptance,
             };
             const result = await validate(ctx, validateOptions);
             // In strict mode, orphans are errors
@@ -510,6 +637,7 @@ export function registerValidateCommand(program) {
                 alignmentIndex.buildLinks(refIndex);
                 const alignmentWarnings = alignmentIndex.findAlignmentWarnings();
                 formatAlignmentWarnings(alignmentWarnings, options.verbose);
+                additionalWarningCount += alignmentWarnings.length;
                 // Show alignment stats
                 const stats = alignmentIndex.getStats();
                 console.log(validationStrings.alignmentStats(stats.specsWithTasks, stats.totalSpecs, stats.alignedSpecs));
@@ -535,30 +663,66 @@ export function registerValidateCommand(program) {
                         }
                     }
                     else {
-                        console.log(chalk.gray('No conventions defined in meta manifest'));
+                        console.log(chalk.gray("No conventions defined in meta manifest"));
                     }
                 }
-                catch (err) {
-                    console.log(chalk.yellow('Warning: Could not load meta manifest for convention validation'));
+                catch (_err) {
+                    console.log(chalk.yellow("Warning: Could not load meta manifest for convention validation"));
                 }
             }
             // Run staleness checks if requested
             // AC: @stale-status-detection ac-4, ac-5
+            let stalenessWarningCount = 0;
             if (options.staleness) {
                 const tasks = await loadAllTasks(ctx);
                 const items = await loadAllItems(ctx);
                 const refIndex = new ReferenceIndex(tasks, items);
                 const stalenessWarnings = checkStaleness(items, tasks, refIndex);
                 formatStalenessWarnings(stalenessWarnings, options.verbose);
+                stalenessWarningCount = stalenessWarnings.length;
                 // AC: @stale-status-detection ac-5 (staleness-exit-code)
                 // With --strict, staleness warnings cause validation failure
                 if (options.strict && stalenessWarnings.length > 0) {
-                    process.exit(EXIT_CODES.VALIDATION_FAILED);
+                    result.valid = false;
                 }
             }
-            if (!result.valid) {
-                process.exit(EXIT_CODES.ERROR);
+            // Run skill file validation if requested or running all checks
+            if (runAll || options.skills) {
+                const skillResult = await validateSkills(ctx.rootDir);
+                formatSkillValidationResult(skillResult, options.verbose);
+                if (!skillResult.valid) {
+                    result.valid = false;
+                }
             }
+            // Run AC schema drift checks if requested
+            let driftWarningCount = 0;
+            if (options.drift) {
+                const items = await loadAllItems(ctx);
+                const driftWarnings = checkACSchemaReferences(items);
+                formatDriftWarnings(driftWarnings, options.verbose);
+                driftWarningCount = driftWarnings.length;
+                // With --strict, drift warnings cause validation failure
+                if (options.strict && driftWarnings.length > 0) {
+                    result.valid = false;
+                }
+            }
+            // Determine exit code based on errors vs warnings
+            // Errors: schema, refs, trait cycles, conventions, skills (result.valid = false)
+            // Warnings: orphans, alignment, completeness, staleness, drift, ref warnings
+            const hasErrors = !result.valid;
+            const hasWarnings = result.orphans.length > 0 ||
+                result.refWarnings.length > 0 ||
+                result.completenessWarnings.length > 0 ||
+                additionalWarningCount > 0 ||
+                stalenessWarningCount > 0 ||
+                driftWarningCount > 0;
+            if (hasErrors) {
+                process.exit(EXIT_CODES.VALIDATION_FAILED);
+            }
+            else if (hasWarnings) {
+                process.exit(EXIT_CODES.VALIDATION_WARNINGS);
+            }
+            // Otherwise exit 0 (success)
         }
         catch (err) {
             error(validationStrings.failed, err);
@@ -567,15 +731,15 @@ export function registerValidateCommand(program) {
     });
     // Alias: kspec lint
     program
-        .command('lint')
-        .description('Alias for validate with style checks')
-        .option('--schema', 'Check schema conformance only')
-        .option('--refs', 'Check reference resolution only')
-        .option('--orphans', 'Find orphaned items only')
-        .option('--completeness', 'Check spec completeness (missing AC, descriptions, status inconsistencies)')
-        .option('--fix', 'Auto-fix issues where possible (invalid ULIDs, missing timestamps)')
-        .option('-v, --verbose', 'Show detailed output')
-        .option('--strict', 'Treat orphans as errors')
+        .command("lint")
+        .description("Alias for validate with style checks")
+        .option("--schema", "Check schema conformance only")
+        .option("--refs", "Check reference resolution only")
+        .option("--orphans", "Find orphaned items only")
+        .option("--completeness", "Check spec completeness (missing AC, descriptions, status inconsistencies)")
+        .option("--fix", "Auto-fix issues where possible (invalid ULIDs, missing timestamps)")
+        .option("-v, --verbose", "Show detailed output")
+        .option("--strict", "Treat orphans as errors")
         .action(async (options) => {
         try {
             const ctx = await initContext();
@@ -583,12 +747,20 @@ export function registerValidateCommand(program) {
                 error(validationStrings.noManifest);
                 process.exit(EXIT_CODES.ERROR);
             }
-            const runAll = !options.schema && !options.refs && !options.orphans && !options.completeness;
+            const runAll = !options.schema &&
+                !options.refs &&
+                !options.orphans &&
+                !options.completeness;
+            // AC: @config-validation ac-4 — CLI --strict overrides config strict_refs
+            const strictRefs = options.strict ? true : ctx.config.validation.strict_refs;
+            const requireAcceptance = ctx.config.validation.require_acceptance;
             const validateOptions = {
                 schema: runAll || options.schema,
                 refs: runAll || options.refs,
                 orphans: runAll || options.orphans,
                 completeness: runAll || options.completeness,
+                strictRefs,
+                requireAcceptance,
             };
             const result = await validate(ctx, validateOptions);
             if (options.strict && result.orphans.length > 0) {
@@ -613,9 +785,18 @@ export function registerValidateCommand(program) {
                     result.valid = revalidateResult.valid;
                 }
             }
-            if (!result.valid) {
-                process.exit(EXIT_CODES.ERROR);
+            // Determine exit code based on errors vs warnings
+            const hasErrors = !result.valid;
+            const hasWarnings = result.orphans.length > 0 ||
+                result.refWarnings.length > 0 ||
+                result.completenessWarnings.length > 0;
+            if (hasErrors) {
+                process.exit(EXIT_CODES.VALIDATION_FAILED);
+            }
+            else if (hasWarnings) {
+                process.exit(EXIT_CODES.VALIDATION_WARNINGS);
             }
+            // Otherwise exit 0 (success)
         }
         catch (err) {
             error(validationStrings.lintFailed, err);