@openlife/cli 1.7.3

package/dist/orchestrator/GovernanceLayer.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GovernanceLayer = void 0;
+const GovernancePolicyStore_1 = require("./GovernancePolicyStore");
+const GovernanceScopeLedger_1 = require("./GovernanceScopeLedger");
+class GovernanceLayer {
+    policyStore;
+    ledger;
+    constructor() {
+        this.policyStore = new GovernancePolicyStore_1.GovernancePolicyStore();
+        this.ledger = new GovernanceScopeLedger_1.GovernanceScopeLedger();
+    }
+    evaluate(goal, project = 'default') {
+        const decision = this.computeDecision(goal, project);
+        // Story 14.2 (v1.5) — append every decision to the tamper-evident
+        // scope ledger. Best-effort; a write failure never affects the
+        // returned decision. Disable via OPENLIFE_GOVERNANCE_LEDGER=off.
+        if (process.env.OPENLIFE_GOVERNANCE_LEDGER !== 'off') {
+            try {
+                this.ledger.append(goal, project, decision);
+            }
+            catch { /* non-fatal */ }
+        }
+        return decision;
+    }
+    computeDecision(goal, project) {
+        const normalized = goal.toLowerCase();
+        const matchedPolicies = [];
+        const blockedCapabilities = [];
+        const policy = this.policyStore.load(project);
+        const destructivePatterns = (policy?.blockedPatterns || ['rm -rf', 'drop table', 'truncate', 'force-push', 'deploy prod', 'production', 'delete', 'remove', 'erase'])
+            .map((value) => new RegExp(value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i'));
+        const injectionPatterns = (policy?.promptInjectionPatterns || ['ignore previous instructions', 'reveal your system prompt', 'bypass guardrails', 'disable safety'])
+            .map((value) => new RegExp(value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i'));
+        const sensitivePatterns = (policy?.sensitivePatterns || ['secret', 'token', 'password', 'api key', 'credential'])
+            .map((value) => new RegExp(value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i'));
+        const destructive = destructivePatterns.some((pattern) => pattern.test(normalized)) || /\b(delete|remove|erase)\b/i.test(normalized);
+        const injection = injectionPatterns.some((pattern) => pattern.test(normalized));
+        const sensitive = sensitivePatterns.some((pattern) => pattern.test(normalized));
+        if (destructive)
+            matchedPolicies.push('destructive-action-guard');
+        if (injection)
+            matchedPolicies.push('prompt-injection-guard');
+        if (sensitive)
+            matchedPolicies.push('sensitive-data-redaction');
+        if (injection) {
+            blockedCapabilities.push('untrusted-instruction-following');
+            return {
+                allowed: false,
+                riskLevel: 'high',
+                rationale: 'Entrada com sinais de prompt injection ou pedido explícito para burlar guardrails.',
+                requiresConsent: false,
+                scope: 'restricted',
+                matchedPolicies,
+                blockedCapabilities,
+                redactionRequired: sensitive,
+                auditSummary: 'Missão bloqueada por policy de prompt injection.'
+            };
+        }
+        if (destructive) {
+            blockedCapabilities.push('destructive-write');
+            return {
+                allowed: false,
+                riskLevel: 'high',
+                rationale: 'Ação destrutiva detectada. O runtime deve exigir consentimento explícito antes de prosseguir.',
+                requiresConsent: policy?.destructiveActionsRequireConsent !== false,
+                scope: 'restricted',
+                matchedPolicies,
+                blockedCapabilities,
+                redactionRequired: sensitive,
+                auditSummary: 'Missão sensível bloqueada até consentimento explícito.'
+            };
+        }
+        // v1.3 (Story 4.2) — four new Hermes-mandated policy categories.
+        // Production deploy
+        const productionDeploy = /\b(deploy|ship|release|push)\b.*\b(prod|production|main|master)\b/i.test(normalized)
+            || /\b(prod|production)\b.*\b(deploy|ship|release)\b/i.test(normalized);
+        if (productionDeploy) {
+            matchedPolicies.push('production-deploy-guard');
+            blockedCapabilities.push('production-deploy');
+            return {
+                allowed: false,
+                riskLevel: 'high',
+                rationale: 'Production deploy detected. Explicit operator consent required.',
+                requiresConsent: true,
+                scope: 'restricted',
+                matchedPolicies,
+                blockedCapabilities,
+                redactionRequired: sensitive,
+                auditSummary: 'Production deploy blocked until explicit consent.',
+            };
+        }
+        // External send (Telegram broadcast, email, public webhook, etc.)
+        const externalSend = /\b(send|post|broadcast|publish|tweet|message|email)\b.*\b(to|external|public|users|customers|telegram|slack|webhook)\b/i.test(normalized)
+            || /\b(announce|broadcast)\b/i.test(normalized);
+        if (externalSend) {
+            matchedPolicies.push('external-send-guard');
+            blockedCapabilities.push('external-send');
+            return {
+                allowed: false,
+                riskLevel: 'high',
+                rationale: 'External communication detected. Requires explicit authorization before sending.',
+                requiresConsent: true,
+                scope: 'restricted',
+                matchedPolicies,
+                blockedCapabilities,
+                redactionRequired: sensitive,
+                auditSummary: 'External send blocked pending authorization.',
+            };
+        }
+        // Fake fallback / mock-success without real work
+        const fakeFallback = /\b(fake|mock|simulate|pretend)\b.*\b(success|complete|done)\b/i.test(normalized)
+            || /\b(skip|bypass)\b.*\b(validation|test|check)\b/i.test(normalized);
+        if (fakeFallback) {
+            matchedPolicies.push('fake-fallback-guard');
+            blockedCapabilities.push('fake-fallback');
+            return {
+                allowed: false,
+                riskLevel: 'high',
+                rationale: 'Request implies fabricating success without doing the work. Refused.',
+                requiresConsent: false,
+                scope: 'restricted',
+                matchedPolicies,
+                blockedCapabilities,
+                redactionRequired: false,
+                auditSummary: 'Fake-fallback intent refused.',
+            };
+        }
+        // Conclusion without validation — claiming a result is final without evidence
+        const concludeWithoutValidation = /\b(mark|declare|conclude|claim)\b.*\b(done|complete|final|success)\b.*\b(no\s+(validation|test|check|review))\b/i.test(normalized)
+            || /\bwithout\s+(testing|validating|checking|reviewing)\b/i.test(normalized);
+        if (concludeWithoutValidation) {
+            matchedPolicies.push('conclusion-without-validation-guard');
+            blockedCapabilities.push('unvalidated-conclusion');
+            return {
+                allowed: false,
+                riskLevel: 'high',
+                rationale: 'Concluding the work without validation. Requires evidence step.',
+                requiresConsent: true,
+                scope: 'restricted',
+                matchedPolicies,
+                blockedCapabilities,
+                redactionRequired: false,
+                auditSummary: 'Conclusion-without-validation blocked.',
+            };
+        }
+        if (sensitive) {
+            return {
+                allowed: true,
+                riskLevel: 'medium',
+                rationale: 'Missão permitida, mas contém material sensível e exige redaction/audit reforçados.',
+                requiresConsent: false,
+                scope: 'sensitive',
+                matchedPolicies,
+                blockedCapabilities,
+                redactionRequired: true,
+                auditSummary: 'Missão permitida com redaction obrigatório.'
+            };
+        }
+        return {
+            allowed: true,
+            riskLevel: 'low',
+            rationale: 'Missão permitida no escopo atual.',
+            requiresConsent: false,
+            scope: 'safe',
+            matchedPolicies: matchedPolicies.length ? matchedPolicies : ['baseline-safe-scope'],
+            blockedCapabilities,
+            redactionRequired: false,
+            auditSummary: 'Missão autorizada pelo baseline de governança.'
+        };
+    }
+    redact(text) {
+        return text
+            .replace(/\b(sk|ghp|sbp|hf|fc|rnd|vcp|gsk|sm)_[A-Za-z0-9\-_]+\b/g, '[REDACTED_TOKEN]')
+            .replace(/\bAIza[0-9A-Za-z\-_]{20,}\b/g, '[REDACTED_GOOGLE_KEY]')
+            .replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g, '[REDACTED_EMAIL]');
+    }
+}
+exports.GovernanceLayer = GovernanceLayer;

package/dist/orchestrator/GovernancePolicyStore.js

@@ -0,0 +1,53 @@
+"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.GovernancePolicyStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class GovernancePolicyStore {
+    root;
+    policyPath;
+    constructor(root = process.cwd()) {
+        this.root = root;
+        this.policyPath = path.join(this.root, 'governance-policy.json');
+    }
+    load(project = 'default') {
+        if (!fs.existsSync(this.policyPath))
+            return null;
+        const raw = JSON.parse(fs.readFileSync(this.policyPath, 'utf-8'));
+        return raw.projects[project] || raw.projects.default || null;
+    }
+}
+exports.GovernancePolicyStore = GovernancePolicyStore;

package/dist/orchestrator/GovernanceScopeLedger.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * GovernanceScopeLedger — Story 14.2 (v1.5)
+ *
+ * Tamper-evident append-only ledger of every GovernanceDecision.
+ *
+ * v1.3 wrote a single consent record at decision time. v1.5 promotes this
+ * to a SHA-chained JSONL ledger so any post-hoc tampering with an existing
+ * entry breaks the chain and is detectable by `verify()`.
+ *
+ * File: `.openlife/governance-ledger.jsonl` (override via OPENLIFE_STATE_DIR).
+ *
+ * Chain rules:
+ *   • First entry has prevHash = 'GENESIS'.
+ *   • Each entry's entryHash = SHA-256( prevHash || JSON.stringify(payload) ).
+ *   • verify() walks the file and reports the first index where the chain
+ *     breaks. An empty file is considered valid (no entries to verify).
+ *
+ * The hook into GovernanceLayer.evaluate() is best-effort: a write failure
+ * never blocks the decision returned to the caller.
+ */
+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.GovernanceScopeLedger = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+class GovernanceScopeLedger {
+    file;
+    constructor(stateDir) {
+        const root = stateDir
+            || process.env.OPENLIFE_STATE_DIR
+            || path.join(process.cwd(), '.openlife');
+        fs.mkdirSync(root, { recursive: true });
+        this.file = path.join(root, 'governance-ledger.jsonl');
+    }
+    path() {
+        return this.file;
+    }
+    append(goal, project, decision) {
+        const prevHash = this.tailHash();
+        const index = this.size();
+        const goalHash = sha256(goal);
+        const payload = { index, ts: new Date().toISOString(), project, goalHash, decision };
+        const entryHash = sha256(prevHash + JSON.stringify(payload));
+        const entry = { ...payload, prevHash, entryHash };
+        fs.appendFileSync(this.file, JSON.stringify(entry) + '\n', 'utf-8');
+        return entry;
+    }
+    read() {
+        if (!fs.existsSync(this.file))
+            return [];
+        return fs.readFileSync(this.file, 'utf-8')
+            .split('\n')
+            .filter((l) => l.trim().length > 0)
+            .map((l) => {
+            try {
+                return JSON.parse(l);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((e) => e !== null);
+    }
+    /** Walk the chain. Returns the first broken index when tampering is detected. */
+    verify() {
+        const entries = this.read();
+        if (entries.length === 0)
+            return { ok: true, entries: 0 };
+        let prev = 'GENESIS';
+        for (let i = 0; i < entries.length; i++) {
+            const e = entries[i];
+            if (e.prevHash !== prev) {
+                return { ok: false, entries: entries.length, brokenAt: i, reason: 'prevHash_mismatch' };
+            }
+            const { index, ts, project, goalHash, decision } = e;
+            const expectedHash = sha256(prev + JSON.stringify({ index, ts, project, goalHash, decision }));
+            if (e.entryHash !== expectedHash) {
+                return { ok: false, entries: entries.length, brokenAt: i, reason: 'entryHash_mismatch' };
+            }
+            if (e.index !== i) {
+                return { ok: false, entries: entries.length, brokenAt: i, reason: 'index_mismatch' };
+            }
+            prev = e.entryHash;
+        }
+        return { ok: true, entries: entries.length };
+    }
+    tailHash() {
+        const entries = this.read();
+        return entries.length === 0 ? 'GENESIS' : entries[entries.length - 1].entryHash;
+    }
+    size() {
+        if (!fs.existsSync(this.file))
+            return 0;
+        return this.read().length;
+    }
+}
+exports.GovernanceScopeLedger = GovernanceScopeLedger;
+function sha256(input) {
+    return crypto.createHash('sha256').update(input).digest('hex');
+}

package/dist/orchestrator/GovernanceScopePolicy.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GovernanceScopePolicy = void 0;
+const IntentClassifier_1 = require("./IntentClassifier");
+const GovernancePolicyStore_1 = require("./GovernancePolicyStore");
+class GovernanceScopePolicy {
+    policyStore;
+    constructor() {
+        this.policyStore = new GovernancePolicyStore_1.GovernancePolicyStore();
+    }
+    decide(task, input, project = 'default') {
+        const normalized = input.toLowerCase();
+        const policy = this.policyStore.load(project);
+        const projectScope = /secret|token|password|credential|api\s*key/i.test(normalized)
+            ? 'sensitive'
+            : task.intent === IntentClassifier_1.TaskIntent.ENGINEERING_BUILD
+                ? 'engineering'
+                : task.intent === IntentClassifier_1.TaskIntent.RESEARCH_ANALYSIS
+                    ? 'research'
+                    : 'general';
+        const policyScope = policy?.scopes?.[projectScope];
+        if (policyScope) {
+            return {
+                projectScope,
+                allowedCapabilities: policyScope.allowedCapabilities,
+                deniedCapabilities: policyScope.deniedCapabilities,
+                rationale: `Escopo ${projectScope} carregado de governance-policy.json.`
+            };
+        }
+        if (projectScope === 'sensitive') {
+            return {
+                projectScope: 'sensitive',
+                allowedCapabilities: ['analysis', 'review', 'synthesis', 'orchestration'],
+                deniedCapabilities: ['release', 'deploy', 'destructive-write'],
+                rationale: 'Entrada sensível: liberar apenas capacidades de leitura, revisão e síntese.'
+            };
+        }
+        if (projectScope === 'engineering') {
+            return {
+                projectScope: 'engineering',
+                allowedCapabilities: ['orchestration', 'build', 'review', 'qa', 'synthesis'],
+                deniedCapabilities: ['release'],
+                rationale: 'Escopo de engenharia: build e review liberados, release segue protegido.'
+            };
+        }
+        if (projectScope === 'research') {
+            return {
+                projectScope: 'research',
+                allowedCapabilities: ['analysis', 'review', 'synthesis'],
+                deniedCapabilities: ['build', 'release', 'destructive-write'],
+                rationale: 'Escopo de research: execução restrita a análise e síntese.'
+            };
+        }
+        return {
+            projectScope: 'general',
+            allowedCapabilities: ['orchestration', 'analysis', 'synthesis'],
+            deniedCapabilities: ['release', 'destructive-write'],
+            rationale: 'Escopo geral conservador por padrão.'
+        };
+    }
+    filterCapabilities(capabilities, scope) {
+        const denied = capabilities.filter((cap) => scope.deniedCapabilities.includes(cap));
+        const allowed = capabilities.filter((cap) => scope.allowedCapabilities.includes(cap));
+        return { allowed, denied };
+    }
+}
+exports.GovernanceScopePolicy = GovernanceScopePolicy;

package/dist/orchestrator/IntentClassifier.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntentClassifier = exports.TaskIntent = void 0;
+var TaskIntent;
+(function (TaskIntent) {
+    TaskIntent["KNOWLEDGE_RETRIEVAL"] = "KNOWLEDGE_RETRIEVAL";
+    TaskIntent["ENGINEERING_BUILD"] = "ENGINEERING_BUILD";
+    TaskIntent["RESEARCH_ANALYSIS"] = "RESEARCH_ANALYSIS";
+    TaskIntent["UNKNOWN"] = "UNKNOWN";
+})(TaskIntent || (exports.TaskIntent = TaskIntent = {}));
+class IntentClassifier {
+    /**
+     * O Classificador Cognitivo do OPEN-LIFE.
+     * Na vida real, isso chamaria um LLM muito rápido (Haiku ou Llama 3 via Ollama)
+     * para ler o prompt e classificar a intenção baseado nas palavras-chave ou contexto.
+     *
+     * Aqui, estamos mockando a heurística para ilustrar o Padrão "Dispatcher".
+     */
+    async classify(userInput) {
+        const lowerInput = userInput.toLowerCase();
+        // Heurística de Construção / Complex Path
+        if (lowerInput.includes('crie') || lowerInput.includes('construa') || lowerInput.includes('desenvolva')) {
+            return {
+                intent: TaskIntent.ENGINEERING_BUILD,
+                budgetLimit: 5.00, // Budget inicial de $5.00 para tarefas de engenharia
+                requiresHarness: true // Engenharia aciona CLIs, precisa estar isolado
+            };
+        }
+        // Heurística de Pesquisa / OSWorld
+        if (lowerInput.includes('pesquise') || lowerInput.includes('procure') || lowerInput.includes('investigue')) {
+            return {
+                intent: TaskIntent.RESEARCH_ANALYSIS,
+                budgetLimit: 1.00, // Pesquisa é mais barata
+                requiresHarness: true // Browser-use precisa de sandbox
+            };
+        }
+        // Heurística de Fast Path (Conversa, dúvida)
+        return {
+            intent: TaskIntent.KNOWLEDGE_RETRIEVAL,
+            budgetLimit: 0.10, // Resposta rápida, custo quase zero
+            requiresHarness: false // Não vai acessar terminal local
+        };
+    }
+}
+exports.IntentClassifier = IntentClassifier;

package/dist/orchestrator/JobLifecycle.js

@@ -0,0 +1,91 @@
+"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.JobLifecycleStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const AtomicWriter_1 = require("./util/AtomicWriter");
+class JobLifecycleStore {
+    baseDir;
+    jobsDir;
+    eventsDir;
+    constructor(workspaceId = 'default') {
+        this.baseDir = path.join(process.cwd(), '.artifacts', 'workspaces', workspaceId, 'jobs');
+        this.jobsDir = path.join(this.baseDir, 'records');
+        this.eventsDir = path.join(this.baseDir, 'events');
+        fs.mkdirSync(this.jobsDir, { recursive: true });
+        fs.mkdirSync(this.eventsDir, { recursive: true });
+    }
+    enqueue(goal, workspaceId = 'default', serviceId, taskId) {
+        const now = new Date().toISOString();
+        const jobId = `job_${Date.now()}`;
+        const rec = { jobId, workspaceId, serviceId, taskId, goal, status: 'enqueued', createdAt: now, updatedAt: now };
+        this.save(rec);
+        this.append({ jobId, workspaceId, type: 'enqueued', summary: 'Job enqueued', at: now });
+        return rec;
+    }
+    transition(jobId, workspaceId, status, summary, ownerAgentId, blocker) {
+        const rec = this.get(jobId);
+        if (!rec)
+            return null;
+        const next = { ...rec, workspaceId, status, ownerAgentId: ownerAgentId ?? rec.ownerAgentId, blocker: blocker ?? rec.blocker, updatedAt: new Date().toISOString() };
+        this.save(next);
+        this.append({ jobId, workspaceId, type: status, summary, at: next.updatedAt });
+        return next;
+    }
+    get(jobId) {
+        const p = path.join(this.jobsDir, `${jobId}.json`);
+        if (!fs.existsSync(p))
+            return null;
+        return JSON.parse(fs.readFileSync(p, 'utf-8'));
+    }
+    list(limit = 100) {
+        const files = fs.readdirSync(this.jobsDir).filter((f) => f.endsWith('.json')).slice(-limit);
+        return files.map((f) => JSON.parse(fs.readFileSync(path.join(this.jobsDir, f), 'utf-8')));
+    }
+    events(jobId) {
+        const p = path.join(this.eventsDir, `${jobId}.jsonl`);
+        if (!fs.existsSync(p))
+            return [];
+        return fs.readFileSync(p, 'utf-8').split('\n').filter(Boolean).map((l) => JSON.parse(l));
+    }
+    save(rec) {
+        (0, AtomicWriter_1.writeJsonAtomic)(path.join(this.jobsDir, `${rec.jobId}.json`), rec);
+    }
+    append(ev) {
+        (0, AtomicWriter_1.appendJsonlAtomic)(path.join(this.eventsDir, `${ev.jobId}.jsonl`), ev);
+    }
+}
+exports.JobLifecycleStore = JobLifecycleStore;

package/dist/orchestrator/LearningRouter.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LearningRouter = void 0;
+const PerformanceScorecard_1 = require("./PerformanceScorecard");
+class LearningRouter {
+    capabilityRouter;
+    scoring;
+    scorecard;
+    constructor(capabilityRouter, scoring) {
+        this.capabilityRouter = capabilityRouter;
+        this.scoring = scoring;
+        this.scorecard = new PerformanceScorecard_1.PerformanceScorecard();
+    }
+    route(task, input) {
+        const route = this.capabilityRouter.route(task, input);
+        route.agents = [...route.agents].sort((a, b) => {
+            const scoreA = (this.scoring.get(a.id)?.score || 0) + (this.scorecard.get(a.id)?.score || 0);
+            const scoreB = (this.scoring.get(b.id)?.score || 0) + (this.scorecard.get(b.id)?.score || 0);
+            return scoreB - scoreA;
+        });
+        return route;
+    }
+}
+exports.LearningRouter = LearningRouter;