@openlife/cli 1.7.3

package/dist/test_performance_latency.js

@@ -0,0 +1,215 @@
+"use strict";
+/**
+ * test_performance_latency.ts — Story 12.4
+ *
+ * Lightweight latency benchmark for OpenLife hot paths. Measures P50/P95/P99
+ * for a handful of deterministic operations and persists a baseline at
+ * `.artifacts/perf-baseline.json`. Fails if any P95 regresses more than
+ * the configured threshold (default 30%) vs the saved baseline.
+ *
+ * Design constraints:
+ *   • runs inside `test:all` → must complete in <5s end-to-end
+ *   • no CLI spawn — measures library code directly to keep variance low
+ *   • baseline auto-seeds on first run; later runs compare
+ *   • configurable threshold via PERF_REGRESSION_THRESHOLD_PCT (default 30)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const IntentClassifier_1 = require("./orchestrator/IntentClassifier");
+const ToolsetGuard_1 = require("./orchestrator/toolset/ToolsetGuard");
+const ProfileManager_1 = require("./cli/ProfileManager");
+const ConditionParser_1 = require("./orchestrator/workflow/ConditionParser");
+const WorkflowParser_1 = require("./orchestrator/workflow/WorkflowParser");
+function nowNs() { return process.hrtime.bigint(); }
+function nsToMs(ns) { return Number(ns) / 1_000_000; }
+function percentile(sorted, p) {
+    if (sorted.length === 0)
+        return 0;
+    const idx = Math.min(sorted.length - 1, Math.floor((sorted.length - 1) * p));
+    return sorted[idx];
+}
+function bench(name, iterations, fn) {
+    // Warm-up — discard first 5 runs to avoid JIT noise.
+    for (let i = 0; i < 5; i++)
+        fn();
+    const samples = [];
+    for (let i = 0; i < iterations; i++) {
+        const start = nowNs();
+        fn();
+        samples.push(nsToMs(nowNs() - start));
+    }
+    samples.sort((a, b) => a - b);
+    return {
+        name,
+        iterations,
+        p50ms: percentile(samples, 0.5),
+        p95ms: percentile(samples, 0.95),
+        p99ms: percentile(samples, 0.99),
+        meanMs: samples.reduce((s, v) => s + v, 0) / samples.length,
+    };
+}
+function main() {
+    const repoRoot = path.resolve(__dirname, '..');
+    const artifactsDir = path.join(repoRoot, '.artifacts');
+    fs.mkdirSync(artifactsDir, { recursive: true });
+    // Story 13.4 (v1.5) — baseline path is now env-overridable so CI can
+    // point at a checked-in `ci/perf-baseline.json` while local dev keeps
+    // the gitignored `.artifacts/perf-baseline.json`.
+    const baselineFile = process.env.OPENLIFE_PERF_BASELINE_FILE
+        ? path.resolve(repoRoot, process.env.OPENLIFE_PERF_BASELINE_FILE)
+        : path.join(artifactsDir, 'perf-baseline.json');
+    fs.mkdirSync(path.dirname(baselineFile), { recursive: true });
+    // ── Benchmark 1: IntentClassifier.classify ──────────────────────
+    const classifier = new IntentClassifier_1.IntentClassifier();
+    const b1 = bench('intent_classify_cold', 200, () => {
+        classifier.classify('plan a small refactor of the auth flow');
+    });
+    // ── Benchmark 2: ToolsetGuard isAllowed (off path) ──────────────
+    (0, ToolsetGuard_1._resetToolsetGuardCache)();
+    const b2 = bench('toolset_guard_off', 500, () => {
+        (0, ToolsetGuard_1.isToolsetAllowed)('terminal');
+    });
+    // ── Benchmark 3: ProfileManager list ────────────────────────────
+    const tmpStateDir = path.join(artifactsDir, '_perf-bench-state');
+    fs.mkdirSync(tmpStateDir, { recursive: true });
+    const prevStateDir = process.env.OPENLIFE_STATE_DIR;
+    process.env.OPENLIFE_STATE_DIR = tmpStateDir;
+    const pm = new ProfileManager_1.ProfileManager();
+    // Seed 5 profiles for realistic listing.
+    for (const id of ['a', 'b', 'c', 'd', 'e']) {
+        try {
+            pm.create({ id, name: id, toolsetAllowed: ['*'] });
+        }
+        catch { /* ignore re-create */ }
+    }
+    const b3 = bench('profile_manager_list', 200, () => {
+        pm.list();
+    });
+    if (prevStateDir === undefined)
+        delete process.env.OPENLIFE_STATE_DIR;
+    else
+        process.env.OPENLIFE_STATE_DIR = prevStateDir;
+    fs.rmSync(tmpStateDir, { recursive: true, force: true });
+    // ── Benchmark 4 (Story 16.2): condition parser hot path ──────────
+    const parseResult = (0, ConditionParser_1.parseCondition)('(foo == "bar" AND baz) OR NOT qux');
+    const conditionAst = parseResult.ok ? parseResult.ast : null;
+    const conditionCtx = { foo: 'bar', baz: true, qux: false };
+    const b4 = bench('condition_parse_and_evaluate', 500, () => {
+        const r = (0, ConditionParser_1.parseCondition)('(foo == "bar" AND baz) OR NOT qux');
+        if (r.ok && r.ast)
+            (0, ConditionParser_1.evaluate)(r.ast, conditionCtx);
+        else if (conditionAst)
+            (0, ConditionParser_1.evaluate)(conditionAst, conditionCtx);
+    });
+    // ── Benchmark 5 (Story 16.2): workflow parse hot path ──────────────
+    const sampleYaml = [
+        'id: bench-wf',
+        'name: Bench Workflow',
+        'version: "1.0"',
+        'description: tiny',
+        'mode: task',
+        'steps:',
+        '  - id: greet',
+        '    name: greet',
+        '    agent: cli',
+        '    action: { kind: log, message: hi }',
+        '  - id: verify',
+        '    name: verify',
+        '    agent: cli',
+        '    action: { kind: log, message: ok }',
+        '    condition: greet.success',
+        '',
+    ].join('\n');
+    const b5 = bench('workflow_parse', 200, () => {
+        (0, WorkflowParser_1.parseWorkflow)(sampleYaml);
+    });
+    // ── Aggregate & persist ────────────────────────────────────────
+    const results = [b1, b2, b3, b4, b5];
+    const current = {
+        capturedAt: new Date().toISOString(),
+        benchmarks: results.reduce((acc, r) => {
+            acc[r.name] = { p50ms: r.p50ms, p95ms: r.p95ms, p99ms: r.p99ms, meanMs: r.meanMs };
+            return acc;
+        }, {}),
+    };
+    const threshold = Number(process.env.PERF_REGRESSION_THRESHOLD_PCT || 30);
+    if (!fs.existsSync(baselineFile)) {
+        fs.writeFileSync(baselineFile, JSON.stringify(current, null, 2), 'utf-8');
+        console.log('[perf] no baseline found — seeded fresh baseline.');
+        for (const r of results) {
+            console.log(`[perf] ${r.name.padEnd(28)} P50=${r.p50ms.toFixed(3)}ms  P95=${r.p95ms.toFixed(3)}ms  P99=${r.p99ms.toFixed(3)}ms  mean=${r.meanMs.toFixed(3)}ms`);
+        }
+        console.log('TEST_PERFORMANCE_LATENCY_OK');
+        return;
+    }
+    const baseline = JSON.parse(fs.readFileSync(baselineFile, 'utf-8'));
+    // Story 13.4 (v1.5) — absolute P95 floor below which the % gate is skipped.
+    // Sub-millisecond benchmarks are dominated by timer noise; a +30% delta on
+    // 0.001ms is meaningless. Configurable via PERF_NOISE_FLOOR_MS (default 0.5).
+    const noiseFloorMs = Number(process.env.PERF_NOISE_FLOOR_MS || 0.5);
+    const regressions = [];
+    for (const r of results) {
+        const prev = baseline.benchmarks[r.name];
+        if (!prev) {
+            console.log(`[perf] ${r.name} new — no baseline.`);
+            continue;
+        }
+        if (prev.p95ms < noiseFloorMs && r.p95ms < noiseFloorMs) {
+            console.log(`[perf] · ${r.name.padEnd(28)} P95 now=${r.p95ms.toFixed(3)}ms (baseline=${prev.p95ms.toFixed(3)}ms) — below noise floor ${noiseFloorMs}ms, gate skipped`);
+            continue;
+        }
+        const pctP95 = prev.p95ms > 0 ? ((r.p95ms - prev.p95ms) / prev.p95ms) * 100 : 0;
+        const mark = pctP95 > threshold ? '❌' : '✓';
+        console.log(`[perf] ${mark} ${r.name.padEnd(28)} P95 now=${r.p95ms.toFixed(3)}ms vs baseline=${prev.p95ms.toFixed(3)}ms (${pctP95 >= 0 ? '+' : ''}${pctP95.toFixed(1)}%)`);
+        if (pctP95 > threshold)
+            regressions.push(`${r.name}: P95 +${pctP95.toFixed(1)}% > threshold ${threshold}%`);
+    }
+    if (regressions.length > 0) {
+        console.error('[perf] REGRESSION DETECTED:');
+        for (const r of regressions)
+            console.error(`  • ${r}`);
+        process.exitCode = 1;
+        return;
+    }
+    // Optionally refresh the baseline if PERF_REFRESH_BASELINE=1.
+    if (process.env.PERF_REFRESH_BASELINE === '1') {
+        fs.writeFileSync(baselineFile, JSON.stringify(current, null, 2), 'utf-8');
+        console.log('[perf] baseline refreshed.');
+    }
+    console.log('TEST_PERFORMANCE_LATENCY_OK');
+}
+main();

