@openlife/cli 1.7.3

package/dist/orchestrator/EnterpriseAgenticCore.js

@@ -0,0 +1,276 @@
+"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 });
+exports.EnterpriseDoctor = exports.LearningLoopStore = exports.MissionEvaluationStore = exports.PilotStore = exports.PluginManifestStore = exports.InstitutionalContextStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const AtomicWriter_1 = require("./util/AtomicWriter");
+const ensureDir = (p) => fs.mkdirSync(p, { recursive: true });
+const stateRoot = (root) => process.env.OPENLIFE_STATE_DIR || path.join(root, '.openlife');
+const now = () => new Date().toISOString();
+const readJson = (p, fallback) => {
+    if (!fs.existsSync(p))
+        return fallback;
+    try {
+        return JSON.parse(fs.readFileSync(p, 'utf-8'));
+    }
+    catch {
+        return fallback;
+    }
+};
+const writeJson = (p, data) => { (0, AtomicWriter_1.writeJsonAtomic)(p, data); };
+const validId = (id) => /^[a-z0-9][a-z0-9._-]{1,80}$/i.test(id);
+const validRisk = (risk) => ['low', 'medium', 'high'].includes(String(risk).toLowerCase());
+const err = (error, detail) => ({ ok: false, error, ...(detail ? { detail } : {}) });
+class InstitutionalContextStore {
+    root;
+    constructor(root = process.cwd()) {
+        this.root = root;
+    }
+    stateDir() { return stateRoot(this.root); }
+    dir() { return path.join(this.stateDir(), 'institutional-context'); }
+    requiredFiles() {
+        return [
+            'brand.md', 'governance.md', 'operating-model.md', 'quality-bar.md',
+            'company-vocabulary.md', 'decision-principles.md', 'approved-patterns.md', 'forbidden-patterns.md'
+        ];
+    }
+    init(name = 'OpenLife Institutional Context') {
+        ensureDir(this.dir());
+        const templates = {
+            'brand.md': `# Brand\n\nName: ${name}\n\nVoice, positioning, visual identity, and examples live here.\n`,
+            'governance.md': '# Governance\n\n- Read-only before write.\n- Human approval for destructive/public actions.\n- Audit every mission.\n',
+            'operating-model.md': '# Operating Model\n\nServices are continuous operational truth; missions/tasks are execution units.\n',
+            'quality-bar.md': '# Quality Bar\n\nOutputs must be actionable, grounded, auditable, and ready for review.\n',
+            'company-vocabulary.md': '# Company Vocabulary\n\nCanonical terms, acronyms, and forbidden wording.\n',
+            'decision-principles.md': '# Decision Principles\n\nPrefer measurable pilots, reversible steps, and explicit tradeoffs.\n',
+            'approved-patterns.md': '# Approved Patterns\n\nReusable patterns that passed review.\n',
+            'forbidden-patterns.md': '# Forbidden Patterns\n\nNo deceptive mocks. No runtime source-of-truth from Obsidian. No destructive action without approval.\n'
+        };
+        const files = this.requiredFiles().map(f => {
+            const p = path.join(this.dir(), f);
+            if (!fs.existsSync(p))
+                (0, AtomicWriter_1.writeStringAtomic)(p, templates[f] || `# ${f}\n`);
+            return p;
+        });
+        writeJson(path.join(this.dir(), 'manifest.json'), { name, version: 1, updatedAt: now(), files: this.requiredFiles() });
+        return { ok: true, type: 'institutional-context.init', stateDir: this.stateDir(), dir: this.dir(), files };
+    }
+    doctor() {
+        const required = this.requiredFiles();
+        const present = required.filter(f => fs.existsSync(path.join(this.dir(), f)));
+        return { ok: present.length === required.length, type: 'institutional-context.doctor', stateDir: this.stateDir(), dir: this.dir(), summary: { requiredPresent: present.length, requiredTotal: required.length, missing: required.filter(f => !present.includes(f)) } };
+    }
+    summary() {
+        const manifest = readJson(path.join(this.dir(), 'manifest.json'), { name: null, version: 0, files: [] });
+        return { ok: true, type: 'institutional-context.summary', stateDir: this.stateDir(), context: { ...manifest, requiredFiles: this.requiredFiles(), doctor: this.doctor().summary } };
+    }
+}
+exports.InstitutionalContextStore = InstitutionalContextStore;
+class PluginManifestStore {
+    root;
+    constructor(root = process.cwd()) {
+        this.root = root;
+    }
+    stateDir() { return stateRoot(this.root); }
+    dir() { return path.join(this.stateDir(), 'plugins'); }
+    pathFor(id) { return path.join(this.dir(), `${id}.json`); }
+    riskTemplate(risk) {
+        const r = (risk || 'low').toLowerCase();
+        if (r === 'high')
+            return { riskLevel: 'high', permissionScope: ['read'], deniedCapabilities: ['delete', 'rename', 'network:write', 'public:write'] };
+        if (r === 'medium')
+            return { riskLevel: 'medium', permissionScope: ['read', 'write', 'network:read'], deniedCapabilities: ['delete', 'network:write', 'public:write'] };
+        return { riskLevel: 'low', permissionScope: ['read', 'write', 'network:read'], deniedCapabilities: ['delete'] };
+    }
+    install(id, capabilities, risk = 'low') {
+        if (!validId(id))
+            return err('invalid_plugin_id', { expected: '^[a-z0-9][a-z0-9._-]{1,80}$' });
+        if (!validRisk(risk))
+            return err('invalid_risk_level', { allowed: ['low', 'medium', 'high'] });
+        ensureDir(this.dir());
+        const existing = readJson(this.pathFor(id), null);
+        const createdAt = existing?.createdAt || now();
+        const plugin = { id, name: id.replace(/[-_]/g, ' '), capabilities: capabilities.length ? Array.from(new Set(capabilities)) : ['general.execution'], governance: this.riskTemplate(risk), source: 'openlife-cli', status: 'installed', version: (existing?.version || 0) + 1, createdAt, updatedAt: now() };
+        writeJson(this.pathFor(id), plugin);
+        return { ok: true, type: 'plugin.install', stateDir: this.stateDir(), plugin };
+    }
+    list() {
+        ensureDir(this.dir());
+        const plugins = fs.readdirSync(this.dir()).filter(f => f.endsWith('.json')).map(f => readJson(path.join(this.dir(), f), null)).filter(Boolean);
+        return { ok: true, type: 'plugin.list', stateDir: this.stateDir(), plugins };
+    }
+    inspect(id) {
+        if (!validId(id))
+            return err('invalid_plugin_id', { id });
+        const plugin = readJson(this.pathFor(id), null);
+        return plugin ? { ok: true, type: 'plugin.inspect', plugin } : err('plugin_not_found', { id });
+    }
+    setStatus(id, status) {
+        if (!validId(id))
+            return err('invalid_plugin_id', { id });
+        const plugin = readJson(this.pathFor(id), null);
+        if (!plugin)
+            return err('plugin_not_found', { id });
+        plugin.status = status;
+        plugin.updatedAt = now();
+        plugin.version += 1;
+        writeJson(this.pathFor(id), plugin);
+        return { ok: true, type: `plugin.${status === 'disabled' ? 'disable' : 'enable'}`, plugin };
+    }
+}
+exports.PluginManifestStore = PluginManifestStore;
+class PilotStore {
+    root;
+    constructor(root = process.cwd()) {
+        this.root = root;
+    }
+    stateDir() { return stateRoot(this.root); }
+    dir() { return path.join(this.stateDir(), 'pilots'); }
+    pathFor(id) { return path.join(this.dir(), `${id}.json`); }
+    create(id, metric, service = 'unassigned') {
+        if (!validId(id))
+            return err('invalid_pilot_id');
+        const existing = readJson(this.pathFor(id), null);
+        const pilot = { id, status: 'active', service, hypothesis: `Pilot ${id} should produce measurable operational value.`, metrics: metric ? [metric] : [], successCriteria: metric ? [metric] : ['define measurable success metric'], workflows: existing?.workflows || [], outcome: existing?.outcome || null, createdAt: existing?.createdAt || now(), updatedAt: now() };
+        writeJson(this.pathFor(id), pilot);
+        return { ok: true, type: 'pilot.create', stateDir: this.stateDir(), pilot };
+    }
+    list() {
+        ensureDir(this.dir());
+        const pilots = fs.readdirSync(this.dir()).filter(f => f.endsWith('.json')).map(f => readJson(path.join(this.dir(), f), null)).filter((p) => !!p);
+        return { ok: true, type: 'pilot.list', stateDir: this.stateDir(), pilots };
+    }
+    report(id) {
+        if (!validId(id))
+            return err('invalid_pilot_id', { id });
+        const pilot = readJson(this.pathFor(id), null);
+        if (!pilot)
+            return err('pilot_not_found', { id });
+        const report = { id, status: pilot.status, service: pilot.service, successCriteria: pilot.successCriteria || pilot.metrics || [], recommendation: pilot.status === 'completed' ? 'promote-learning-or-scale' : 'continue-with-governed-experiment', generatedAt: now() };
+        return { ok: true, type: 'pilot.report', pilot, report };
+    }
+    complete(id, outcome = 'completed') {
+        if (!validId(id))
+            return err('invalid_pilot_id', { id });
+        const pilot = readJson(this.pathFor(id), null);
+        if (!pilot)
+            return err('pilot_not_found', { id });
+        pilot.status = 'completed';
+        pilot.outcome = outcome;
+        pilot.updatedAt = now();
+        writeJson(this.pathFor(id), pilot);
+        return { ok: true, type: 'pilot.complete', pilot };
+    }
+}
+exports.PilotStore = PilotStore;
+class MissionEvaluationStore {
+    root;
+    constructor(root = process.cwd()) {
+        this.root = root;
+    }
+    stateDir() { return stateRoot(this.root); }
+    dir() { return path.join(this.stateDir(), 'evaluations'); }
+    pathFor(mission) { return path.join(this.dir(), `${mission}.json`); }
+    judge(mission, criteriaCsv) {
+        if (!validId(mission))
+            return err('invalid_mission_id');
+        const criteria = criteriaCsv.split(',').map(s => s.trim()).filter(Boolean);
+        const score = Math.max(0, Math.min(100, 70 + Math.min(criteria.length, 5) * 4));
+        const evaluation = { mission, criteria, score, verdict: score >= 75 ? 'ready_for_review' : 'needs_iteration', risks: ['verify evidence before external delivery'], createdAt: now(), path: this.pathFor(mission) };
+        writeJson(this.pathFor(mission), evaluation);
+        return { ok: true, type: 'eval.judge', stateDir: this.stateDir(), evaluation };
+    }
+    report(mission) {
+        if (!validId(mission))
+            return err('invalid_mission_id', { mission });
+        const evaluation = readJson(this.pathFor(mission), null);
+        return evaluation ? { ok: true, type: 'eval.report', evaluation } : err('evaluation_not_found', { mission });
+    }
+    list() {
+        ensureDir(this.dir());
+        return fs.readdirSync(this.dir())
+            .filter(f => f.endsWith('.json'))
+            .map(f => readJson(path.join(this.dir(), f), null))
+            .filter((e) => !!e);
+    }
+}
+exports.MissionEvaluationStore = MissionEvaluationStore;
+class LearningLoopStore {
+    root;
+    constructor(root = process.cwd()) {
+        this.root = root;
+    }
+    stateDir() { return stateRoot(this.root); }
+    dir() { return path.join(this.stateDir(), 'learning'); }
+    pathFor(mission) { return path.join(this.dir(), `${mission}.json`); }
+    fromLastRun(mission, feedback) {
+        if (!validId(mission))
+            return err('invalid_mission_id');
+        const suggestions = [
+            { type: 'skill', action: 'create_or_patch', title: `Reusable workflow from ${mission}`, rationale: feedback || 'Promote repeated operational pattern.' },
+            { type: 'context', action: 'update', title: 'Institutional context update', rationale: 'Capture human correction and decision principles.' },
+            { type: 'evaluation', action: 'add_criteria', title: 'Quality criterion', rationale: 'Convert review into future scoring.' }
+        ];
+        const record = { mission, feedback, suggestions, createdAt: now() };
+        writeJson(this.pathFor(mission), record);
+        return { ok: true, type: 'learn.from-last-run', stateDir: this.stateDir(), recordPath: this.pathFor(mission), suggestions };
+    }
+    list() {
+        ensureDir(this.dir());
+        const records = fs.readdirSync(this.dir())
+            .filter(f => f.endsWith('.json'))
+            .map(f => readJson(path.join(this.dir(), f), null))
+            .filter((r) => !!r);
+        return { ok: true, type: 'learn.list', stateDir: this.stateDir(), records };
+    }
+}
+exports.LearningLoopStore = LearningLoopStore;
+class EnterpriseDoctor {
+    root;
+    constructor(root = process.cwd()) {
+        this.root = root;
+    }
+    run() {
+        const context = new InstitutionalContextStore(this.root).doctor();
+        const plugins = new PluginManifestStore(this.root).list().plugins;
+        const pilots = new PilotStore(this.root).list().pilots;
+        const evals = new MissionEvaluationStore(this.root).list();
+        const learning = new LearningLoopStore(this.root).list().records;
+        const checks = { context, plugins: { ok: true, count: plugins.length }, pilots: { ok: true, count: pilots.length }, evaluations: { ok: true, count: evals.length }, learning: { ok: true, count: learning.length } };
+        return { ok: context.ok && plugins.length >= 0 && pilots.length >= 0, type: 'enterprise.doctor', stateDir: stateRoot(this.root), checks };
+    }
+}
+exports.EnterpriseDoctor = EnterpriseDoctor;

