@openlife/cli 1.7.3

package/dist/orchestrator/capability/CapabilityPackParser.js

@@ -0,0 +1,223 @@
+"use strict";
+/**
+ * CapabilityPackParser — load + validate capability pack YAML manifests.
+ *
+ * Story 1.1 — OpenLife v1.3 Agent OS Integration.
+ *
+ * Mirrors WorkflowParser's pattern: never throws on user input, returns
+ * `{ ok, pack?, errors[] }` with stable error codes from CAPABILITY_ERRORS.
+ *
+ * Validation scope (what this parser CAN check):
+ *   - YAML well-formedness
+ *   - Required scalar fields (id, name, description, version, status, objective)
+ *   - Status enum membership (draft|tested|active|deprecated)
+ *   - Asset-ref shape (id+source on each item)
+ *   - Duplicate asset ids within each kind (agents/skills/squads/workflows)
+ *   - Embedded-ref file existence (when given a directory context)
+ *
+ * Validation scope (what this parser CANNOT check — done by the registry layer):
+ *   - Whether `referenced` asset ids resolve in the global agent/skill/squad/workflow registries
+ *   - Whether the pack name conflicts with existing packs
+ *   These higher-level checks live in CapabilityPackState (Story 1.4).
+ */
+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.parseCapabilityPack = parseCapabilityPack;
+exports.parseCapabilityPackFile = parseCapabilityPackFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const CapabilityPackSchema_1 = require("./CapabilityPackSchema");
+/** Parse a YAML string. Never throws. */
+function parseCapabilityPack(yamlContent, opts = {}) {
+    const errors = [];
+    let doc;
+    try {
+        doc = yaml.load(yamlContent);
+    }
+    catch (err) {
+        return {
+            ok: false,
+            errors: [{
+                    code: CapabilityPackSchema_1.CAPABILITY_ERRORS.INVALID_YAML,
+                    message: err instanceof Error ? err.message : 'YAML parse failed',
+                }],
+        };
+    }
+    if (doc === null || typeof doc !== 'object') {
+        return {
+            ok: false,
+            errors: [{
+                    code: CapabilityPackSchema_1.CAPABILITY_ERRORS.MISSING_ROOT,
+                    message: 'document must be a YAML mapping with a `capability:` root key',
+                }],
+        };
+    }
+    const root = doc;
+    if (!root.capability || typeof root.capability !== 'object') {
+        return {
+            ok: false,
+            errors: [{
+                    code: CapabilityPackSchema_1.CAPABILITY_ERRORS.MISSING_ROOT,
+                    message: 'top-level `capability:` key is required',
+                }],
+        };
+    }
+    const cap = root.capability;
+    // Required scalars
+    requireString(cap, 'id', errors);
+    requireString(cap, 'name', errors);
+    requireString(cap, 'description', errors);
+    requireString(cap, 'version', errors);
+    requireString(cap, 'objective', errors);
+    // Status — must be one of the four valid values
+    if (typeof cap.status !== 'string') {
+        errors.push({
+            code: CapabilityPackSchema_1.CAPABILITY_ERRORS.MISSING_REQUIRED_FIELD,
+            message: '`status` is required (draft | tested | active | deprecated)',
+        });
+    }
+    else if (!(0, CapabilityPackSchema_1.isCapabilityStatus)(cap.status)) {
+        errors.push({
+            code: CapabilityPackSchema_1.CAPABILITY_ERRORS.INVALID_STATUS,
+            message: 'status must be one of: draft, tested, active, deprecated',
+            context: { received: cap.status },
+        });
+    }
+    // Asset refs — validate shape + de-duplicate per kind
+    validateAssetRefs(cap.agents, 'agents', errors);
+    validateAssetRefs(cap.skills, 'skills', errors);
+    validateAssetRefs(cap.squads, 'squads', errors);
+    validateAssetRefs(cap.workflows, 'workflows', errors);
+    // Embedded-ref file existence (when packDir is provided)
+    if (opts.packDir) {
+        validateEmbeddedFiles(cap.agents, 'agents', opts.packDir, errors);
+        validateEmbeddedFiles(cap.skills, 'skills', opts.packDir, errors);
+        validateEmbeddedFiles(cap.squads, 'squads', opts.packDir, errors);
+        validateEmbeddedFiles(cap.workflows, 'workflows', opts.packDir, errors);
+    }
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return { ok: true, pack: cap, errors: [] };
+}
+/** Parse a YAML file by path. Convenience wrapper. */
+function parseCapabilityPackFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return {
+            ok: false,
+            errors: [{
+                    code: CapabilityPackSchema_1.CAPABILITY_ERRORS.INVALID_YAML,
+                    message: `capability manifest not found: ${filePath}`,
+                    context: { filePath },
+                }],
+        };
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return parseCapabilityPack(content, { packDir: path.dirname(filePath) });
+}
+// ─── internal helpers ──────────────────────────────────────────────
+function requireString(obj, field, errors) {
+    const v = obj[field];
+    if (typeof v !== 'string' || v.length === 0) {
+        errors.push({
+            code: CapabilityPackSchema_1.CAPABILITY_ERRORS.MISSING_REQUIRED_FIELD,
+            message: `\`${field}\` is required and must be a non-empty string`,
+        });
+    }
+}
+function validateAssetRefs(refs, kind, errors) {
+    if (refs === undefined)
+        return;
+    if (!Array.isArray(refs)) {
+        errors.push({
+            code: CapabilityPackSchema_1.CAPABILITY_ERRORS.INVALID_TYPE,
+            message: `\`${kind}\` must be an array of asset refs`,
+        });
+        return;
+    }
+    const seen = new Set();
+    for (let i = 0; i < refs.length; i++) {
+        const ref = refs[i];
+        if (typeof ref?.id !== 'string' || ref.id.length === 0) {
+            errors.push({
+                code: CapabilityPackSchema_1.CAPABILITY_ERRORS.MISSING_REQUIRED_FIELD,
+                message: `${kind}[${i}].id is required`,
+            });
+            continue;
+        }
+        if (ref.source !== 'embedded' && ref.source !== 'referenced') {
+            errors.push({
+                code: CapabilityPackSchema_1.CAPABILITY_ERRORS.INVALID_TYPE,
+                message: `${kind}[${i}].source must be 'embedded' or 'referenced'`,
+                context: { id: ref.id, received: String(ref.source) },
+            });
+        }
+        if (seen.has(ref.id)) {
+            errors.push({
+                code: CapabilityPackSchema_1.CAPABILITY_ERRORS.DUPLICATE_ASSET_REF,
+                message: `${kind}: duplicate asset id '${ref.id}'`,
+                context: { kind, id: ref.id },
+            });
+        }
+        seen.add(ref.id);
+    }
+}
+function validateEmbeddedFiles(refs, kind, packDir, errors) {
+    if (!Array.isArray(refs))
+        return;
+    for (const ref of refs) {
+        if (ref?.source !== 'embedded' || typeof ref.id !== 'string')
+            continue;
+        // Convention: embedded assets live under <packDir>/<kind>/<id>/ (squads, agents)
+        // or <packDir>/<kind>/<id>.{md,yaml} (skills, workflows). Accept any of:
+        //   <kind>/<id>/             (dir)
+        //   <kind>/<id>.md           (single-file skill)
+        //   <kind>/<id>.yaml         (single-file workflow)
+        const candidates = [
+            path.join(packDir, kind, ref.id),
+            path.join(packDir, kind, `${ref.id}.md`),
+            path.join(packDir, kind, `${ref.id}.yaml`),
+            path.join(packDir, kind, `${ref.id}.yml`),
+        ];
+        if (!candidates.some((p) => fs.existsSync(p))) {
+            errors.push({
+                code: CapabilityPackSchema_1.CAPABILITY_ERRORS.EMBEDDED_REF_MISSING_FILE,
+                message: `${kind} embedded ref '${ref.id}' has no file under ${path.join(kind, ref.id)}`,
+                context: { kind, id: ref.id },
+            });
+        }
+    }
+}