package/dist/test_performance_scorecard.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PerformanceScorecard_1 = require("./orchestrator/PerformanceScorecard");
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+async function main() {
+    const scorecard = new PerformanceScorecard_1.PerformanceScorecard();
+    scorecard.record({
+        entityId: 'agent-builder',
+        entityType: 'agent',
+        status: 'success',
+        durationMs: 8000,
+        reviewScore: 0.9,
+        fallbackUsed: false,
+        timestamp: new Date().toISOString()
+    });
+    scorecard.record({
+        entityId: 'agent-builder',
+        entityType: 'agent',
+        status: 'partial',
+        durationMs: 12000,
+        reviewScore: 0.6,
+        fallbackUsed: true,
+        timestamp: new Date().toISOString()
+    });
+    const aggregate = scorecard.get('agent-builder');
+    assert(!!aggregate, 'aggregate should exist');
+    assert(aggregate.runs >= 2, 'runs should accumulate');
+    assert(aggregate.avgReviewScore > 0, 'review score should be tracked');
+    assert(aggregate.fallbackRate > 0, 'fallback rate should be tracked');
+    console.log('TEST_PERFORMANCE_SCORECARD_OK');
+}
+main().catch((error) => {
+    console.error(error.message || error);
+    process.exit(1);
+});

package/dist/test_phase1_check_exit.js

