intentdna 1.6.5 → 1.7.4

package/dist/cli/commands/templates.js

@@ -1,9 +1,11 @@
 /**
- * dna templates deploy — copy local src/templates/*.dna.yaml to global intentdna install
+ * dna templates — template catalog and deployment commands.
  */
 import { readdirSync, copyFileSync, existsSync, readFileSync, mkdirSync } from "node:fs";
 import { resolve, join } from "node:path";
 import { execSync } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { findTemplateCatalogEntry, listTemplateCatalog } from "../../templates/catalog.js";
 /**
  * Resolve the global intentdna templates directory.
  * Strategy: npm root -g + /intentdna/dist/templates
@@ -45,6 +47,53 @@ function verifyProjectRoot(cwd) {
     }
     return cwd;
 }
+export async function runTemplatesList(opts = {}) {
+    const templates = await listTemplateCatalog({ projectDir: opts.projectDir });
+    if (templates.length === 0) {
+        process.stderr.write("No templates found.\n");
+        return 1;
+    }
+    process.stderr.write(`Available templates (${templates.length}):\n`);
+    for (const template of templates) {
+        const ns = template.namespace ? ` ns=${template.namespace}` : "";
+        const version = template.version ? ` v${template.version}` : "";
+        process.stderr.write(`  - ${template.name} [${template.source}]${ns}${version}`);
+        if (template.displayName)
+            process.stderr.write(` — ${template.displayName}`);
+        process.stderr.write("\n");
+    }
+    return 0;
+}
+export async function runTemplatesShow(opts) {
+    if (!opts.name) {
+        process.stderr.write("Usage: dna templates show <name>\n");
+        return 2;
+    }
+    const template = await findTemplateCatalogEntry(opts.name, { projectDir: opts.projectDir });
+    if (!template) {
+        process.stderr.write(`Unknown template: ${opts.name}\n`);
+        return 2;
+    }
+    const content = await readFile(template.path, "utf-8");
+    process.stderr.write(`Template: ${template.name}\n`);
+    process.stderr.write(`Source: ${template.source}\n`);
+    process.stderr.write(`Path: ${template.path}\n`);
+    if (template.displayName)
+        process.stderr.write(`Name: ${template.displayName}\n`);
+    if (template.namespace)
+        process.stderr.write(`Namespace: ${template.namespace}\n`);
+    if (template.version)
+        process.stderr.write(`Version: ${template.version}\n`);
+    process.stderr.write(`Content hash: ${template.contentHash}\n`);
+    if (template.keywords.length > 0) {
+        process.stderr.write(`Match keywords: ${template.keywords.join(", ")}\n`);
+    }
+    process.stderr.write("\n---\n");
+    process.stdout.write(content);
+    if (!content.endsWith("\n"))
+        process.stdout.write("\n");
+    return 0;
+}
 export async function runTemplatesDeploy(opts = {}) {
     try {
         const cwd = process.cwd();

package/dist/cli/commands/validate.js

@@ -3,7 +3,7 @@
  *
  * Validate DNA files for structural correctness.
  */