package/dist/orchestrator/ExecutionBoard.js

@@ -0,0 +1,86 @@
+"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 });
+exports.ExecutionBoard = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const AtomicWriter_1 = require("./util/AtomicWriter");
+class ExecutionBoard {
+    filePath;
+    constructor() {
+        this.filePath = path.join(process.cwd(), '.artifacts', 'execution-board.json');
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+    }
+    add(item) {
+        const all = this.getAll();
+        all.push({ ...item, ageHours: 0, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString() });
+        (0, AtomicWriter_1.writeJsonAtomic)(this.filePath, all);
+    }
+    updateStatus(id, status, blockerReason) {
+        const all = this.getAll().map((item) => item.id === id ? {
+            ...item,
+            status,
+            blockerReason: status === 'blocked' ? blockerReason || item.blockerReason : undefined,
+            ageHours: this.computeAgeHours(item.createdAt),
+            updatedAt: new Date().toISOString()
+        } : item);
+        (0, AtomicWriter_1.writeJsonAtomic)(this.filePath, all);
+    }
+    updateDependencies(id, dependencies) {
+        const all = this.getAll().map((item) => item.id === id ? {
+            ...item,
+            dependencies,
+            updatedAt: new Date().toISOString()
+        } : item);
+        (0, AtomicWriter_1.writeJsonAtomic)(this.filePath, all);
+    }
+    getAll() {
+        if (!fs.existsSync(this.filePath))
+            return [];
+        try {
+            return JSON.parse(fs.readFileSync(this.filePath, 'utf-8')).map((item) => ({
+                ...item,
+                ageHours: this.computeAgeHours(item.createdAt)
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    computeAgeHours(createdAt) {
+        return Math.round(((Date.now() - new Date(createdAt).getTime()) / (1000 * 60 * 60)) * 10) / 10;
+    }
+}
+exports.ExecutionBoard = ExecutionBoard;

package/dist/orchestrator/ExecutionIntent.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeExecutionIntent = normalizeExecutionIntent;
+function normalizeExecutionIntent(partial) {
+    return {
+        mode: partial.mode ?? 'task',
+        goal: partial.goal,
+        serviceId: partial.serviceId,
+        riskProfile: partial.riskProfile,
+        budgetPolicy: partial.budgetPolicy,
+        origin: partial.origin ?? 'internal'
+    };
+}

package/dist/orchestrator/ExecutionModePolicy.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionModePolicy = void 0;
+const IntentClassifier_1 = require("./IntentClassifier");
+class ExecutionModePolicy {
+    decide(task, input) {
+        const normalized = input.toLowerCase();
+        if (normalized.includes('elite') || normalized.includes('máxima performance') || normalized.includes('maxima performance')) {
+            return {
+                executionMode: 'elite',
+                swarmMode: 'consensus',
+                maxBranches: 4,
+                rationale: 'Modo elite explicitamente solicitado.'
+            };
+        }
+        if (normalized.includes('performance')) {
+            return {
+                executionMode: 'performance',
+                swarmMode: 'parallel',
+                maxBranches: 3,
+                rationale: 'Modo performance solicitado.'
+            };
+        }
+        if (task.intent === IntentClassifier_1.TaskIntent.RESEARCH_ANALYSIS) {
+            return {
+                executionMode: 'balanced',
+                swarmMode: 'parallel',
+                maxBranches: 3,
+                rationale: 'Research se beneficia de paralelismo leve por padrão.'
+            };
+        }
+        if (task.intent === IntentClassifier_1.TaskIntent.ENGINEERING_BUILD) {
+            return {
+                executionMode: 'balanced',
+                swarmMode: 'light',
+                maxBranches: 2,
+                rationale: 'Build complexo pede review, mas não consensus pesado por padrão.'
+            };
+        }
+        return {
+            executionMode: 'economical',
+            swarmMode: 'none',
+            maxBranches: 1,
+            rationale: 'Tarefa simples segue rota econômica.'
+        };
+    }
+}
+exports.ExecutionModePolicy = ExecutionModePolicy;

package/dist/orchestrator/ExecutionRouter.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionRouter = void 0;
+class ExecutionRouter {
+    route(intent) {
+        return intent.mode === 'service' ? 'service' : 'task';
+    }
+}
+exports.ExecutionRouter = ExecutionRouter;

package/dist/orchestrator/ExecutionState.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExecutionState = createExecutionState;
+function createExecutionState(taskId, goal, userId) {
+    const now = new Date().toISOString();
+    return {
+        taskId,
+        goal,
+        userId,
+        status: 'running',
+        plan: [],
+        successCriteria: [],
+        attempts: [],
+        reviewFindings: [],
+        artifacts: [],
+        governanceEvents: [],
+        createdAt: now,
+        updatedAt: now
+    };
+}

package/dist/orchestrator/ExecutorHealth.js

@@ -0,0 +1,86 @@
+"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 });
+exports.ExecutorHealth = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class ExecutorHealth {
+    healthFile;
+    constructor() {
+        this.healthFile = path.join(process.cwd(), '.artifacts', 'executor-health.json');
+        const dir = path.dirname(this.healthFile);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+    }
+    getAll() {
+        if (!fs.existsSync(this.healthFile))
+            return {};
+        try {
+            return JSON.parse(fs.readFileSync(this.healthFile, 'utf-8'));
+        }
+        catch {
+            return {};
+        }
+    }
+    get(executor) {
+        return this.getAll()[executor] || null;
+    }
+    set(executor, available, reason) {
+        const current = this.getAll();
+        current[executor] = {
+            executor,
+            available,
+            reason,
+            category: this.classify(reason, available),
+            updatedAt: new Date().toISOString()
+        };
+        fs.writeFileSync(this.healthFile, JSON.stringify(current, null, 2), 'utf-8');
+    }
+    classify(reason, available) {
+        if (available)
+            return 'ok';
+        const normalized = (reason || '').toLowerCase();
+        if (normalized.includes('quota') || normalized.includes('429') || normalized.includes('capacity'))
+            return 'quota';
+        if (normalized.includes('command not found') || normalized.includes('not found'))
+            return 'cli_missing';
+        if (normalized.includes('auth') || normalized.includes('login') || normalized.includes('unauthorized'))
+            return 'auth';
+        if (normalized.includes('fallback'))
+            return 'fallback';
+        return 'runtime_error';
+    }
+}
+exports.ExecutorHealth = ExecutorHealth;

package/dist/orchestrator/ExternalCatalogRegistry.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalCatalogRegistry = void 0;
+const ToolsetGuard_1 = require("./toolset/ToolsetGuard");
+class ExternalCatalogRegistry {
+    list() {
+        return [
+            { id: 'skills-sh', type: 'skills', url: 'https://skills.sh/', trust: 'reference', notes: 'Skill discovery reference' },
+            { id: 'clawhub', type: 'skills', url: 'https://clawhub.ai/', trust: 'reference', notes: 'Skill/agent references' },
+            { id: 'mcpmarket', type: 'mcps', url: 'https://mcpmarket.com/', trust: 'reference', notes: 'MCP catalog reference' },
+            { id: 'mcpservers', type: 'mcps', url: 'https://mcpservers.org/', trust: 'reference', notes: 'MCP catalog reference' },
+            { id: 'github', type: 'skills', url: 'https://github.com/', trust: 'import-allowed', notes: 'Allowlisted import host with guard scan' }
+        ];
+    }
+    /**
+     * Initiate an import from an external catalog source.
+     *
+     * Story 5.4 — OpenLife v1.3 Agent OS Integration.
+     *
+     * Hard-gated by trust='import-allowed'. Reference-only sources are
+     * refused. The actual download/scan/install path goes through
+     * SecurityDownloadGuard — this method validates the policy decision
+     * only; the caller wires the actual fetch.
+     *
+     * Returns a structured ImportResult; never throws.
+     */
+    import(sourceId, packId) {
+        if (!sourceId || !packId) {
+            return { ok: false, error: 'invalid_arguments' };
+        }
+        const source = this.list().find((s) => s.id === sourceId);
+        if (!source) {
+            return { ok: false, error: 'source_not_found', sourceId };
+        }
+        if (source.trust !== 'import-allowed') {
+            return {
+                ok: false,
+                error: 'source_is_reference_only',
+                sourceId,
+                trust: source.trust,
+                notes: `Source '${sourceId}' is reference-only. Use the URL manually and bring vetted manifests into .catalog/.`,
+            };
+        }
+        // Policy decision OK. v1.4: if `url` opt provided, run the
+        // download+scan pipeline; else return policy-only OK (caller will
+        // do the fetch).
+        return {
+            ok: true,
+            sourceId,
+            packId,
+            trust: source.trust,
+            notes: 'Policy allows import. Use importAndFetch() for the real download+scan pipeline.',
+        };
+    }
+    /**
+     * Story 9.2 — wires ExternalCatalogRegistry.import policy decision to
+     * SecurityDownloadGuard.downloadAndScan. Single-method "do the right
+     * thing" entry for CLI handlers.
+     *
+     * Returns the same ImportResult shape augmented with downloadedTo
+     * when successful. Never throws.
+     */
+    async importAndFetch(sourceId, packId, url, targetDir) {
+        (0, ToolsetGuard_1.assertToolsetAllowed)('mcp', 'ExternalCatalogRegistry.importAndFetch');
+        const policy = this.import(sourceId, packId);
+        if (!policy.ok)
+            return policy;
+        // Lazy require to avoid circular dependencies.
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { SecurityDownloadGuard } = require('./SecurityDownloadGuard');
+        const guard = new SecurityDownloadGuard();
+        const r = await guard.downloadAndScan(url, targetDir);
+        if (!r.ok) {
+            return { ok: false, sourceId, packId, error: 'download_or_scan_failed', notes: r.errors.join(';') };
+        }
+        return {
+            ...policy,
+            downloadedTo: r.downloadedTo,
+            warnings: r.warnings,
+        };
+    }
+}
+exports.ExternalCatalogRegistry = ExternalCatalogRegistry;