@@ -0,0 +1,103 @@
+"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 });
+/*
+ * Regression test for Story 2.1 — Phase 5 v1.0 milestone.
+ *
+ * Asserts `openlife phase1-check` exits DETERMINISTICALLY (does not hang).
+ * Previously, the command would never exit because TestHarness instantiates
+ * Gateway → Telegraf, leaving event-loop handles open. Same root-cause pattern
+ * as Story 1.2 `ask` exit fix.
+ *
+ * The test uses a generous timeout (default 120s) to accommodate slow imports
+ * in WSL (Brain alone takes ~10s to require; Gateway ~21s). The bug being
+ * tested is forever-hang, not slow-but-finite.
+ *
+ * Wired into test:all via `test:phase1-check-exit` script.
+ */
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const CLI = path.join(process.cwd(), 'dist', 'index.js');
+// Generous shell timeout — Brain/Gateway imports take 10-25s each in WSL.
+// The bug is forever-hang, not slowness. If it exits within 120s, fix works.
+const SHELL_TIMEOUT_MS = Number(process.env.OPENLIFE_TEST_PHASE1_SHELL_TIMEOUT_MS || 120000);
+// Pass tighter internal master timeout to phase1-check
+const INTERNAL_TIMEOUT_MS = Number(process.env.OPENLIFE_TEST_PHASE1_INTERNAL_TIMEOUT_MS || 90000);
+function runPhase1Check() {
+    return new Promise((resolve) => {
+        const t0 = Date.now();
+        const child = (0, child_process_1.spawn)('node', [CLI, 'phase1-check'], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                OPENLIFE_PHASE1_TIMEOUT_MS: String(INTERNAL_TIMEOUT_MS)
+            }
+        });
+        // Drain stdio so child doesn't block on full pipes
+        child.stdout?.on('data', () => { });
+        child.stderr?.on('data', () => { });
+        let timedOut = false;
+        const killer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGKILL');
+        }, SHELL_TIMEOUT_MS);
+        child.on('exit', (code, signal) => {
+            clearTimeout(killer);
+            resolve({ code, signal, elapsed: Date.now() - t0, timedOut });
+        });
+    });
+}
+async function main() {
+    if (!fs.existsSync(CLI))
+        throw new Error(`MISSING_BUILD: ${CLI}`);
+    const result = await runPhase1Check();
+    if (result.timedOut) {
+        throw new Error(`PHASE1_CHECK_HUNG: process did not exit within ${SHELL_TIMEOUT_MS}ms — Story 2.1 regression`);
+    }
+    // Accept exit 0 (all checks green) OR exit 1 (some checks failed but command terminated)
+    // Reject signal-only exit (would indicate crash mid-execution)
+    if (result.code === null) {
+        throw new Error(`PHASE1_CHECK_NO_EXIT_CODE: signal=${result.signal} elapsed=${result.elapsed}ms`);
+    }
+    if (result.code !== 0 && result.code !== 1) {
+        throw new Error(`PHASE1_CHECK_UNEXPECTED_EXIT: code=${result.code} elapsed=${result.elapsed}ms (expected 0 or 1)`);
+    }
+    console.log(`TEST_PHASE1_CHECK_EXIT_OK (code=${result.code}, elapsed=${result.elapsed}ms, signal=${result.signal})`);
+}
+main().catch((err) => {
+    console.error('TEST_PHASE1_CHECK_EXIT_FAIL:', err?.message || err);
+    process.exit(1);
+});