-import { loadDNA } from "../../compiler/index.js";
+import { formatDiagnostic, loadDNAWithDiagnostics } from "../../compiler/index.js";
 export async function runValidate(opts) {
     if (opts.files.length === 0) {
         process.stderr.write("Error: no files specified\n");
@@ -11,17 +11,23 @@ export async function runValidate(opts) {
     }
     let allValid = true;
     for (const file of opts.files) {
-        try {
-            await loadDNA(file);
+        const result = await loadDNAWithDiagnostics(file);
+        const errors = result.diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+        const warnings = result.diagnostics.filter((diagnostic) => diagnostic.severity === "warning");
+        if (errors.length > 0 || !result.dna) {
+            allValid = false;
+            process.stderr.write(`invalid: ${file}\n`);
             if (!opts.quiet) {
-                process.stderr.write(`valid: ${file}\n`);
+                for (const diagnostic of result.diagnostics) {
+                    process.stderr.write(`${formatDiagnostic(diagnostic)}\n`);
+                }
             }
+            continue;
         }
-        catch (err) {
-            allValid = false;
-            process.stderr.write(`invalid: ${file}\n`);
-            if (!opts.quiet && err instanceof Error) {
-                process.stderr.write(`${err.message}\n`);
+        if (!opts.quiet) {
+            process.stderr.write(`valid: ${file}\n`);
+            for (const warning of warnings) {
+                process.stderr.write(`${formatDiagnostic(warning)}\n`);
             }
         }
     }

package/dist/cli/commands/verify.d.ts

@@ -9,10 +9,13 @@
  *   1 — drift detected (modified or missing files)
  *   2 — usage error (e.g. lock file not found)
  */
+import type { CompiledProvenanceManifest } from "../../schema/types.js";
 export interface VerifyOptions {
     lockFile: string;
     stats?: boolean;
     health?: boolean;
+    strict?: boolean;
+    projectDir?: string;
 }
 export interface LockFileEntry {
     sha256: string;
@@ -21,6 +24,8 @@ export interface LockFile {
     synced_at: string;
     dna_sources: string[];
     outputs: Record<string, LockFileEntry>;
+    compiled_ir_hash?: string;
+    provenance?: CompiledProvenanceManifest;
 }
 export interface VerifyResult {
     file: string;
@@ -28,9 +33,36 @@ export interface VerifyResult {
     expected?: string;
     actual?: string;
 }
+export interface ProvenanceVerifyResult {
+    source_id: string;
+    file: string;
+    status: "match" | "mismatch" | "missing";
+    expected?: string;
+    actual?: string;
+}
+export interface InheritanceGraphVerifyResult {
+    source_id: string;
+    file: string;
+    status: "match" | "mismatch" | "missing" | "extra";
+    expected?: string;
+    actual?: string;
+}
 export declare function sha256(content: string): string;
 export declare function parseLockFile(raw: string): LockFile;
 export declare function verifyLock(lock: LockFile): Promise<VerifyResult[]>;
+export declare function verifyInheritanceGraph(lock: LockFile): Promise<InheritanceGraphVerifyResult[]>;
+export declare function verifyProvenance(provenance?: CompiledProvenanceManifest): Promise<ProvenanceVerifyResult[]>;
+export interface StrictRuntimeEvidenceExpectation {
+    compiledIrHash?: string;
+    policyBundleId?: string;
+    policyBundleVersion?: string;
+}
+export declare function verifyStrictRuntimeEvidence(projectDir: string, expected?: StrictRuntimeEvidenceExpectation): Promise<{
+    ok: boolean;
+    total: number;
+    enterprise: number;
+    errors: string[];
+}>;
 export declare function runVerify(opts: VerifyOptions): Promise<number>;
 export interface HealthCheckResult {
     name: string;

package/dist/cli/commands/verify.js

@@ -11,7 +11,11 @@
  */
 import { readFile } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { readTraces } from "../../hooks/state.js";
+import { dirname, resolve } from "node:path";
+import { readRuntimeDecisionEvents, readTraces } from "../../hooks/state.js";
+import { expandDNAInputs, formatDiagnostics } from "../../compiler/index.js";
+import { DNADiagnosticsError } from "../../compiler/diagnostics.js";
+import { validateRuntimeDecisionEvent } from "../../governance/index.js";
 // ── Helpers ────────────────────────────────────────────────
 export function sha256(content) {
     return createHash("sha256").update(content, "utf-8").digest("hex");
@@ -52,6 +56,108 @@ export async function verifyLock(lock) {
     }
     return results;
 }
+function enterpriseDirsFromLock(lock) {
+    const dirs = new Set();
+    for (const source of lock.provenance?.sources ?? []) {
+        if (source.source_ref.startsWith("enterprise:"))
+            dirs.add(dirname(source.resolved_path));
+    }
+    return [...dirs];
+}
+function sourceGraphKey(source) {
+    return JSON.stringify([source.source_id, source.source_ref, source.inherited_by ?? ""]);
+}
+function comparableSource(source) {
+    return JSON.stringify({
+        source_ref: source.source_ref,
+        resolved_path: source.resolved_path,
+        fingerprint: source.fingerprint,
+        inherited_by: source.inherited_by,
+    });
+}
+export async function verifyInheritanceGraph(lock) {
+    if (!lock.provenance)
+        return [];
+    const expanded = await expandDNAInputs(lock.dna_sources, { enterprisePolicyDirs: enterpriseDirsFromLock(lock) });
+    const current = new Map(expanded.provenance.map((source) => [sourceGraphKey(source), source]));
+    const locked = new Map(lock.provenance.sources.map((source) => [sourceGraphKey(source), source]));
+    const results = [];
+    for (const [key, expected] of locked) {
+        const actual = current.get(key);
+        if (!actual) {
+            results.push({ source_id: expected.source_id, file: expected.resolved_path, status: "missing", expected: comparableSource(expected) });
+            continue;
+        }
+        const expectedComparable = comparableSource(expected);
+        const actualComparable = comparableSource(actual);
+        results.push({
+            source_id: expected.source_id,
+            file: expected.resolved_path,
+            status: expectedComparable === actualComparable ? "match" : "mismatch",
+            expected: expectedComparable,
+            actual: actualComparable,
+        });
+    }
+    for (const [key, actual] of current) {
+        if (!locked.has(key)) {
+            results.push({ source_id: actual.source_id, file: actual.resolved_path, status: "extra", actual: comparableSource(actual) });
+        }
+    }
+    return results;
+}
+export async function verifyProvenance(provenance) {
+    if (!provenance)
+        return [];
+    const results = [];
+    for (const source of provenance.sources) {
+        try {
+            const content = await readFile(source.resolved_path, "utf-8");
+            const actual = `sha256:${sha256(content)}`;
+            results.push({
+                source_id: source.source_id,
+                file: source.resolved_path,
+                status: actual === source.fingerprint ? "match" : "mismatch",
+                expected: source.fingerprint,
+                actual,
+            });
+        }
+        catch {
+            results.push({
+                source_id: source.source_id,
+                file: source.resolved_path,
+                status: "missing",
+                expected: source.fingerprint,
+            });
+        }
+    }
+    return results;
+}
+export async function verifyStrictRuntimeEvidence(projectDir, expected = {}) {
+    const events = await readRuntimeDecisionEvents(projectDir, 7);
+    const errors = [];
+    let enterprise = 0;
+    for (const event of events) {
+        const result = validateRuntimeDecisionEvent(event);
+        if (!result.valid)
+            errors.push(...result.errors.map((error) => `${event.event_id ?? "unknown"}: ${error}`));
+        if (expected.compiledIrHash && event.compiled_ir_hash !== expected.compiledIrHash) {
+            errors.push(`${event.event_id ?? "unknown"}: compiled_ir_hash does not match current lock`);
+        }
+        if (expected.policyBundleId && event.policy_bundle_id !== expected.policyBundleId) {
+            errors.push(`${event.event_id ?? "unknown"}: policy_bundle_id does not match current lock`);
+        }
+        if (expected.policyBundleVersion && event.policy_bundle_version !== expected.policyBundleVersion) {
+            errors.push(`${event.event_id ?? "unknown"}: policy_bundle_version does not match current lock`);
+        }
+        if (result.classification === "enterprise_evidence")
+            enterprise++;
+        else
+            errors.push(`${event.event_id ?? "unknown"}: RuntimeDecisionEvent is diagnostic-only, not enterprise evidence`);
+    }
+    if (events.length === 0)
+        errors.push("no RuntimeDecisionEvent evidence found");
+    return { ok: errors.length === 0, total: events.length, enterprise, errors };
+}
 // ── CLI entry ──────────────────────────────────────────────
 export async function runVerify(opts) {
     // Handle --health mode
@@ -79,8 +185,24 @@ export async function runVerify(opts) {
         process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}\n`);
         return 2;
     }
+    let inheritanceResults = [];
+    if (lock.provenance) {
+        try {
+            inheritanceResults = await verifyInheritanceGraph(lock);
+        }
+        catch (err) {
+            if (err instanceof DNADiagnosticsError) {
+                process.stderr.write(`Error: DNA inheritance graph is invalid:\n${formatDiagnostics(err.diagnostics)}\n`);
+            }
+            else {
+                process.stderr.write(`Error: DNA inheritance graph is invalid: ${err instanceof Error ? err.message : String(err)}\n`);
+            }
+            return 1;
+        }
+    }
     // Verify
     const results = await verifyLock(lock);
+    const provenanceResults = await verifyProvenance(lock.provenance);
     // Report
     let hasFailure = false;
     for (const r of results) {
@@ -96,17 +218,62 @@ export async function runVerify(opts) {
             hasFailure = true;
         }
     }
-    const total = results.length;
-    const ok = results.filter((r) => r.status === "match").length;
+    for (const r of inheritanceResults) {
+        if (r.status === "match") {
+            process.stderr.write(`  ok  inheritance ${r.source_id}: ${r.file}\n`);
+        }
+        else if (r.status === "mismatch") {
+            process.stderr.write(`  MISMATCH  inheritance ${r.source_id}: ${r.file}\n`);
+            hasFailure = true;
+        }
+        else if (r.status === "missing") {
+            process.stderr.write(`  MISSING   inheritance ${r.source_id}: ${r.file}\n`);
+            hasFailure = true;
+        }
+        else {
+            process.stderr.write(`  EXTRA     inheritance ${r.source_id}: ${r.file}\n`);
+            hasFailure = true;
+        }
+    }
+    for (const r of provenanceResults) {
+        if (r.status === "match") {
+            process.stderr.write(`  ok  provenance ${r.source_id}: ${r.file}\n`);
+        }
+        else if (r.status === "mismatch") {
+            process.stderr.write(`  MISMATCH  provenance ${r.source_id}: ${r.file}\n`);
+            hasFailure = true;
+        }
+        else {
+            process.stderr.write(`  MISSING   provenance ${r.source_id}: ${r.file}\n`);
+            hasFailure = true;
+        }
+    }
+    if (lock.provenance?.compiled_ir_hash && lock.compiled_ir_hash && lock.provenance.compiled_ir_hash !== lock.compiled_ir_hash) {
+        process.stderr.write("  MISMATCH  compiled_ir_hash differs between lock and provenance\n");
+        hasFailure = true;
+    }
+    const total = results.length + inheritanceResults.length + provenanceResults.length;
+    const ok = results.filter((r) => r.status === "match").length + inheritanceResults.filter((r) => r.status === "match").length + provenanceResults.filter((r) => r.status === "match").length;
     const failed = total - ok;
     if (hasFailure) {
         process.stderr.write(`\nDrift detected: ${failed}/${total} file(s) changed since last sync\n`);
         return 1;
     }
-    else {
-        process.stderr.write(`\nAll ${total} file(s) verified — no drift\n`);
-        return 0;
+    if (opts.strict) {
+        const strictProjectDir = opts.projectDir ?? dirname(dirname(resolve(opts.lockFile)));
+        const strict = await verifyStrictRuntimeEvidence(strictProjectDir, {
+            compiledIrHash: lock.compiled_ir_hash,
+            policyBundleId: lock.provenance?.policy_bundle_id,
+            policyBundleVersion: lock.provenance?.policy_bundle_version,
+        });
+        if (!strict.ok) {
+            process.stderr.write(`\nStrict runtime evidence failed: ${strict.errors.join("; ")}\n`);
+            return 1;
+        }
+        process.stderr.write(`\nStrict runtime evidence: ${strict.enterprise}/${strict.total} enterprise event(s) valid\n`);
     }
+    process.stderr.write(`\nAll ${total} file(s) verified — no drift\n`);
+    return 0;
 }
 // ── Stats Mode ────────────────────────────────────────────
 async function runStats() {
@@ -218,6 +385,18 @@ function truncate(s, max) {
         return s;
     return s.slice(0, max - 3) + "...";
 }
+async function checkTemplateVersionsQuiet(configs) {
+    const stderr = process.stderr;
+    const originalWrite = stderr.write;
+    stderr.write = (() => true);
+    try {
+        const { checkTemplateVersions } = await import("./sync.js");
+        return await checkTemplateVersions(configs);
+    }
+    finally {
+        stderr.write = originalWrite;
+    }
+}
 /**
  * U3: Comprehensive health report for DNA installation.
  * Checks IR, configs, templates, hooks, and trace system.
@@ -225,7 +404,7 @@ function truncate(s, max) {
 export async function runHealth() {
     const cwd = process.cwd();
     const checks = [];
-    const { resolve } = await import("node:path");
+    const { resolve, basename } = await import("node:path");
     const { stat, readFile: rf, readdir } = await import("node:fs/promises");
     // 1. Check compiled IR
     const irPath = resolve(cwd, ".dna", "compiled", "ir.json");
@@ -245,15 +424,15 @@ export async function runHealth() {
             checks.push({ name: "Compiled IR", status: "warn", detail: "Legacy format — run `dna sync` to upgrade" });
         }
         else {
-            checks.push({ name: "Compiled IR", status: "fail", detail: "Unrecognized format" });
+            checks.push({ name: "Compiled IR", status: "fail", detail: "Unrecognized format — run `dna sync` to regenerate" });
         }
     }
     catch {
         checks.push({ name: "Compiled IR", status: "fail", detail: "Not found — run `dna sync`" });
     }
     // 2. Check DNA config files
-    const { autoDetectConfigs } = await import("./sync.js");
-    const configs = await autoDetectConfigs();
+    const { detectDNAConfigs } = await import("../../compiler/index.js");
+    const configs = await detectDNAConfigs(cwd);
     if (configs.length > 0) {
         checks.push({ name: "DNA configs", status: "pass", detail: `${configs.length} config(s) found` });
     }
@@ -262,51 +441,72 @@ export async function runHealth() {
     }
     // 3. Check config validity
     if (configs.length > 0) {
-        const { loadDNA } = await import("../../compiler/index.js");
+        const { loadDNAWithDiagnostics, formatDiagnostic } = await import("../../compiler/index.js");
         let valid = 0;
         let invalid = 0;
+        let warningCount = 0;
         const errors = [];
         for (const configPath of configs) {
-            try {
-                await loadDNA(configPath);
+            const result = await loadDNAWithDiagnostics(configPath);
+            const errorDiagnostics = result.diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+            const warningDiagnostics = result.diagnostics.filter((diagnostic) => diagnostic.severity === "warning");
+            warningCount += warningDiagnostics.length;
+            if (errorDiagnostics.length === 0 && result.dna) {
                 valid++;
             }
-            catch (err) {
+            else {
                 invalid++;
-                const { basename } = await import("node:path");
-                errors.push(`${basename(configPath)}: ${err instanceof Error ? err.message : String(err)}`);
+                errors.push(`${basename(configPath)}: ${errorDiagnostics.map(formatDiagnostic).join(", ")}`);
             }
         }
         if (invalid === 0) {
-            checks.push({ name: "Config validity", status: "pass", detail: `${valid} config(s) valid` });
+            const detail = warningCount > 0 ? `${valid} config(s) valid, ${warningCount} warning(s)` : `${valid} config(s) valid`;
+            checks.push({ name: "Config validity", status: warningCount > 0 ? "warn" : "pass", detail });
         }
         else {
-            checks.push({ name: "Config validity", status: "fail", detail: errors.join("; ") });
+            checks.push({ name: "Config validity", status: "fail", detail: `${errors.join("; ")} — fix listed config errors, then run \`dna validate\`` });
         }
     }
     // 4. Check template versions
     if (configs.length > 0) {
-        const { checkTemplateVersions: checkVersions } = await import("./sync.js");
-        // Suppress stderr output from checkTemplateVersions — we'll report ourselves
-        const origWrite = process.stderr.write;
-        process.stderr.write = (() => true);
         try {
-            const upgrades = await checkVersions(configs);
+            const upgrades = await checkTemplateVersionsQuiet(configs);
             if (upgrades.length === 0) {
                 checks.push({ name: "Template versions", status: "pass", detail: "All up to date" });
             }
             else {
-                const names = upgrades.map(u => `${u.templateName} (${u.currentVersion} → ${u.availableVersion})`);
-                checks.push({ name: "Template versions", status: "warn", detail: `Upgrade available: ${names.join(", ")}` });
+                const versionUpdates = upgrades.filter(u => u.reason === "version-update");
+                const missingHash = upgrades.filter(u => u.reason === "missing-hash");
+                const contentDrift = upgrades.filter(u => u.reason === "content-drift");
+                const parts = [];
+                if (versionUpdates.length > 0) {
+                    const names = versionUpdates.map(u => `${u.templateName} (${u.currentVersion} → ${u.availableVersion})`);
+                    parts.push(`Upgrade available: ${names.join(", ")}`);
+                }
+                if (missingHash.length > 0) {
+                    const names = missingHash.map(u => `${u.templateName} (${u.currentVersion})`);
+                    parts.push(`Template metadata incomplete: ${names.join(", ")} — run dna init --upgrade <template>`);
+                }
+                if (contentDrift.length > 0) {
+                    const names = contentDrift.map(u => `${u.templateName} (${u.currentVersion})`);
+                    parts.push(`Template content drift: ${names.join(", ")} — run dna init --upgrade <template>`);
+                }
+                checks.push({ name: "Template versions", status: "warn", detail: parts.join("; ") });
             }
         }
         catch {
-            checks.push({ name: "Template versions", status: "warn", detail: "Could not check versions" });
-        }
-        finally {
-            process.stderr.write = origWrite;
+            checks.push({ name: "Template versions", status: "warn", detail: "Could not check versions — run `dna templates list` and retry `dna verify --health`" });
         }
     }
+    // 4.5 Check sync mode detection
+    try {
+        const { detectMode } = await import("./sync.js");
+        const mode = await detectMode();
+        checks.push({ name: "Sync mode", status: "pass", detail: `auto resolves to ${mode}` });
+    }
+    catch {
+        checks.push({ name: "Sync mode", status: "warn", detail: "Could not auto-detect plugin/bin mode — use `dna sync --mode bin` if plugin mode is unavailable" });
+    }
     // 5. Check .claude settings or plugin registration
     const settingsPath = resolve(cwd, ".claude", "settings.json");
     try {
@@ -319,7 +519,7 @@ export async function runHealth() {
             checks.push({ name: "Hook registration", status: "pass", detail: `${eventCount} event(s) in settings.json` });
         }
         else {
-            checks.push({ name: "Hook registration", status: "warn", detail: "No hooks in settings.json — using plugin mode?" });
+            checks.push({ name: "Hook registration", status: "warn", detail: "settings.json has no hooks — run `dna sync --mode bin` or use plugin-managed hooks" });
         }
     }
     catch {
@@ -332,13 +532,52 @@ export async function runHealth() {
                 checks.push({ name: "MCP server", status: "pass", detail: "dna-mcp registered in .mcp.json" });
             }
             else {
-                checks.push({ name: "Hook registration", status: "warn", detail: "No hooks or MCP server found" });
+                checks.push({ name: "Hook registration", status: "warn", detail: "No hooks or MCP server found — run `dna sync`" });
             }
         }
         catch {
             checks.push({ name: "Hook registration", status: "warn", detail: "No settings.json or .mcp.json — run `dna setup` or `dna sync`" });
         }
     }
+    // 5.5 Check generated skill map/body references
+    const skillsDir = resolve(cwd, ".claude", "skills");
+    const skillMapPath = resolve(skillsDir, ".intentdna-skill-map.json");
+    try {
+        const raw = await rf(skillMapPath, "utf-8");
+        const map = JSON.parse(raw);
+        const skills = Array.isArray(map.skills) ? map.skills : [];
+        const missingBodies = [];
+        for (const skill of skills) {
+            if (!skill.bodyPath)
+                continue;
+            try {
+                await stat(resolve(skillsDir, skill.bodyPath));
+            }
+            catch {
+                missingBodies.push(`${skill.name ?? "unknown"}: ${skill.bodyPath}`);
+            }
+        }
+        if (missingBodies.length === 0) {
+            checks.push({ name: "Generated skills", status: "pass", detail: `${skills.length} skill map entr${skills.length === 1 ? "y" : "ies"} with valid bodies` });
+        }
+        else {
+            checks.push({ name: "Generated skills", status: "fail", detail: `Missing body files: ${missingBodies.join(", ")} — run \`dna sync --skills .claude/skills\`` });
+        }
+    }
+    catch {
+        try {
+            const entries = await readdir(skillsDir);
+            const hasSkillDirs = entries.some((entry) => entry.startsWith("dna-"));
+            checks.push({
+                name: "Generated skills",
+                status: hasSkillDirs ? "warn" : "pass",
+                detail: hasSkillDirs ? "Skill dirs exist without .intentdna-skill-map.json — run `dna sync`" : "No generated skill dirs found",
+            });
+        }
+        catch {
+            checks.push({ name: "Generated skills", status: "pass", detail: "No skills directory" });
+        }
+    }
     // 6. Check trace system
     const traceDir = resolve(cwd, ".dna", "state", "trace");
     try {