@openlife/cli 1.7.3

package/dist/test_sources_import_ref.js

@@ -0,0 +1,46 @@
+"use strict";
+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 child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+(0, child_process_1.execSync)('node dist/index.js sources import-ref skill sample-from-url https://skills.sh/', { stdio: 'pipe' });
+const p = path.join(process.cwd(), '.catalog', 'skills', 'sample-from-url', 'IMPORTED_REFERENCE.md');
+if (!fs.existsSync(p))
+    throw new Error('imported reference missing');
+const txt = fs.readFileSync(p, 'utf-8');
+if (!txt.includes('source: https://skills.sh/'))
+    throw new Error('missing source stamp');
+console.log('TEST_SOURCES_IMPORT_REF_OK');

package/dist/test_sources_scaffold.js

@@ -0,0 +1,43 @@
+"use strict";
+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 child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+(0, child_process_1.execSync)('node dist/index.js sources scaffold skill test-skill --notes "seed"', { stdio: 'pipe' });
+const p = path.join(process.cwd(), '.catalog', 'skills', 'test-skill', 'REFERENCE.md');
+if (!fs.existsSync(p))
+    throw new Error('scaffold file missing');
+console.log('TEST_SOURCES_SCAFFOLD_OK');

package/dist/test_squad_skill_creator.js

