@openlife/cli 1.7.3

package/dist/test_capability_genesis_engine.js

@@ -0,0 +1,225 @@
+"use strict";
+/**
+ * test_capability_genesis_engine.ts — Stories 1.2/1.3/1.4/1.5
+ *
+ * Integration test covering the whole Sprint 1 stack:
+ *   1. CapabilityGenesisEngine.generate() produces a draft pack
+ *   2. The manifest parses cleanly via CapabilityPackParser
+ *   3. FileCapabilityProvider.list() finds the new pack
+ *   4. CapabilityPackStateStore tracks the pack as draft
+ *   5. CompositeCapabilityProvider primary/fallback chain works
+ *   6. CompositeWorkflowProvider primary/fallback chain works
+ *   7. Lifecycle transitions follow the state machine (draft→tested→active)
+ *   8. Invalid transitions are rejected
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const CapabilityGenesisEngine_1 = require("./orchestrator/capability/CapabilityGenesisEngine");
+const CapabilityPackState_1 = require("./orchestrator/capability/CapabilityPackState");
+const CapabilityPackParser_1 = require("./orchestrator/capability/CapabilityPackParser");
+const FileCapabilityProvider_1 = require("./orchestrator/providers/FileCapabilityProvider");
+const CompositeCapabilityProvider_1 = require("./orchestrator/providers/CompositeCapabilityProvider");
+const CompositeWorkflowProvider_1 = require("./orchestrator/providers/CompositeWorkflowProvider");
+function assertTrue(cond, label) {
+    if (!cond)
+        throw new Error(`ASSERT_FAILED[${label}]`);
+}
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'capability-genesis-'));
+const catalogRoot = path.join(tmp, 'catalog', 'capabilities');
+const stateDir = path.join(tmp, '.openlife');
+fs.mkdirSync(stateDir, { recursive: true });
+fs.mkdirSync(path.join(stateDir, 'capabilities'), { recursive: true });
+try {
+    // ── Scenario 1: Genesis generates a quick pack ─────────────────────
+    const stateStore = new CapabilityPackState_1.CapabilityPackStateStore({ stateDir });
+    const engine = new CapabilityGenesisEngine_1.CapabilityGenesisEngine({
+        catalogRoot,
+        stateStore,
+    });
+    const r1 = engine.generate({
+        description: 'research mid-cap medical devices',
+        packId: 'medical-devices-research',
+        mode: 'professional',
+        hints: {
+            skills: ['source-credibility-scoring', 'evidence-synthesis'],
+            squads: ['medical-research-squad'],
+        },
+        actor: 'test-runner',
+    });
+    assertTrue(r1.ok, 'scenario 1: genesis ok');
+    if (!r1.ok)
+        throw new Error('cannot continue');
+    assertTrue(fs.existsSync(r1.manifestPath), 'scenario 1: manifest written');
+    assertTrue(fs.existsSync(path.join(r1.packDir, 'INDEX.md')), 'scenario 1: INDEX.md written');
+    assertTrue(r1.pack.status === 'draft', 'scenario 1: pack status=draft');
+    assertTrue(r1.createdAssets.length === 3, `scenario 1: 3 assets created (got ${r1.createdAssets.length})`);
+    console.log('[1.5] scenario 1 (genesis → draft pack) ✓');
+    // ── Scenario 2: Generated manifest parses cleanly ──────────────────
+    const parsed = (0, CapabilityPackParser_1.parseCapabilityPackFile)(r1.manifestPath);
+    assertTrue(parsed.ok, `scenario 2: manifest parses (errors=${JSON.stringify(parsed.errors)})`);
+    assertTrue(parsed.pack?.id === 'medical-devices-research', 'scenario 2: id round-trip');
+    assertTrue((parsed.pack?.skills?.length || 0) === 2, 'scenario 2: 2 skill refs');
+    assertTrue((parsed.pack?.squads?.length || 0) === 1, 'scenario 2: 1 squad ref');
+    console.log('[1.1+1.5] scenario 2 (parse round-trip) ✓');
+    // ── Scenario 3: FileCapabilityProvider finds it ────────────────────
+    const fileProvider = new FileCapabilityProvider_1.FileCapabilityProvider({
+        cwd: tmp,
+        catalogRoot,
+        templateRoot: path.join(tmp, 'never-exists'),
+    });
+    const list = fileProvider.list();
+    assertTrue(list.length === 1, `scenario 3: 1 pack listed (got ${list.length})`);
+    assertTrue(list[0].id === 'medical-devices-research', 'scenario 3: correct id');
+    assertTrue(list[0].source === 'catalog', 'scenario 3: source=catalog');
+    console.log('[1.2] scenario 3 (FileCapabilityProvider) ✓');
+    // ── Scenario 4: Composite primary/fallback ─────────────────────────
+    const emptyProvider = { list: () => [] };
+    const fallbackProvider = {
+        list: () => [{
+                id: 'from-fallback',
+                name: 'Fallback',
+                description: 'x',
+                version: '1.0.0',
+                status: 'active',
+                filePath: '/fake',
+                packDir: '/fake',
+                source: 'cloud',
+            }],
+    };
+    const composite = new CompositeCapabilityProvider_1.CompositeCapabilityProvider(emptyProvider, fallbackProvider);
+    const fallbackList = composite.list();
+    assertTrue(fallbackList.length === 1, 'scenario 4: fallback engaged when primary empty');
+    assertTrue(fallbackList[0].id === 'from-fallback', 'scenario 4: fallback id');
+    const composite2 = new CompositeCapabilityProvider_1.CompositeCapabilityProvider(fileProvider, fallbackProvider);
+    const primaryList = composite2.list();
+    assertTrue(primaryList.length === 1, 'scenario 4: primary takes precedence');
+    assertTrue(primaryList[0].id === 'medical-devices-research', 'scenario 4: primary id wins');
+    console.log('[1.2] scenario 4 (CompositeCapabilityProvider) ✓');
+    // ── Scenario 5: Lifecycle store tracks pack ────────────────────────
+    const status1 = stateStore.read('medical-devices-research');
+    assertTrue(status1?.status === 'draft', 'scenario 5: lifecycle=draft');
+    assertTrue(status1?.history.length === 0, 'scenario 5: no history yet');
+    console.log('[1.4] scenario 5 (lifecycle init) ✓');
+    // ── Scenario 6: Promote draft → tested with validatedBy ────────────
+    const promote1 = stateStore.promote({
+        packId: 'medical-devices-research',
+        to: 'tested',
+        actor: 'qa',
+        validatedBy: 'manual-checklist',
+    });
+    assertTrue(promote1.ok, `scenario 6: promote to tested ok (error=${promote1.error})`);
+    assertTrue(promote1.status?.status === 'tested', 'scenario 6: status=tested');
+    assertTrue(promote1.status?.history.length === 1, 'scenario 6: 1 transition recorded');
+    console.log('[1.4] scenario 6 (promote draft→tested) ✓');
+    // ── Scenario 7: Refuse silent promotion to tested (no validatedBy) ─
+    // Start a fresh pack to test the refusal
+    const engine2 = new CapabilityGenesisEngine_1.CapabilityGenesisEngine({ catalogRoot, stateStore });
+    const r2 = engine2.generate({
+        description: 'simple test pack',
+        packId: 'simple-test',
+        mode: 'quick',
+        hints: { skills: ['simple-skill'] },
+        actor: 'test',
+    });
+    assertTrue(r2.ok, 'scenario 7: second pack generated');
+    const bad = stateStore.promote({
+        packId: 'simple-test',
+        to: 'tested',
+        actor: 'qa',
+        // intentionally no validatedBy
+    });
+    assertTrue(!bad.ok, 'scenario 7: silent promotion refused');
+    assertTrue(bad.error === 'tested_promotion_requires_validated_by', `scenario 7: expected error code, got ${bad.error}`);
+    console.log('[1.4] scenario 7 (refuse silent tested promotion) ✓');
+    // ── Scenario 8: Refuse auto-system promotion to active ─────────────
+    stateStore.promote({
+        packId: 'simple-test',
+        to: 'tested',
+        actor: 'qa',
+        validatedBy: 'auto-test',
+    });
+    const sysBad = stateStore.promote({
+        packId: 'simple-test',
+        to: 'active',
+        actor: 'system',
+    });
+    assertTrue(!sysBad.ok, 'scenario 8: system actor refused for active');
+    assertTrue(sysBad.error === 'active_promotion_requires_human_actor', `scenario 8: expected error code, got ${sysBad.error}`);
+    console.log('[1.4] scenario 8 (refuse auto active promotion) ✓');
+    // ── Scenario 9: Refuse invalid transition (draft → active) ─────────
+    const engine3 = new CapabilityGenesisEngine_1.CapabilityGenesisEngine({ catalogRoot, stateStore });
+    engine3.generate({
+        description: 'leap pack',
+        packId: 'leap-pack',
+        mode: 'quick',
+        actor: 'test',
+    });
+    const invalidLeap = stateStore.promote({
+        packId: 'leap-pack',
+        to: 'active',
+        actor: 'rafa',
+    });
+    assertTrue(!invalidLeap.ok, 'scenario 9: draft→active rejected');
+    assertTrue(invalidLeap.error?.startsWith('transition_not_allowed'), `scenario 9: expected transition_not_allowed, got ${invalidLeap.error}`);
+    console.log('[1.4] scenario 9 (invalid transition rejected) ✓');
+    // ── Scenario 10: CompositeWorkflowProvider primary/fallback ────────
+    const primaryWfEntry = {
+        id: 'wf-primary',
+        name: 'Primary',
+        type: 'custom',
+        version: '1.0',
+        filePath: '/fake',
+        source: 'catalog',
+    };
+    const fakePrimary = {
+        list: () => [primaryWfEntry],
+        load: (id) => id === 'wf-primary' ? { entry: primaryWfEntry, workflow: {} } : null,
+    };
+    const fakeFallback = {
+        list: () => [{ ...primaryWfEntry, id: 'wf-fallback' }],
+        load: () => null,
+    };
+    const wfComposite = new CompositeWorkflowProvider_1.CompositeWorkflowProvider(fakePrimary, fakeFallback);
+    const wfList = wfComposite.list();
+    assertTrue(wfList.length === 1 && wfList[0].id === 'wf-primary', 'scenario 10: primary workflow wins');
+    console.log('[1.3] scenario 10 (CompositeWorkflowProvider) ✓');
+    console.log('TEST_CAPABILITY_GENESIS_ENGINE_OK');
+}
+finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+}

package/dist/test_capability_pack_schema.js

@@ -0,0 +1,214 @@
+"use strict";
+/**
+ * test_capability_pack_schema.ts — Story 1.1
+ *
+ * Regression test for CapabilityPackSchema + Parser.
+ *
+ * Asserts:
+ *   1. A minimal valid pack parses.
+ *   2. A complete pack with all sections parses and round-trips fields.
+ *   3. Missing required fields surface stable error codes.
+ *   4. Invalid status surfaces INVALID_STATUS.
+ *   5. Bad YAML surfaces INVALID_YAML.
+ *   6. Missing root key surfaces MISSING_ROOT.
+ *   7. Duplicate asset ids inside the same kind surface DUPLICATE_ASSET_REF.
+ *   8. Asset refs with invalid source surface INVALID_TYPE.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const CapabilityPackParser_1 = require("./orchestrator/capability/CapabilityPackParser");
+const CapabilityPackSchema_1 = require("./orchestrator/capability/CapabilityPackSchema");
+function assertTrue(cond, label) {
+    if (!cond)
+        throw new Error(`ASSERT_FAILED[${label}]`);
+}
+function assertErrorCode(errors, code, label) {
+    if (!errors.some((e) => e.code === code)) {
+        throw new Error(`ASSERT_FAILED[${label}]: expected error code ${code}, got ${JSON.stringify(errors.map((e) => e.code))}`);
+    }
+}
+// ─── Scenario 1: minimal valid pack ──────────────────────────────────
+const minimal = `
+capability:
+  id: minimal-pack
+  name: Minimal Pack
+  description: smallest possible pack
+  version: "1.0.0"
+  status: draft
+  objective: prove the parser accepts a minimal manifest
+`;
+const r1 = (0, CapabilityPackParser_1.parseCapabilityPack)(minimal);
+assertTrue(r1.ok, 'scenario 1: minimal pack ok');
+assertTrue(r1.pack?.id === 'minimal-pack', 'scenario 1: id round-trip');
+assertTrue(r1.pack?.status === 'draft', 'scenario 1: status round-trip');
+console.log('[1.1] scenario 1 (minimal) ✓');
+// ─── Scenario 2: complete pack ───────────────────────────────────────
+const complete = `
+capability:
+  id: deep-research
+  name: Deep Research
+  description: thorough research capability
+  version: "1.0.0"
+  status: draft
+  objective: produce verifiable research reports with cited sources
+  success_criteria:
+    - "Every claim has a verifiable citation"
+    - "At least 3 contradicting sources considered"
+  agents:
+    - { id: research-lead, source: embedded, label: "Research Lead" }
+    - { id: writer, source: referenced, version: "1.0.0" }
+  skills:
+    - { id: source-credibility-scoring, source: embedded }
+  squads:
+    - { id: research-squad, source: embedded }
+  workflows:
+    - { id: deep-research-flow, source: embedded }
+  checklists:
+    - { id: quality-gate, path: checklists/quality-gate.md }
+  templates:
+    - { id: report, path: templates/report.md }
+  policies:
+    - { id: no-uncited-claims, rationale: "All claims must cite a source" }
+  metadata:
+    author: Genesis Engine
+    tags: [research, analysis]
+`;
+const r2 = (0, CapabilityPackParser_1.parseCapabilityPack)(complete);
+assertTrue(r2.ok, 'scenario 2: complete pack ok');
+assertTrue((r2.pack?.agents?.length || 0) === 2, 'scenario 2: 2 agents');
+assertTrue(r2.pack?.agents?.[0].source === 'embedded', 'scenario 2: first agent embedded');
+assertTrue(r2.pack?.agents?.[1].source === 'referenced', 'scenario 2: second agent referenced');
+assertTrue((r2.pack?.success_criteria?.length || 0) === 2, 'scenario 2: 2 success criteria');
+assertTrue(r2.pack?.policies?.[0].id === 'no-uncited-claims', 'scenario 2: policy round-trip');
+console.log('[1.1] scenario 2 (complete) ✓');
+// ─── Scenario 3: missing required fields ────────────────────────────
+const missingFields = `
+capability:
+  name: No ID
+`;
+const r3 = (0, CapabilityPackParser_1.parseCapabilityPack)(missingFields);
+assertTrue(!r3.ok, 'scenario 3: missing fields fails');
+assertErrorCode(r3.errors, CapabilityPackSchema_1.CAPABILITY_ERRORS.MISSING_REQUIRED_FIELD, 'scenario 3: error code');
+console.log('[1.1] scenario 3 (missing fields) ✓');
+// ─── Scenario 4: invalid status ─────────────────────────────────────
+const invalidStatus = `
+capability:
+  id: bad-status
+  name: Bad Status
+  description: x
+  version: "1.0.0"
+  status: unstable
+  objective: x
+`;
+const r4 = (0, CapabilityPackParser_1.parseCapabilityPack)(invalidStatus);
+assertTrue(!r4.ok, 'scenario 4: invalid status fails');
+assertErrorCode(r4.errors, CapabilityPackSchema_1.CAPABILITY_ERRORS.INVALID_STATUS, 'scenario 4: error code');
+console.log('[1.1] scenario 4 (invalid status) ✓');
+// ─── Scenario 5: bad YAML ────────────────────────────────────────────
+const r5 = (0, CapabilityPackParser_1.parseCapabilityPack)(':\n  bad: [unclosed');
+assertTrue(!r5.ok, 'scenario 5: bad yaml fails');
+assertErrorCode(r5.errors, CapabilityPackSchema_1.CAPABILITY_ERRORS.INVALID_YAML, 'scenario 5: error code');
+console.log('[1.1] scenario 5 (bad yaml) ✓');
+// ─── Scenario 6: missing root key ────────────────────────────────────
+const r6 = (0, CapabilityPackParser_1.parseCapabilityPack)('not_capability:\n  id: x');
+assertTrue(!r6.ok, 'scenario 6: missing root fails');
+assertErrorCode(r6.errors, CapabilityPackSchema_1.CAPABILITY_ERRORS.MISSING_ROOT, 'scenario 6: error code');
+console.log('[1.1] scenario 6 (missing root) ✓');
+// ─── Scenario 7: duplicate asset ids ─────────────────────────────────
+const dupes = `
+capability:
+  id: dup-pack
+  name: Dup
+  description: x
+  version: "1.0.0"
+  status: draft
+  objective: x
+  skills:
+    - { id: same-skill, source: embedded }
+    - { id: same-skill, source: referenced }
+`;
+const r7 = (0, CapabilityPackParser_1.parseCapabilityPack)(dupes);
+assertTrue(!r7.ok, 'scenario 7: duplicate refs fail');
+assertErrorCode(r7.errors, CapabilityPackSchema_1.CAPABILITY_ERRORS.DUPLICATE_ASSET_REF, 'scenario 7: error code');
+console.log('[1.1] scenario 7 (duplicate refs) ✓');
+// ─── Scenario 8: invalid asset source ────────────────────────────────
+const badSource = `
+capability:
+  id: bad-source
+  name: Bad Source
+  description: x
+  version: "1.0.0"
+  status: draft
+  objective: x
+  agents:
+    - { id: a1, source: cloud }
+`;
+const r8 = (0, CapabilityPackParser_1.parseCapabilityPack)(badSource);
+assertTrue(!r8.ok, 'scenario 8: bad source fails');
+assertErrorCode(r8.errors, CapabilityPackSchema_1.CAPABILITY_ERRORS.INVALID_TYPE, 'scenario 8: error code');
+console.log('[1.1] scenario 8 (invalid source) ✓');
+// ─── Scenario 9: file-mode parse + embedded ref file check ───────────
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'capability-test-'));
+try {
+    const packDir = path.join(tmp, 'demo-pack');
+    fs.mkdirSync(packDir, { recursive: true });
+    fs.mkdirSync(path.join(packDir, 'skills'), { recursive: true });
+    fs.writeFileSync(path.join(packDir, 'skills', 'real-skill.md'), '# Real Skill\n');
+    const yamlPath = path.join(packDir, 'capability.yaml');
+    fs.writeFileSync(yamlPath, `
+capability:
+  id: demo-pack
+  name: Demo
+  description: file-mode test
+  version: "1.0.0"
+  status: draft
+  objective: prove file-mode parsing finds embedded files
+  skills:
+    - { id: real-skill, source: embedded }
+    - { id: ghost-skill, source: embedded }
+`);
+    const r9 = (0, CapabilityPackParser_1.parseCapabilityPackFile)(yamlPath);
+    // ghost-skill has no file → should error; real-skill is fine
+    assertTrue(!r9.ok, 'scenario 9: ghost-skill missing file fails');
+    assertErrorCode(r9.errors, CapabilityPackSchema_1.CAPABILITY_ERRORS.EMBEDDED_REF_MISSING_FILE, 'scenario 9: error code');
+    console.log('[1.1] scenario 9 (file-mode + embedded check) ✓');
+}
+finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+}
+console.log('TEST_CAPABILITY_PACK_SCHEMA_OK');

package/dist/test_catalog_quality.js

@@ -0,0 +1,150 @@
+"use strict";
+/**
+ * test_catalog_quality.ts — Story 5.6
+ *
+ * Regression gate against bad squad/skill check-ins.
+ *
+ * Scans `.catalog/squads/` and `.catalog/skills/` (excluding `test-*`) and asserts:
+ *  - Every entry has the expected primary doc (SQUAD.md or SKILL.md).
+ *  - Frontmatter parses and contains required fields (id, name, status).
+ *  - Frontmatter `id` matches the directory name.
+ *  - No squad is left in status=`draft` with `source: aiobuilder-auto-route` for
+ *    more than CATALOG_DRAFT_TTL_DAYS days (default 7).
+ *
+ * Test-pollution entries (prefix `test-`) are ignored — `clean-test-pollution.js`
+ * sweeps them in `pretest:all`. This test guards permanent check-ins.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const CATALOG_ROOT = path.join(process.cwd(), '.catalog');
+const SQUADS_DIR = path.join(CATALOG_ROOT, 'squads');
+const SKILLS_DIR = path.join(CATALOG_ROOT, 'skills');
+const DRAFT_TTL_DAYS = Number(process.env.OPENLIFE_DRAFT_TTL_DAYS || '7');
+function parseFrontmatter(content) {
+    const m = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!m)
+        return {};
+    const out = {};
+    for (const line of m[1].split('\n')) {
+        const kv = line.match(/^([\w-]+):\s*(.*)$/);
+        if (kv)
+            out[kv[1]] = kv[2].trim();
+    }
+    return out;
+}
+function getDirMtimeMs(dir) {
+    try {
+        return fs.statSync(dir).mtimeMs;
+    }
+    catch {
+        return Date.now();
+    }
+}
+function scan(dir, docName, label) {
+    const issues = [];
+    if (!fs.existsSync(dir))
+        return issues;
+    for (const entry of fs.readdirSync(dir)) {
+        if (entry.startsWith('test-'))
+            continue;
+        if (entry.startsWith('.'))
+            continue;
+        const entryDir = path.join(dir, entry);
+        const stat = fs.statSync(entryDir);
+        if (!stat.isDirectory())
+            continue;
+        const docPath = path.join(entryDir, docName);
+        if (!fs.existsSync(docPath)) {
+            // Imported-reference-only directories are tolerated: they hold raw upstream
+            // material (e.g. fetched HTML, source-of-truth excerpts) and aren't meant
+            // to be loaded as runtime skills. They must declare themselves with
+            // IMPORTED_REFERENCE.md and no primary doc.
+            const importedRef = path.join(entryDir, 'IMPORTED_REFERENCE.md');
+            if (fs.existsSync(importedRef))
+                continue;
+            issues.push({ kind: 'missing_primary_doc', entry, detail: `${label} ${entry}/ has no ${docName}` });
+            continue;
+        }
+        const fm = parseFrontmatter(fs.readFileSync(docPath, 'utf-8'));
+        if (!fm.id)
+            issues.push({ kind: 'missing_id', entry, detail: `${label} ${entry}/${docName} frontmatter missing 'id'` });
+        if (!fm.name)
+            issues.push({ kind: 'missing_name', entry, detail: `${label} ${entry}/${docName} frontmatter missing 'name'` });
+        if (fm.id && fm.id !== entry) {
+            issues.push({ kind: 'id_dir_mismatch', entry, detail: `${label} frontmatter id='${fm.id}' but directory is '${entry}'` });
+        }
+        // Stale draft gate — only enforced for auto-route auto-creations.
+        if (fm.status === 'draft' && /aiobuilder-auto-route/.test(fm.source || '')) {
+            const ageDays = (Date.now() - getDirMtimeMs(entryDir)) / (1000 * 60 * 60 * 24);
+            if (ageDays > DRAFT_TTL_DAYS) {
+                issues.push({
+                    kind: 'stale_auto_route_draft',
+                    entry,
+                    detail: `${label} ${entry}/ is auto-route draft for ${ageDays.toFixed(1)}d (TTL ${DRAFT_TTL_DAYS}d). Promote with \`openlife aiobuilder canonize\` or delete.`,
+                });
+            }
+        }
+    }
+    return issues;
+}
+function main() {
+    const squadIssues = scan(SQUADS_DIR, 'SQUAD.md', 'squad');
+    const skillIssues = scan(SKILLS_DIR, 'SKILL.md', 'skill');
+    const all = [...squadIssues, ...skillIssues];
+    const squadsScanned = fs.existsSync(SQUADS_DIR)
+        ? fs.readdirSync(SQUADS_DIR).filter((e) => !e.startsWith('test-') && !e.startsWith('.')).length
+        : 0;
+    const skillsScanned = fs.existsSync(SKILLS_DIR)
+        ? fs.readdirSync(SKILLS_DIR).filter((e) => !e.startsWith('test-') && !e.startsWith('.')).length
+        : 0;
+    console.log(`[catalog-quality] Scanned ${squadsScanned} squads, ${skillsScanned} skills.`);
+    if (all.length > 0) {
+        console.error(`[catalog-quality] ${all.length} issue(s) found:`);
+        for (const i of all)
+            console.error(`  - [${i.kind}] ${i.detail}`);
+        throw new Error(`CATALOG_QUALITY_FAILED: ${all.length} issue(s) in .catalog/`);
+    }
+    console.log('[catalog-quality] PASS — no broken squad/skill check-ins.');
+    console.log('TEST_CATALOG_QUALITY_OK');
+}
+try {
+    main();
+}
+catch (err) {
+    console.error('[catalog-quality] FAILED:', err instanceof Error ? err.message : err);
+    process.exit(1);
+}