package/dist/test_phase6_board.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ExecutionBoard_1 = require("./orchestrator/ExecutionBoard");
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+async function main() {
+    const board = new ExecutionBoard_1.ExecutionBoard();
+    board.add({
+        id: 'board-phase6-smart',
+        title: 'Testar board inteligente',
+        ownerRole: 'coo',
+        status: 'active',
+        priority: 'high',
+        dependencies: ['dep-1'],
+        slaHours: 24,
+        notes: 'item de teste'
+    });
+    board.updateStatus('board-phase6-smart', 'blocked', 'Dependência externa pendente');
+    const item = board.getAll().find((entry) => entry.id === 'board-phase6-smart');
+    assert(!!item, 'board item should exist');
+    assert(item.blockerReason === 'Dependência externa pendente', 'board should persist blocker reason');
+    assert(Array.isArray(item.dependencies) && item.dependencies.length === 1, 'board should persist dependencies');
+    assert(typeof item.ageHours === 'number', 'board should expose age hours');
+    console.log('TEST_PHASE6_BOARD_OK');
+}
+main().catch((error) => {
+    console.error(error.message || error);
+    process.exit(1);
+});

package/dist/test_phase6_cadence.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RoleHandoff_1 = require("./orchestrator/RoleHandoff");
+const CadenceEngine_1 = require("./orchestrator/CadenceEngine");
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+async function main() {
+    const handoff = new RoleHandoff_1.RoleHandoff();
+    const cadence = new CadenceEngine_1.CadenceEngine();
+    handoff.create({
+        id: 'handoff-phase6',
+        fromRole: 'cpo',
+        toRole: 'cto',
+        missionId: 'task-phase6',
+        summary: 'Transformar descoberta em execução.',
+        status: 'queued'
+    });
+    const planning = cadence.schedule('planning', 'Planning semanal', 'coo');
+    cadence.updateStatus(planning.id, 'running');
+    assert(handoff.getAll().some((item) => item.id === 'handoff-phase6'), 'handoff should persist');
+    assert(cadence.getAll().some((item) => item.id === planning.id && item.status === 'running'), 'cadence should update status');
+    console.log('TEST_PHASE6_CADENCE_OK');
+}
+main().catch((error) => {
+    console.error(error.message || error);
+    process.exit(1);
+});

package/dist/test_phase6_ops.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const OrgStructure_1 = require("./orchestrator/OrgStructure");
+const ExecutionBoard_1 = require("./orchestrator/ExecutionBoard");
+const ReleaseWorkflow_1 = require("./orchestrator/ReleaseWorkflow");
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+async function main() {
+    const org = new OrgStructure_1.OrgStructure();
+    const board = new ExecutionBoard_1.ExecutionBoard();
+    const release = new ReleaseWorkflow_1.ReleaseWorkflow();
+    const roles = org.all();
+    assert(roles.length >= 4, 'org structure should expose core leadership roles');
+    board.add({
+        id: 'phase6-init',
+        title: 'Iniciar estrutura operacional da Fase 6',
+        ownerRole: 'coo',
+        status: 'active',
+        priority: 'high',
+        notes: 'Abrir trilho company-in-a-box'
+    });
+    const items = board.getAll();
+    assert(items.some((item) => item.id === 'phase6-init'), 'execution board should store operational items');
+    const checklist = release.create('release-phase6-bootstrap', [
+        { name: 'build', ok: true },
+        { name: 'tests', ok: true },
+        { name: 'docs', ok: true }
+    ]);
+    assert(checklist.approved === true, 'release checklist should approve when all checks pass');
+    console.log('TEST_PHASE6_OPS_OK');
+}
+main().catch((error) => {
+    console.error(error.message || error);
+    process.exit(1);
+});