package/dist/orchestrator/capability/CapabilityPackSchema.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * CapabilityPackSchema — TypeScript types for OpenLife Capability Packs.
+ *
+ * A Capability Pack is a bundle that ships together: one or more
+ * workflows, the squads/agents/skills they depend on, plus checklists,
+ * templates, and policies. Packs live under `.catalog/capabilities/<id>/`
+ * and follow the established `.catalog/`-as-runtime-SoT contract.
+ *
+ * Story 1.1 — OpenLife v1.3 Agent OS Integration.
+ *
+ * Why packs instead of just composing the existing registries on the fly?
+ *  - Authoring: CapabilityGenesisEngine produces a coherent draft bundle
+ *    from a brief; callers want a single id to canonize, version, and
+ *    promote — not 4 separate ids to keep in sync.
+ *  - Sharing: a pack is the unit of import/export between projects.
+ *  - Lifecycle: draft → tested → active → deprecated is a pack-level
+ *    state machine (Story 1.4).
+ *
+ * The pack manifest is `capability.yaml`. References inside it
+ * (agents[], skills[], squads[], workflows[]) point at ids resolved by
+ * the existing Agent/Skill/Squad/Workflow registries. References are
+ * validated by CapabilityPackParser (Story 1.1 below) — broken refs
+ * surface as stable error codes.
+ *
+ * NEW IDs are tolerated when the pack is in status `draft` (the genesis
+ * engine creates skills/squads in the same pass that writes the pack
+ * manifest, so a forward-reference is OK). For `active` packs, every
+ * reference MUST resolve.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAPABILITY_ERRORS = void 0;
+exports.isCapabilityStatus = isCapabilityStatus;
+exports.isCapabilityAssetRef = isCapabilityAssetRef;
+// ─────────────────────────────────────────────────────────────
+// Stable error codes — exported so callers + tests assert on strings,
+// not error messages.
+// ─────────────────────────────────────────────────────────────
+exports.CAPABILITY_ERRORS = {
+    INVALID_YAML: 'capability_invalid_yaml',
+    INVALID_SCHEMA: 'capability_invalid_schema',
+    MISSING_ROOT: 'capability_missing_root',
+    MISSING_REQUIRED_FIELD: 'capability_missing_required_field',
+    INVALID_TYPE: 'capability_invalid_type',
+    INVALID_STATUS: 'capability_invalid_status',
+    DUPLICATE_ASSET_REF: 'capability_duplicate_asset_ref',
+    UNKNOWN_ASSET_REF: 'capability_unknown_asset_ref',
+    ID_DIR_MISMATCH: 'capability_id_dir_mismatch',
+    EMBEDDED_REF_MISSING_FILE: 'capability_embedded_ref_missing_file',
+};
+// ─────────────────────────────────────────────────────────────
+// Type guards
+// ─────────────────────────────────────────────────────────────
+function isCapabilityStatus(s) {
+    return s === 'draft' || s === 'tested' || s === 'active' || s === 'deprecated';
+}
+function isCapabilityAssetRef(x) {
+    if (x === null || typeof x !== 'object')
+        return false;
+    const r = x;
+    return typeof r.id === 'string' && (r.source === 'embedded' || r.source === 'referenced');
+}