@@ -0,0 +1,305 @@
+"use strict";
+/**
+ * test_squad_skill_creator — Stories 5.1 + 5.2 combined regression.
+ *
+ * SquadCreator scenarios:
+ *   1. create — full directory layout with 3 agents + 2 tasks + 1 checklist
+ *   2. validate — frontmatter & component refs detected
+ *   3. list — returns squads filtered by status
+ *   4. analyze — surfaces orphan agents + missing checklist suggestion
+ *   5. create reject — duplicate id and no agents both fail with stable codes
+ *   6. v1.3 placeholders return clean "not_implemented" envelopes
+ *
+ * SkillCreator scenarios:
+ *   7. create — single SKILL.md generated with all sections
+ *   8. validate + analyze — frontmatter ok, section detection works
+ *
+ * Prints TEST_SQUAD_SKILL_CREATOR_OK on full pass.
+ */
+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 os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const SquadCreator_1 = require("./orchestrator/SquadCreator");
+const SkillCreator_1 = require("./orchestrator/SkillCreator");
+function assert(cond, msg) {
+    if (!cond)
+        throw new Error(`assertion failed: ${msg}`);
+}
+function mkTmp() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'creator-test-'));
+}
+function rmTmp(dir) {
+    try {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+    catch { /* ignore */ }
+}
+const REPO_ROOT = path.resolve(__dirname, '..');
+const SQUAD_TEMPLATE = path.join(REPO_ROOT, 'dist-templates', 'squad-template');
+const SKILL_TEMPLATE = path.join(REPO_ROOT, 'dist-templates', 'skill-template');
+// ─────────────────────────────────────────────────────────────
+// SquadCreator scenarios
+// ─────────────────────────────────────────────────────────────
+function scenarioSquadCreate() {
+    const tmp = mkTmp();
+    try {
+        const sc = new SquadCreator_1.SquadCreator({
+            catalogRoot: path.join(tmp, '.catalog', 'squads'),
+            templateRoot: SQUAD_TEMPLATE,
+        });
+        const proposal = {
+            id: 'test-research-squad',
+            name: 'test-research-squad',
+            description: 'Test squad for research workflows',
+            tags: ['research', 'synthesis'],
+            agents: [
+                { id: 'research-lead', name: 'Research Lead', role: 'Lead coordinator' },
+                { id: 'source-hunter', name: 'Source Hunter', role: 'Source discovery' },
+                { id: 'synthesis-writer', name: 'Synthesis Writer', role: 'Report writing' },
+            ],
+            tasks: [
+                { id: 'discover-sources', ownerAgentId: 'source-hunter', purpose: 'Find primary sources' },
+                { id: 'write-summary', ownerAgentId: 'synthesis-writer', purpose: 'Produce executive summary' },
+            ],
+            checklists: [{
+                    id: 'quality-gate',
+                    purpose: 'Ensure deep-research outputs meet professional bar',
+                    items: ['Has at least 3 primary sources', 'Conclusions cite evidence', 'Contradictions logged'],
+                }],
+        };
+        const result = sc.create(proposal);
+        assert(result.ok === true, `create must succeed, got: ${JSON.stringify(result)}`);
+        if (result.ok) {
+            // SQUAD.md (1) + agents (3) + tasks (2) + checklists (1) = 7
+            assert(result.filesCreated.length === 7, `expected 7 files, got ${result.filesCreated.length}`);
+            assert(fs.existsSync(path.join(result.squadDir, 'SQUAD.md')), 'SQUAD.md must exist');
+            assert(fs.existsSync(path.join(result.squadDir, 'agents', 'research-lead.md')), 'agent file must exist');
+            assert(fs.existsSync(path.join(result.squadDir, 'tasks', 'discover-sources.md')), 'task file must exist');
+            assert(fs.existsSync(path.join(result.squadDir, 'checklists', 'quality-gate.md')), 'checklist file must exist');
+        }
+        console.log('✅ scenario 1: SquadCreator.create — full directory layout');
+    }
+    finally {
+        rmTmp(tmp);
+    }
+}
+function scenarioSquadValidate() {
+    const tmp = mkTmp();
+    try {
+        const sc = new SquadCreator_1.SquadCreator({ catalogRoot: path.join(tmp, '.catalog', 'squads'), templateRoot: SQUAD_TEMPLATE });
+        sc.create({
+            id: 'val-squad',
+            name: 'val-squad',
+            description: 'Validation test',
+            agents: [{ id: 'a-1', name: 'A1', role: 'lead' }],
+        });
+        const ok = sc.validate('val-squad');
+        assert(ok.ok, `validate must pass, errors: ${ok.errors.join(',')}`);
+        assert(ok.errors.length === 0, 'no errors expected');
+        const missing = sc.validate('does-not-exist');
+        assert(!missing.ok, 'validate must fail for missing squad');
+        console.log('✅ scenario 2: SquadCreator.validate');
+    }
+    finally {
+        rmTmp(tmp);
+    }
+}
+function scenarioSquadList() {
+    const tmp = mkTmp();
+    try {
+        const sc = new SquadCreator_1.SquadCreator({ catalogRoot: path.join(tmp, '.catalog', 'squads'), templateRoot: SQUAD_TEMPLATE });
+        sc.create({ id: 'a-sq', name: 'A', description: '', status: 'active', agents: [{ id: 'x', name: 'X', role: 'r' }] });
+        sc.create({ id: 'b-sq', name: 'B', description: '', status: 'draft', agents: [{ id: 'y', name: 'Y', role: 'r' }] });
+        const all = sc.list();
+        assert(all.length === 2, `expected 2 squads, got ${all.length}`);
+        const drafts = sc.list({ status: 'draft' });
+        assert(drafts.length === 1 && drafts[0].id === 'b-sq', `draft filter mismatch: ${JSON.stringify(drafts)}`);
+        console.log('✅ scenario 3: SquadCreator.list (filter by status)');
+    }
+    finally {
+        rmTmp(tmp);
+    }
+}
+function scenarioSquadAnalyze() {
+    const tmp = mkTmp();
+    try {
+        const sc = new SquadCreator_1.SquadCreator({ catalogRoot: path.join(tmp, '.catalog', 'squads'), templateRoot: SQUAD_TEMPLATE });
+        sc.create({
+            id: 'anal-sq',
+            name: 'anal-sq',
+            description: 'Analysis test',
+            agents: [
+                { id: 'used-agent', name: 'U', role: 'r' },
+                { id: 'orphan-agent', name: 'O', role: 'r' },
+            ],
+            tasks: [{ id: 'a-task', ownerAgentId: 'used-agent', purpose: 'x' }],
+        });
+        const a = sc.analyze('anal-sq');
+        assert(a !== null, 'analyze must return result');
+        assert(a.agentCount === 2, `expected 2 agents, got ${a.agentCount}`);
+        assert(a.taskCount === 1, `expected 1 task, got ${a.taskCount}`);
+        assert(a.orphanAgents.includes('orphan-agent'), `expected orphan-agent in orphanAgents, got: ${a.orphanAgents.join(',')}`);
+        assert(a.suggestions.some((s) => /quality gates|checklist/i.test(s)), 'should suggest adding a checklist');
+        console.log('✅ scenario 4: SquadCreator.analyze (orphans + suggestions)');
+    }
+    finally {
+        rmTmp(tmp);
+    }
+}
+function scenarioSquadCreateRejects() {
+    const tmp = mkTmp();
+    try {
+        const sc = new SquadCreator_1.SquadCreator({ catalogRoot: path.join(tmp, '.catalog', 'squads'), templateRoot: SQUAD_TEMPLATE });
+        // First creation succeeds
+        const first = sc.create({ id: 'dup-test', name: 'dup', description: '', agents: [{ id: 'a', name: 'A', role: 'r' }] });
+        assert(first.ok, 'first create must succeed');
+        // Second with same id fails
+        const dup = sc.create({ id: 'dup-test', name: 'dup', description: '', agents: [{ id: 'a', name: 'A', role: 'r' }] });
+        assert(!dup.ok && dup.error === 'squad_already_exists', `expected squad_already_exists, got: ${JSON.stringify(dup)}`);
+        // No agents → no_agents error
+        const noAgents = sc.create({ id: 'no-agents-sq', name: 'X', description: '', agents: [] });
+        assert(!noAgents.ok && noAgents.error === 'no_agents', `expected no_agents, got: ${JSON.stringify(noAgents)}`);
+        console.log('✅ scenario 5: SquadCreator.create rejects (dup id + no agents)');
+    }
+    finally {
+        rmTmp(tmp);
+    }
+}
+function scenarioPlaceholders() {
+    const tmp = mkTmp();
+    try {
+        const sc = new SquadCreator_1.SquadCreator({ catalogRoot: path.join(tmp, '.catalog', 'squads'), templateRoot: SQUAD_TEMPLATE });
+        // v1.3 (Story 3.1): design() now produces a proposal heuristically.
+        const designed = sc.design('research mid-cap medical devices', { mode: 'professional' });
+        assert(designed.ok === true, 'design produces proposal');
+        if (designed.ok) {
+            assert(designed.proposal.agents.length >= 3, 'design includes >=3 agents in professional mode');
+        }
+        // v1.4 (Story 11.1-11.3): migrate/extend/publish are now real;
+        // calling them on a non-existent squad should surface squad_not_found.
+        assert(sc.migrate('demo-x', '1.0', '1.1').error === 'squad_not_found', 'migrate squad_not_found');
+        assert(sc.extend('demo-x', { kind: 'agent', spec: { id: 'a1', name: 'A1', role: 'r' } }).error === 'squad_not_found', 'extend squad_not_found');
+        assert(sc.publish('demo-x').error === 'squad_not_found', 'publish squad_not_found');
+        console.log('✅ scenario 6: design() heuristic + migrate/extend/publish real (Stories 11.1-11.3)');
+    }
+    finally {
+        rmTmp(tmp);
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// SkillCreator scenarios
+// ─────────────────────────────────────────────────────────────
+function scenarioSkillCreate() {
+    const tmp = mkTmp();
+    try {
+        const sk = new SkillCreator_1.SkillCreator({ catalogRoot: path.join(tmp, '.catalog', 'skills'), templateRoot: SKILL_TEMPLATE });
+        const proposal = {
+            id: 'source-credibility',
+            name: 'Source Credibility Scoring',
+            description: 'Score sources by authority, recency, bias, and primary-ness',
+            whenToUse: ['Evaluating an unfamiliar source', 'Resolving contradictions'],
+            procedure: ['Check author', 'Check date', 'Check primary-ness', 'Assign confidence band'],
+            inputs: ['Source URL or doc'],
+            outputs: ['Confidence score 0-1'],
+            validations: ['Score is in [0,1]'],
+            guardrails: ['Never assign 1.0 without a primary source link'],
+        };
+        const r = sk.create(proposal);
+        assert(r.ok === true, `skill create must succeed: ${JSON.stringify(r)}`);
+        if (r.ok) {
+            assert(fs.existsSync(r.filePath), 'SKILL.md must exist');
+            const content = fs.readFileSync(r.filePath, 'utf-8');
+            assert(/## When to use/.test(content), 'rendered content must have When to use section');
+            assert(/## Procedure/.test(content), 'rendered content must have Procedure section');
+            assert(content.includes('Score sources by authority'), 'description must round-trip');
+        }
+        console.log('✅ scenario 7: SkillCreator.create — SKILL.md rendered');
+    }
+    finally {
+        rmTmp(tmp);
+    }
+}
+function scenarioSkillValidateAnalyze() {
+    const tmp = mkTmp();
+    try {
+        const sk = new SkillCreator_1.SkillCreator({ catalogRoot: path.join(tmp, '.catalog', 'skills'), templateRoot: SKILL_TEMPLATE });
+        sk.create({
+            id: 'analyze-test-skill',
+            name: 'Analyze Test',
+            description: 'd',
+            whenToUse: ['always'],
+            procedure: ['step'],
+        });
+        const v = sk.validate('analyze-test-skill');
+        assert(v.ok, `validate must pass: ${v.errors.join(',')}`);
+        const a = sk.analyze('analyze-test-skill');
+        assert(a !== null, 'analyze must return result');
+        assert(a.hasProcedure === true, 'procedure section present');
+        assert(a.hasWhenToUse === true, 'when-to-use section present');
+        // Missing skill
+        assert(sk.analyze('nope') === null, 'analyze returns null for missing skill');
+        const missing = sk.validate('nope');
+        assert(!missing.ok, 'validate fails for missing skill');
+        console.log('✅ scenario 8: SkillCreator.validate + analyze');
+    }
+    finally {
+        rmTmp(tmp);
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// Driver
+// ─────────────────────────────────────────────────────────────
+function main() {
+    console.log('🧪 test_squad_skill_creator — Stories 5.1 + 5.2 regression suite');
+    scenarioSquadCreate();
+    scenarioSquadValidate();
+    scenarioSquadList();
+    scenarioSquadAnalyze();
+    scenarioSquadCreateRejects();
+    scenarioPlaceholders();
+    scenarioSkillCreate();
+    scenarioSkillValidateAnalyze();
+    console.log('');
+    console.log('TEST_SQUAD_SKILL_CREATOR_OK');
+}
+try {
+    main();
+}
+catch (err) {
+    console.error('❌ test_squad_skill_creator FAILED:', err instanceof Error ? err.message : err);
+    process.exit(1);
+}

package/dist/test_squad_skill_design_llm.js

@@ -0,0 +1,176 @@
+"use strict";
+/**
+ * test_squad_skill_design_llm.ts — Stories 8.1 + 8.2
+ *
+ * Asserts that:
+ *   1. Brain.isAnyProviderAvailable() returns false when no env keys.
+ *   2. SquadCreator.designWithBrain() falls back to heuristic when
+ *      Brain reports no provider.
+ *   3. With a mocked Brain that returns valid JSON, designWithBrain()
+ *      returns source='brain'.
+ *   4. With a mocked Brain that throws / returns junk, designWithBrain()
+ *      gracefully falls back to source='heuristic'.
+ *   5. Same four scenarios for SkillCreator.designWithBrain().
+ */
+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 os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const Brain_1 = require("./orchestrator/Brain");
+const SquadCreator_1 = require("./orchestrator/SquadCreator");
+const SkillCreator_1 = require("./orchestrator/SkillCreator");
+function assertTrue(cond, label) {
+    if (!cond)
+        throw new Error(`ASSERT_FAILED[${label}]`);
+}
+async function main() {
+    // ── Scenario 1: real Brain reports no providers when env is clean ──
+    const origKeys = {
+        OPENAI_API_KEY: process.env.OPENAI_API_KEY,
+        ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
+        GEMINI_API_KEY: process.env.GEMINI_API_KEY,
+        OPENROUTER_API_KEY: process.env.OPENROUTER_API_KEY,
+        OLLAMA_URL: process.env.OLLAMA_URL,
+    };
+    delete process.env.OPENAI_API_KEY;
+    delete process.env.ANTHROPIC_API_KEY;
+    delete process.env.GEMINI_API_KEY;
+    delete process.env.OPENROUTER_API_KEY;
+    delete process.env.OLLAMA_URL;
+    const cleanBrain = new Brain_1.Brain();
+    assertTrue(!cleanBrain.isAnyProviderAvailable(), 'Brain reports unavailable with no env');
+    console.log('[8.1] Brain.isAnyProviderAvailable returns false when clean ✓');
+    // ── Scenario 2: SquadCreator.designWithBrain with unavailable Brain → heuristic ──
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'design-llm-'));
+    try {
+        const sc = new SquadCreator_1.SquadCreator({ catalogRoot: path.join(tmp, '.catalog', 'squads') });
+        const noBrain = {
+            isAnyProviderAvailable: () => false,
+            think: async () => { throw new Error('should not be called'); },
+        };
+        const r1 = await sc.designWithBrain(noBrain, 'research mid-cap medical devices', { mode: 'professional' });
+        assertTrue(r1.ok, 'designWithBrain ok when no provider');
+        if (r1.ok) {
+            assertTrue(r1.source === 'heuristic', `source=heuristic (got ${r1.source})`);
+            assertTrue(r1.proposal.agents.length >= 3, 'heuristic professional has >=3 agents');
+        }
+        console.log('[8.1] SquadCreator.designWithBrain unavailable → heuristic ✓');
+        // ── Scenario 3: Mocked Brain returns valid JSON → source=brain ──
+        const validBrain = {
+            isAnyProviderAvailable: () => true,
+            think: async () => `\`\`\`json
+{
+  "agents": [
+    { "id": "research-lead", "role": "lead" },
+    { "id": "research-executor", "role": "executor" },
+    { "id": "research-reviewer", "role": "reviewer" }
+  ],
+  "tasks": [
+    { "id": "research-default", "ownerAgentId": "research-lead", "purpose": "do the research" }
+  ],
+  "checklists": []
+}
+\`\`\``,
+        };
+        const r2 = await sc.designWithBrain(validBrain, 'research medical devices', { mode: 'professional', id: 'mock-brain-squad' });
+        assertTrue(r2.ok, 'designWithBrain ok with valid mocked Brain');
+        if (r2.ok) {
+            assertTrue(r2.source === 'brain', `source=brain (got ${r2.source})`);
+            assertTrue(r2.proposal.agents.length === 3, '3 agents from mocked response');
+            assertTrue(r2.proposal.agents[0].id === 'research-lead', 'first agent id preserved');
+        }
+        console.log('[8.1] SquadCreator.designWithBrain valid JSON → source=brain ✓');
+        // ── Scenario 4: Mocked Brain returns junk → falls back to heuristic ──
+        const junkBrain = {
+            isAnyProviderAvailable: () => true,
+            think: async () => 'definitely not JSON, just prose',
+        };
+        const r3 = await sc.designWithBrain(junkBrain, 'something weird', { mode: 'quick', id: 'junk-test-squad' });
+        assertTrue(r3.ok, 'designWithBrain ok despite junk');
+        if (r3.ok) {
+            assertTrue(r3.source === 'heuristic', `source=heuristic on junk (got ${r3.source})`);
+        }
+        console.log('[8.1] SquadCreator.designWithBrain junk → heuristic fallback ✓');
+        // ── Scenario 5: Mocked Brain throws → falls back ──
+        const throwBrain = {
+            isAnyProviderAvailable: () => true,
+            think: async () => { throw new Error('network'); },
+        };
+        const r4 = await sc.designWithBrain(throwBrain, 'will throw', { mode: 'quick', id: 'throw-test-squad' });
+        assertTrue(r4.ok, 'designWithBrain ok despite throw');
+        if (r4.ok)
+            assertTrue(r4.source === 'heuristic', `source=heuristic on throw (got ${r4.source})`);
+        console.log('[8.1] SquadCreator.designWithBrain throw → heuristic fallback ✓');
+        // ── Scenarios 6–9: same for SkillCreator ──
+        const skc = new SkillCreator_1.SkillCreator({ catalogRoot: path.join(tmp, '.catalog', 'skills') });
+        const r5 = await skc.designWithBrain(noBrain, 'extract images from PDFs', { mode: 'professional' });
+        assertTrue(r5.ok && r5.source === 'heuristic', '[8.2] SkillCreator unavailable → heuristic');
+        console.log('[8.2] SkillCreator.designWithBrain unavailable → heuristic ✓');
+        const validSkillBrain = {
+            isAnyProviderAvailable: () => true,
+            think: async () => `{
+        "description": "extract structured data from PDFs",
+        "whenToUse": ["pdf parsing needed", "structured extraction"],
+        "procedure": ["open pdf", "OCR pages", "parse layout", "emit JSON"],
+        "validation": ["json schema valid"],
+        "guardrails": ["never store raw pdf content"]
+      }`,
+        };
+        const r6 = await skc.designWithBrain(validSkillBrain, 'pdf-extract', { mode: 'professional', id: 'pdf-extract' });
+        assertTrue(r6.ok && r6.source === 'brain', '[8.2] SkillCreator valid → brain');
+        if (r6.ok) {
+            assertTrue(r6.proposal.procedure.length === 4, '4 procedure steps');
+            assertTrue(r6.proposal.guardrails?.[0] === 'never store raw pdf content', 'guardrail preserved');
+        }
+        console.log('[8.2] SkillCreator.designWithBrain valid → source=brain ✓');
+        const r7 = await skc.designWithBrain(junkBrain, 'junk skill', { mode: 'quick', id: 'junk-skill' });
+        assertTrue(r7.ok && r7.source === 'heuristic', '[8.2] SkillCreator junk → heuristic');
+        console.log('[8.2] SkillCreator.designWithBrain junk → heuristic ✓');
+    }
+    finally {
+        fs.rmSync(tmp, { recursive: true, force: true });
+        // restore env
+        for (const [k, v] of Object.entries(origKeys)) {
+            if (v !== undefined)
+                process.env[k] = v;
+        }
+    }
+    console.log('TEST_SQUAD_SKILL_DESIGN_LLM_OK');
+}
+main().catch((err) => {
+    console.error('[design-llm] FAILED:', err instanceof Error ? err.message : err);
+    process.exit(1);
+});