package/dist/test_post_mission_evaluation.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * test_post_mission_evaluation.ts — Story 13.1 (v1.5)
+ *
+ * Asserts:
+ *   1. OPENLIFE_POST_MISSION_EVALUATION=off short-circuits — no evaluation
+ *      file is written even when a Brain key is present.
+ *   2. With no Brain key but with successCriteria, the heuristic fallback
+ *      via MissionEvaluationStore.judge() writes the file.
+ *   3. With a stubbed Brain that returns a structured JSON evaluation, the
+ *      Brain-derived fields land in the persisted record (source='brain').
+ *   4. Malformed Brain output falls back to the heuristic record.
+ *
+ * Drives the real `evaluateMission` via a focused harness — we instantiate
+ * a partial MissionState (only the fields evaluateMission reads) and call
+ * the private method via a thin reflection bridge to keep the test
+ * deterministic and offline.
+ */
+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"));
+function assertTrue(cond, label) {
+    if (!cond)
+        throw new Error(`ASSERT_FAILED[${label}]`);
+}
+function withEnv(key, value, body) {
+    const prev = process.env[key];
+    if (value === undefined)
+        delete process.env[key];
+    else
+        process.env[key] = value;
+    return Promise.resolve(body()).finally(() => {
+        if (prev === undefined)
+            delete process.env[key];
+        else
+            process.env[key] = prev;
+    });
+}
+async function main() {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'post-mission-eval-'));
+    process.env.OPENLIFE_STATE_DIR = tmp;
+    try {
+        // Defer requires until env is set so EnterpriseAgenticCore picks tmp dir.
+        const { OrchestrationLoop } = require('./orchestrator/OrchestrationLoop');
+        const { MissionEvaluationStore } = require('./orchestrator/EnterpriseAgenticCore');
+        // Constructing OrchestrationLoop is heavy (many deps). For Story 13.1 we
+        // only need the evaluateMission method, so we reach into the prototype
+        // directly with a minimal `this` shape.
+        const evaluateMission = OrchestrationLoop.prototype.evaluateMission;
+        const parseEvalJson = OrchestrationLoop.prototype.parseEvaluationJson;
+        const baseState = {
+            taskId: 'mission-001',
+            goal: 'investigate cold-start latency',
+            status: 'success',
+            successCriteria: ['root cause found', 'fix proposed'],
+            consequenceThoughtTrace: { snapshots: [{ note: 'looked at metrics' }] },
+            reviewFindings: [{ approved: true, critique: 'looks good' }],
+        };
+        const store = new MissionEvaluationStore(tmp);
+        const evalPath = (id) => path.join(store.dir(), `${id}.json`);
+        // ── Scenario 1: parseEvaluationJson unit checks ────────────────────
+        // Verifies the JSON-extraction helper that gates Brain output.
+        const ok = parseEvalJson.call({}, 'noise {"score":42,"verdict":"needs_iteration","risks":["a"],"rationale":"r"} trailing');
+        assertTrue(ok !== null && ok.score === 42, '[13.1] parser handles embedded JSON');
+        const wrongVerdict = parseEvalJson.call({}, '{"score":50,"verdict":"thumbs_up","risks":[],"rationale":""}');
+        assertTrue(wrongVerdict === null, '[13.1] parser rejects unknown verdict');
+        const noScore = parseEvalJson.call({}, '{"verdict":"ready_for_review","risks":[],"rationale":"x"}');
+        assertTrue(noScore === null, '[13.1] parser rejects missing score');
+        const clamped = parseEvalJson.call({}, '{"score":150,"verdict":"ready_for_review","risks":[],"rationale":""}');
+        assertTrue(clamped && clamped.score === 100, '[13.1] parser clamps score to <=100');
+        const garbage = parseEvalJson.call({}, 'totally not json');
+        assertTrue(garbage === null, '[13.1] parser returns null on garbage input');
+        console.log('[13.1] parseEvaluationJson unit checks pass ✓');
+        // ── Scenario 2: no Brain key → heuristic fallback ──────────────────
+        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 id = 'mission-heuristic';
+            await evaluateMission.call({ parseEvaluationJson: parseEvalJson }, { ...baseState, taskId: id });
+            assertTrue(fs.existsSync(evalPath(id)), '[13.1] heuristic fallback wrote eval file');
+            const eval1 = JSON.parse(fs.readFileSync(evalPath(id), 'utf-8'));
+            assertTrue(typeof eval1.score === 'number' && eval1.score >= 0 && eval1.score <= 100, '[13.1] heuristic score in [0,100]');
+            assertTrue(Array.isArray(eval1.criteria) && eval1.criteria.length === 2, '[13.1] heuristic criteria preserved');
+        }
+        console.log('[13.1] no-key heuristic fallback writes record ✓');
+        // ── Scenario 3: stubbed Brain → structured evaluation lands ────────
+        // We stub Brain by monkey-patching the require cache.
+        const brainPath = require.resolve('./orchestrator/Brain');
+        const origCache = require.cache[brainPath];
+        require.cache[brainPath] = {
+            ...origCache,
+            exports: {
+                Brain: class {
+                    isAnyProviderAvailable() { return true; }
+                    async think() {
+                        return 'Sure! Here is the eval: {"score":88,"verdict":"ready_for_review","risks":["regression in cold path"],"rationale":"all criteria met"}';
+                    }
+                },
+            },
+        };
+        try {
+            const id = 'mission-brain';
+            await evaluateMission.call({ parseEvaluationJson: parseEvalJson }, { ...baseState, taskId: id });
+            assertTrue(fs.existsSync(evalPath(id)), '[13.1] brain path wrote eval file');
+            const evalBrain = JSON.parse(fs.readFileSync(evalPath(id), 'utf-8'));
+            assertTrue(evalBrain.source === 'brain', `[13.1] eval source=brain (got ${evalBrain.source})`);
+            assertTrue(evalBrain.score === 88, `[13.1] brain score landed (got ${evalBrain.score})`);
+            assertTrue(evalBrain.verdict === 'ready_for_review', `[13.1] brain verdict landed (got ${evalBrain.verdict})`);
+            assertTrue(Array.isArray(evalBrain.risks) && evalBrain.risks[0] === 'regression in cold path', '[13.1] brain risks landed');
+            assertTrue(typeof evalBrain.rationale === 'string' && evalBrain.rationale.includes('criteria met'), '[13.1] brain rationale landed');
+        }
+        finally {
+            if (origCache)
+                require.cache[brainPath] = origCache;
+            else
+                delete require.cache[brainPath];
+        }
+        console.log('[13.1] brain-derived structured evaluation persisted ✓');
+        // ── Scenario 4: garbage Brain output → heuristic fallback ─────────
+        require.cache[brainPath] = {
+            ...origCache,
+            exports: {
+                Brain: class {
+                    isAnyProviderAvailable() { return true; }
+                    async think() { return 'I cannot parse this. Sorry.'; }
+                },
+            },
+        };
+        try {
+            const id = 'mission-garbage';
+            await evaluateMission.call({ parseEvaluationJson: parseEvalJson }, { ...baseState, taskId: id });
+            assertTrue(fs.existsSync(evalPath(id)), '[13.1] garbage brain fell back to heuristic file');
+            const evalGarbage = JSON.parse(fs.readFileSync(evalPath(id), 'utf-8'));
+            assertTrue(evalGarbage.source !== 'brain', '[13.1] garbage path is not source=brain (heuristic fallback)');
+        }
+        finally {
+            if (origCache)
+                require.cache[brainPath] = origCache;
+            else
+                delete require.cache[brainPath];
+        }
+        console.log('[13.1] malformed brain output falls back cleanly ✓');
+    }
+    finally {
+        delete process.env.OPENLIFE_STATE_DIR;
+        fs.rmSync(tmp, { recursive: true, force: true });
+    }
+    console.log('TEST_POST_MISSION_EVALUATION_OK');
+}
+main().catch((err) => {
+    console.error('[post-mission-evaluation] FAILED:', err instanceof Error ? err.message : err);
+    process.exit(1);
+});