package/dist/orchestrator/capability/CapabilityPackState.js

@@ -0,0 +1,163 @@
+"use strict";
+/**
+ * CapabilityPackState — lifecycle store for Capability Packs.
+ *
+ * Story 1.4 — OpenLife v1.3 Agent OS Integration.
+ *
+ * Owns the `draft → tested → active → deprecated` state machine and the
+ * append-only audit ledger at `.openlife/capability-lifecycle.jsonl`.
+ *
+ * Promotion rules:
+ *   draft → tested     : requires `validatedBy` (test/checklist name)
+ *   tested → active    : requires explicit `actor` (canonization)
+ *   active → deprecated: anytime
+ *   anyState → deprecated: anytime (for emergency disabling)
+ *
+ * Never auto-promotes — every transition is an explicit call with an actor.
+ *
+ * Uses AtomicWriter for both the per-pack status file and the JSONL ledger,
+ * surviving kill -9 (same contract as MissionCheckpointStore, Story 6.2).
+ */
+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.CapabilityPackStateStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const AtomicWriter_1 = require("../util/AtomicWriter");
+/** Valid transition map. Source → set of allowed destinations. */
+const ALLOWED_TRANSITIONS = {
+    draft: new Set(['tested', 'deprecated']),
+    tested: new Set(['active', 'draft', 'deprecated']),
+    active: new Set(['deprecated']),
+    deprecated: new Set([]),
+};
+class CapabilityPackStateStore {
+    stateDir;
+    ledgerFile;
+    constructor(opts = {}) {
+        this.stateDir = opts.stateDir
+            || process.env.OPENLIFE_STATE_DIR
+            || path.join(process.cwd(), '.openlife');
+        this.ledgerFile = path.join(this.stateDir, 'capability-lifecycle.jsonl');
+    }
+    statusFile(packId) {
+        const safe = packId.replace(/[^a-zA-Z0-9._-]/g, '_');
+        return path.join(this.stateDir, 'capabilities', `${safe}.json`);
+    }
+    read(packId) {
+        const f = this.statusFile(packId);
+        if (!fs.existsSync(f))
+            return null;
+        try {
+            return JSON.parse(fs.readFileSync(f, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Initialize a pack at status `draft`. Idempotent — if a status file
+     * already exists, returns it unchanged.
+     */
+    init(packId, actor) {
+        const existing = this.read(packId);
+        if (existing)
+            return existing;
+        const now = new Date().toISOString();
+        const initial = {
+            packId,
+            status: 'draft',
+            updatedAt: now,
+            updatedBy: actor,
+            history: [],
+        };
+        (0, AtomicWriter_1.writeJsonAtomic)(this.statusFile(packId), initial);
+        (0, AtomicWriter_1.appendJsonlAtomic)(this.ledgerFile, {
+            packId, from: '<none>', to: 'draft', actor, at: now, event: 'init',
+        });
+        return initial;
+    }
+    promote(opts) {
+        const { packId, to, actor, reason, validatedBy } = opts;
+        const current = this.read(packId);
+        if (!current)
+            return { ok: false, error: 'pack_not_initialized' };
+        const from = current.status;
+        if (!ALLOWED_TRANSITIONS[from].has(to)) {
+            return { ok: false, error: `transition_not_allowed:${from}->${to}` };
+        }
+        // Promotion to `tested` requires evidence — refuse silent promotion.
+        if (to === 'tested' && !validatedBy) {
+            return { ok: false, error: 'tested_promotion_requires_validated_by' };
+        }
+        // Promotion to `active` requires an actor distinct from auto-systems.
+        if (to === 'active' && (!actor || actor === 'system' || actor === 'auto')) {
+            return { ok: false, error: 'active_promotion_requires_human_actor' };
+        }
+        const now = new Date().toISOString();
+        const transition = {
+            packId, from, to, actor, reason, validatedBy, at: now,
+        };
+        const next = {
+            packId,
+            status: to,
+            updatedAt: now,
+            updatedBy: actor,
+            history: [...current.history, transition],
+        };
+        (0, AtomicWriter_1.writeJsonAtomic)(this.statusFile(packId), next);
+        (0, AtomicWriter_1.appendJsonlAtomic)(this.ledgerFile, { ...transition, event: 'transition' });
+        return { ok: true, status: next };
+    }
+    /** List all known packs and their current lifecycle status. */
+    list() {
+        const dir = path.join(this.stateDir, 'capabilities');
+        if (!fs.existsSync(dir))
+            return [];
+        const out = [];
+        for (const f of fs.readdirSync(dir)) {
+            if (!f.endsWith('.json'))
+                continue;
+            try {
+                out.push(JSON.parse(fs.readFileSync(path.join(dir, f), 'utf-8')));
+            }
+            catch {
+                // skip corrupted entries
+            }
+        }
+        return out;
+    }
+}
+exports.CapabilityPackStateStore = CapabilityPackStateStore;

package/dist/orchestrator/providers/AgentProvider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/orchestrator/providers/CapabilityProvider.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * CapabilityProvider — interface contract for capability pack loaders.
+ *
+ * Story 1.2 — OpenLife v1.3 Agent OS Integration.
+ *
+ * Mirrors AgentProvider / SkillProvider / SquadProvider pattern. Returns
+ * lightweight `CapabilityPackEntry` records (not the full parsed pack) —
+ * callers that want the full manifest go back through the parser via the
+ * `filePath`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/orchestrator/providers/CloudAgentProvider.js

@@ -0,0 +1,55 @@
+"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.CloudAgentProvider = void 0;
+const fs = __importStar(require("fs"));
+class CloudAgentProvider {
+    cloudFile;
+    constructor(cloudFile = process.env.OPENLIFE_CLOUD_AGENTS_FILE || '') {
+        this.cloudFile = cloudFile;
+    }
+    load() {
+        if (!this.cloudFile || !fs.existsSync(this.cloudFile))
+            return [];
+        try {
+            const raw = JSON.parse(fs.readFileSync(this.cloudFile, 'utf-8'));
+            return Array.isArray(raw) ? raw : [];
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.CloudAgentProvider = CloudAgentProvider;

package/dist/orchestrator/providers/CloudSkillProvider.js

@@ -0,0 +1,55 @@
+"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.CloudSkillProvider = void 0;
+const fs = __importStar(require("fs"));
+class CloudSkillProvider {
+    cloudFile;
+    constructor(cloudFile = process.env.OPENLIFE_CLOUD_SKILLS_FILE || '') {
+        this.cloudFile = cloudFile;
+    }
+    load() {
+        if (!this.cloudFile || !fs.existsSync(this.cloudFile))
+            return [];
+        try {
+            const raw = JSON.parse(fs.readFileSync(this.cloudFile, 'utf-8'));
+            return Array.isArray(raw) ? raw : [];
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.CloudSkillProvider = CloudSkillProvider;

package/dist/orchestrator/providers/CloudSquadProvider.js

@@ -0,0 +1,55 @@
+"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.CloudSquadProvider = void 0;
+const fs = __importStar(require("fs"));
+class CloudSquadProvider {
+    cloudFile;
+    constructor(cloudFile = process.env.OPENLIFE_CLOUD_SQUADS_FILE || '') {
+        this.cloudFile = cloudFile;
+    }
+    load() {
+        if (!this.cloudFile || !fs.existsSync(this.cloudFile))
+            return [];
+        try {
+            const raw = JSON.parse(fs.readFileSync(this.cloudFile, 'utf-8'));
+            return Array.isArray(raw) ? raw : [];
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.CloudSquadProvider = CloudSquadProvider;

package/dist/orchestrator/providers/CompositeAgentProvider.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeAgentProvider = void 0;
+class CompositeAgentProvider {
+    primary;
+    fallback;
+    constructor(primary, fallback) {
+        this.primary = primary;
+        this.fallback = fallback;
+    }
+    load() {
+        const data = this.primary.load();
+        return data.length ? data : this.fallback.load();
+    }
+}
+exports.CompositeAgentProvider = CompositeAgentProvider;

package/dist/orchestrator/providers/CompositeCapabilityProvider.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * CompositeCapabilityProvider — primary/fallback composite for capability packs.
+ *
+ * Story 1.2 — OpenLife v1.3 Agent OS Integration.
+ *
+ * Mirrors CompositeAgentProvider / CompositeSkillProvider / CompositeSquadProvider.
+ * Primary returns its full list if non-empty; otherwise fallback. Used by the
+ * registry layer (Story 1.4) to chain file → cloud sources.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeCapabilityProvider = void 0;
+class CompositeCapabilityProvider {
+    primary;
+    fallback;
+    constructor(primary, fallback) {
+        this.primary = primary;
+        this.fallback = fallback;
+    }
+    list() {
+        const data = this.primary.list();
+        return data.length ? data : this.fallback.list();
+    }
+}
+exports.CompositeCapabilityProvider = CompositeCapabilityProvider;