@openlife/cli 1.7.3

package/dist/test_trigger_basic_auth.js

@@ -0,0 +1,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const http = __importStar(require("http"));
+const PORT = 3098;
+process.env.PORT = String(PORT);
+process.env.TELEGRAM_BOT_TOKEN = '';
+async function post(pathStr, body, headers = {}) {
+    return new Promise((resolve, reject) => {
+        const payload = JSON.stringify(body);
+        const req = http.request({
+            host: '127.0.0.1',
+            port: PORT,
+            path: pathStr,
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload), ...headers },
+            timeout: 5000
+        }, (res) => {
+            let chunks = '';
+            res.on('data', (d) => { chunks += d; });
+            res.on('end', () => resolve({ status: res.statusCode || 0, body: chunks }));
+        });
+        req.on('error', reject);
+        req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+        req.write(payload);
+        req.end();
+    });
+}
+function basicAuthHeader(user, pass) {
+    return 'Basic ' + Buffer.from(`${user}:${pass}`).toString('base64');
+}
+async function bootGateway() {
+    const { Gateway } = require('./orchestrator/Gateway');
+    const gateway = new Gateway();
+    gateway.start();
+    await new Promise((r) => setTimeout(r, 500));
+    return gateway;
+}
+async function caseAuthEnabled() {
+    process.env.OPENLIFE_TRIGGER_USER = 'webhook-user';
+    process.env.OPENLIFE_TRIGGER_PASS = 'webhook-pass';
+    const gateway = await bootGateway();
+    try {
+        const noAuth = await post('/api/v1/trigger', { text: 'ping' });
+        if (noAuth.status !== 401)
+            throw new Error(`AUTH_ENABLED_BUT_NO_AUTH_REQUEST_GOT_${noAuth.status}: ${noAuth.body}`);
+        const wrongPass = await post('/api/v1/trigger', { text: 'ping' }, { Authorization: basicAuthHeader('webhook-user', 'wrong') });
+        if (wrongPass.status !== 403)
+            throw new Error(`WRONG_CREDS_GOT_${wrongPass.status}: ${wrongPass.body}`);
+        const goodAuth = await post('/api/v1/trigger', { text: 'ping smoke' }, { Authorization: basicAuthHeader('webhook-user', 'webhook-pass') });
+        if (goodAuth.status !== 200 && goodAuth.status !== 500) {
+            throw new Error(`VALID_CREDS_GOT_${goodAuth.status} (expected 200 or 500-when-no-LLM): ${goodAuth.body}`);
+        }
+    }
+    finally {
+        await gateway.shutdown('TEST_AUTH_ENABLED');
+    }
+}
+async function caseAuthDisabled() {
+    delete process.env.OPENLIFE_TRIGGER_USER;
+    delete process.env.OPENLIFE_TRIGGER_PASS;
+    const gateway = await bootGateway();
+    try {
+        const r = await post('/api/v1/trigger', { text: 'ping unauth' });
+        if (r.status === 401 || r.status === 403)
+            throw new Error(`UNAUTHED_MODE_REJECTED_${r.status}: ${r.body}`);
+    }
+    finally {
+        await gateway.shutdown('TEST_AUTH_DISABLED');
+    }
+}
+async function main() {
+    await caseAuthEnabled();
+    await caseAuthDisabled();
+    console.log('TEST_TRIGGER_BASIC_AUTH_OK');
+}
+main().catch((err) => {
+    console.error('TEST_TRIGGER_BASIC_AUTH_FAIL:', err?.message || err);
+    process.exit(1);
+});

package/dist/test_util/doc_parity.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * doc_parity.ts — Story 7.2
+ *
+ * Reusable helpers for "documentation makes a claim about CLI surface — is it
+ * still true?" tests. Used by:
+ *   - test_cli_doc_parity.ts        (root help vs README quick-start)
+ *   - test_multi_host_docs_parity.ts (per-host install docs vs CLI)
+ *   - test_aiobuilder_cli_parity.ts (squad doc verbs vs aiobuilder sub-commands)
+ *
+ * Each helper is intentionally tiny. The goal is fewer copy-pasted regex
+ * loops across parity tests, not an inheritance hierarchy.
+ */
+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.spawnCliHelp = spawnCliHelp;
+exports.extractCommanderCommands = extractCommanderCommands;
+exports.extractDocTokens = extractDocTokens;
+exports.assertCliParity = assertCliParity;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const CLI = path.join(process.cwd(), 'dist', 'index.js');
+/** Spawn `node bin/openlife.js <args> --help` and return the merged stdout/stderr. */
+function spawnCliHelp(args = [], timeoutMs = 20000) {
+    const r = (0, child_process_1.spawnSync)('node', [CLI, ...args, '--help'], { encoding: 'utf-8', timeout: timeoutMs });
+    return { ok: r.status === 0, status: r.status, help: (r.stdout || '') + (r.stderr || '') };
+}
+/**
+ * Extract Commander sub-command names from a help block.
+ * Commander prints each sub-command starting at column 2: "  <name> [options]...".
+ */
+function extractCommanderCommands(helpText) {
+    const out = new Set();
+    const lines = helpText.split('\n');
+    let inCommands = false;
+    for (const line of lines) {
+        if (/^Commands:/.test(line)) {
+            inCommands = true;
+            continue;
+        }
+        if (!inCommands)
+            continue;
+        const m = line.match(/^\s{2}([a-z][\w-]*)/);
+        if (m)
+            out.add(m[1]);
+    }
+    return out;
+}
+/**
+ * Read a doc file and extract every token matching `re` (must have one capture group).
+ * Returns a sorted, de-duplicated list. Throws if the file does not exist.
+ */
+function extractDocTokens(docPath, re) {
+    if (!fs.existsSync(docPath)) {
+        throw new Error(`DOC_NOT_FOUND: ${docPath}`);
+    }
+    const content = fs.readFileSync(docPath, 'utf-8');
+    const tokens = new Set();
+    // Use matchAll to avoid stateful regex iteration.
+    const reGlobal = new RegExp(re.source, re.flags.includes('g') ? re.flags : re.flags + 'g');
+    for (const m of content.matchAll(reGlobal)) {
+        if (m[1])
+            tokens.add(m[1]);
+    }
+    return Array.from(tokens).sort();
+}
+/**
+ * Assert every doc token corresponds to a CLI command (direct or via alias map).
+ * Returns a verdict object — callers decide whether to throw, log, or annotate.
+ */
+function assertCliParity(docTokens, cliCommands, aliasMap = {}) {
+    const matched = [];
+    const missing = [];
+    for (const tok of docTokens) {
+        if (cliCommands.has(tok)) {
+            matched.push({ token: tok, via: tok });
+            continue;
+        }
+        const alias = aliasMap[tok];
+        if (alias && cliCommands.has(alias)) {
+            matched.push({ token: tok, via: `${alias} (alias)` });
+            continue;
+        }
+        missing.push(tok);
+    }
+    return { ok: missing.length === 0, matched, missing, total: docTokens.length };
+}

package/dist/test_v15_e2e_integration.js

@@ -0,0 +1,207 @@
+"use strict";
+/**
+ * test_v15_e2e_integration.ts — Story 17.1 (v1.5)
+ *
+ * Walks every v1.5 surface in sequence from a tmp workspace, asserting
+ * that the cross-feature interactions hold:
+ *
+ *   1. Seed a Squad via SquadCreator.create.
+ *   2. Run a synthetic mission and persist a MissionState.
+ *   3. Trigger the post-mission evaluation hook (Story 13.1) directly
+ *      via OrchestrationLoop.prototype.evaluateMission, stubbing Brain
+ *      so the test stays offline. Expect a `.openlife/evaluations/<id>.json`
+ *      with source='brain'.
+ *   4. `eval list` (Story 13.2) via the MissionEvaluationStore.list()
+ *      surface — filters by verdict.
+ *   5. Squad migrate + extend + publish (v1.4 Stories 11.1–11.3).
+ *   6. Publish to remote via stubbed RemotePublisher (Story 14.1).
+ *   7. Governance evaluate writes to the scope ledger (Story 14.2);
+ *      verify() walks the chain clean.
+ *
+ * No network. No filesystem outside the tmp workspace. Every Brain /
+ * RemotePublisher call is module-cache-stubbed.
+ */
+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 stubModule(modulePath, exports) {
+    const resolved = require.resolve(modulePath);
+    const orig = require.cache[resolved];
+    require.cache[resolved] = { ...orig, exports };
+    return () => {
+        if (orig)
+            require.cache[resolved] = orig;
+        else
+            delete require.cache[resolved];
+    };
+}
+async function main() {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'v15-e2e-'));
+    process.env.OPENLIFE_STATE_DIR = path.join(tmp, '.openlife');
+    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;
+    delete process.env.OPENLIFE_GOVERNANCE_LEDGER;
+    try {
+        const SQUAD_TEMPLATE = path.resolve(__dirname, '..', 'dist-templates', 'squad-template');
+        const { SquadCreator } = require('./orchestrator/SquadCreator');
+        const sc = new SquadCreator({
+            catalogRoot: path.join(tmp, '.catalog', 'squads'),
+            templateRoot: SQUAD_TEMPLATE,
+        });
+        // ── Step 1: seed a squad ─────────────────────────────────────────
+        const seed = sc.create({
+            id: 'e2e-squad',
+            name: 'E2E Squad',
+            description: 'integration target',
+            version: '0.1.0',
+            status: 'draft',
+            agents: [{ id: 'lead', name: 'Lead', role: 'lead' }],
+        });
+        assertTrue(seed.ok, '[17.1] seed squad created');
+        console.log('[17.1] step 1: seed squad ✓');
+        // ── Step 2: persist a synthetic mission ──────────────────────────
+        const { MissionStateStore } = require('./orchestrator/MissionState');
+        const missionStore = new MissionStateStore();
+        const missionId = 'mission-e2e';
+        const mission = {
+            taskId: missionId,
+            userId: 'cli',
+            goal: 'audit the access ledger',
+            mode: 'task',
+            status: 'success',
+            plan: ['gather sources', 'cross-reference'],
+            successCriteria: ['evidence found', 'no gaps'],
+            reviewFindings: [{ approved: true, critique: 'looks good' }],
+            attempts: [],
+            chosenAgents: [],
+            chosenSquads: [],
+            chosenSkills: [],
+            routeMode: 'single',
+            memoryCandidates: [],
+            artifacts: [],
+            governanceEvents: [],
+            consequenceThoughtTrace: { snapshots: [{ note: 'analysed' }] },
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        missionStore.persist(mission);
+        console.log('[17.1] step 2: mission persisted ✓');
+        // ── Step 3: stubbed Brain → evaluation lands as source=brain ────
+        const restoreBrain = stubModule('./orchestrator/Brain', {
+            Brain: class {
+                isAnyProviderAvailable() { return true; }
+                async think() {
+                    return '{"score":91,"verdict":"ready_for_review","risks":["watch the redactor"],"rationale":"all criteria met"}';
+                }
+            },
+        });
+        try {
+            const { OrchestrationLoop } = require('./orchestrator/OrchestrationLoop');
+            const evaluateMission = OrchestrationLoop.prototype.evaluateMission;
+            const parseEvalJson = OrchestrationLoop.prototype.parseEvaluationJson;
+            await evaluateMission.call({ parseEvaluationJson: parseEvalJson }, mission);
+            const { MissionEvaluationStore } = require('./orchestrator/EnterpriseAgenticCore');
+            const evals = new MissionEvaluationStore().list();
+            assertTrue(evals.length === 1, '[17.1] one evaluation persisted');
+            assertTrue(evals[0].source === 'brain', '[17.1] source=brain landed');
+            assertTrue(evals[0].score === 91 && evals[0].verdict === 'ready_for_review', '[17.1] brain verdict landed');
+            console.log('[17.1] step 3: brain-driven evaluation persisted ✓');
+            // ── Step 4: eval list filter (Story 13.2) ──────────────────────
+            const readyFiltered = evals.filter((e) => e.verdict === 'ready_for_review');
+            assertTrue(readyFiltered.length === 1, '[17.1] eval list filter by verdict');
+            console.log('[17.1] step 4: eval list filter ✓');
+        }
+        finally {
+            restoreBrain();
+        }
+        // ── Step 5: squad migrate + extend + publish (v1.4 lifecycle) ────
+        const mig = sc.migrate('e2e-squad', '0.1.0', '1.0.0');
+        assertTrue(mig.ok, '[17.1] migrate ok');
+        const ext = sc.extend('e2e-squad', { kind: 'task', spec: { id: 'review', ownerAgentId: 'lead', purpose: 'gate' } });
+        assertTrue(ext.ok && ext.filesAdded?.length === 1, '[17.1] extend ok');
+        const pub = sc.publish('e2e-squad');
+        assertTrue(pub.ok && !!pub.sha256, '[17.1] local publish ok');
+        console.log('[17.1] step 5: squad migrate+extend+publish ✓');
+        // ── Step 6: remote publish via stubbed RemotePublisher ───────────
+        let remoteCalls = 0;
+        const restoreRemote = stubModule('./orchestrator/RemotePublisher', {
+            RemotePublisher: class {
+                async publishAsset(kind, id, sha256) {
+                    remoteCalls += 1;
+                    return { ok: true, url: `https://stub.example/${kind}/${id}/${sha256}.md`, status: 201 };
+                }
+            },
+        });
+        try {
+            const composed = await sc.publishWithRemote('e2e-squad');
+            assertTrue(composed.ok && composed.remote?.ok, '[17.1] composed publishWithRemote ok');
+            assertTrue(remoteCalls === 1, `[17.1] RemotePublisher invoked exactly once (got ${remoteCalls})`);
+        }
+        finally {
+            restoreRemote();
+        }
+        console.log('[17.1] step 6: remote publish composes with local ✓');
+        // ── Step 7: governance scope ledger (Story 14.2) ─────────────────
+        const { GovernanceLayer } = require('./orchestrator/GovernanceLayer');
+        const layer = new GovernanceLayer();
+        layer.evaluate('refactor the auth flow', 'e2e-project');
+        layer.evaluate('audit the access ledger', 'e2e-project');
+        const { GovernanceScopeLedger } = require('./orchestrator/GovernanceScopeLedger');
+        const ledger = new GovernanceScopeLedger();
+        const entries = ledger.read();
+        assertTrue(entries.length === 2, `[17.1] ledger has 2 entries (got ${entries.length})`);
+        const v = ledger.verify();
+        assertTrue(v.ok && v.entries === 2, '[17.1] ledger chain verifies');
+        console.log('[17.1] step 7: governance scope ledger verifies ✓');
+    }
+    finally {
+        delete process.env.OPENLIFE_STATE_DIR;
+        fs.rmSync(tmp, { recursive: true, force: true });
+    }
+    console.log('TEST_V15_E2E_INTEGRATION_OK');
+}
+main().catch((err) => {
+    console.error('[v15-e2e-integration] FAILED:', err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/dist/test_watchdog_heartbeat.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * test_watchdog_heartbeat — Story 6.6 regression suite.
+ *
+ * Three scenarios:
+ *   1. start() emits immediately and writes a fresh heartbeat file
+ *   2. periodic emission updates `ts` after intervalMs elapses
+ *   3. stop() halts emission; subsequent file mtime stays frozen
+ *
+ * Prints TEST_WATCHDOG_HEARTBEAT_OK on full pass.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const WatchdogHeartbeat_1 = require("./orchestrator/util/WatchdogHeartbeat");
+function assert(cond, msg) {
+    if (!cond)
+        throw new Error(`assertion failed: ${msg}`);
+}
+function mkTmp() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'wd-test-'));
+}
+function rmTmp(dir) {
+    try {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+    catch { /* ignore */ }
+}
+function read(filePath) {
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// ─────────────────────────────────────────────────────────────
+// Scenario 1 — start() emits immediately
+// ─────────────────────────────────────────────────────────────
+function scenarioStartImmediate() {
+    const tmp = mkTmp();
+    const filePath = path.join(tmp, 'heartbeat.json');
+    try {
+        const wd = new WatchdogHeartbeat_1.WatchdogHeartbeat({ filePath, intervalMs: 100_000, version: '1.2.0' });
+        wd.start();
+        assert(fs.existsSync(filePath), 'heartbeat file must exist immediately after start()');
+        const rec = read(filePath);
+        assert(rec.pid === process.pid, 'pid round-trip');
+        assert(typeof rec.ts === 'number' && rec.ts > 0, 'ts must be a positive ms epoch');
+        assert(rec.uptime_s >= 0, 'uptime_s must be non-negative');
+        assert(rec.version === '1.2.0', 'version round-trip');
+        wd.stop();
+        console.log('✅ scenario 1: start() emits immediately');
+    }
+    finally {
+        rmTmp(tmp);
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// Scenario 2 — periodic emission updates ts
+// ─────────────────────────────────────────────────────────────
+async function scenarioPeriodicEmission() {
+    const tmp = mkTmp();
+    const filePath = path.join(tmp, 'heartbeat.json');
+    try {
+        const wd = new WatchdogHeartbeat_1.WatchdogHeartbeat({ filePath, intervalMs: 50 });
+        wd.start();
+        const firstTs = read(filePath).ts;
+        await sleep(180); // wait ~3 intervals
+        const laterTs = read(filePath).ts;
+        assert(laterTs > firstTs, `ts must advance after interval: first=${firstTs}, later=${laterTs}`);
+        wd.stop();
+        console.log('✅ scenario 2: periodic emission updates ts');
+    }
+    finally {
+        rmTmp(tmp);
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// Scenario 3 — stop() halts emission
+// ─────────────────────────────────────────────────────────────
+async function scenarioStopHalts() {
+    const tmp = mkTmp();
+    const filePath = path.join(tmp, 'heartbeat.json');
+    try {
+        const wd = new WatchdogHeartbeat_1.WatchdogHeartbeat({ filePath, intervalMs: 50 });
+        wd.start();
+        await sleep(70);
+        const beforeStop = read(filePath).ts;
+        wd.stop();
+        await sleep(150); // would be 3 more intervals if still running
+        const afterStop = read(filePath).ts;
+        assert(afterStop === beforeStop, `ts must not change after stop(): before=${beforeStop}, after=${afterStop}`);
+        // Idempotent stop
+        wd.stop();
+        // Manual emit after stop still works (graceful-shutdown final beat use case)
+        wd.emit();
+        const manual = read(filePath).ts;
+        assert(manual >= afterStop, 'manual emit() after stop must succeed');
+        console.log('✅ scenario 3: stop() halts emission, emit() still callable');
+    }
+    finally {
+        rmTmp(tmp);
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// Driver
+// ─────────────────────────────────────────────────────────────
+async function main() {
+    console.log('🧪 test_watchdog_heartbeat — Story 6.6 regression suite');
+    scenarioStartImmediate();
+    await scenarioPeriodicEmission();
+    await scenarioStopHalts();
+    console.log('');
+    console.log('TEST_WATCHDOG_HEARTBEAT_OK');
+}
+main().catch((err) => {
+    console.error('❌ test_watchdog_heartbeat FAILED:', err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/dist/test_workflow_condition_parser.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * test_workflow_condition_parser.ts — Story 10.3
+ *
+ * Asserts the AND / OR / NOT / == / != boolean expression parser
+ * and its backward-compat with v1.2/v1.3 bare-identifier semantics.
+ *
+ * 10 scenarios.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const ConditionParser_1 = require("./orchestrator/workflow/ConditionParser");
+function assertTrue(cond, label) {
+    if (!cond)
+        throw new Error(`ASSERT_FAILED[${label}]`);
+}
+// 1. Backward-compat: bare identifier
+assertTrue((0, ConditionParser_1.evaluateCondition)('user_wants_ai', { user_wants_ai: true }) === true, '1: bare identifier truthy');
+assertTrue((0, ConditionParser_1.evaluateCondition)('user_wants_ai', { user_wants_ai: false }) === false, '1b: bare identifier false');
+console.log('[10.3] scenario 1 (bare identifier) ✓');
+// 2. AND
+assertTrue((0, ConditionParser_1.evaluateCondition)('a AND b', { a: true, b: true }) === true, '2a: a=t & b=t');
+assertTrue((0, ConditionParser_1.evaluateCondition)('a AND b', { a: true, b: false }) === false, '2b: a=t & b=f');
+console.log('[10.3] scenario 2 (AND) ✓');
+// 3. OR
+assertTrue((0, ConditionParser_1.evaluateCondition)('a OR b', { a: false, b: true }) === true, '3a: a=f | b=t');
+assertTrue((0, ConditionParser_1.evaluateCondition)('a OR b', { a: false, b: false }) === false, '3b: a=f | b=f');
+console.log('[10.3] scenario 3 (OR) ✓');
+// 4. NOT
+assertTrue((0, ConditionParser_1.evaluateCondition)('NOT a', { a: false }) === true, '4a: !false');
+assertTrue((0, ConditionParser_1.evaluateCondition)('NOT a', { a: true }) === false, '4b: !true');
+console.log('[10.3] scenario 4 (NOT) ✓');
+// 5. Equality with string literal
+assertTrue((0, ConditionParser_1.evaluateCondition)('mode == "elite"', { mode: 'elite' }) === true, '5: mode == elite');
+assertTrue((0, ConditionParser_1.evaluateCondition)('mode == "elite"', { mode: 'quick' }) === false, '5b: mode != elite');
+console.log('[10.3] scenario 5 (== string) ✓');
+// 6. Inequality with number
+assertTrue((0, ConditionParser_1.evaluateCondition)('score != 0', { score: 5 }) === true, '6: score != 0');
+assertTrue((0, ConditionParser_1.evaluateCondition)('score != 0', { score: 0 }) === false, '6b: score == 0');
+console.log('[10.3] scenario 6 (!= number) ✓');
+// 7. Parentheses + precedence
+// (a OR b) AND NOT c
+assertTrue((0, ConditionParser_1.evaluateCondition)('(a OR b) AND NOT c', { a: true, b: false, c: false }) === true, '7: precedence');
+assertTrue((0, ConditionParser_1.evaluateCondition)('(a OR b) AND NOT c', { a: true, b: false, c: true }) === false, '7b: precedence c=t');
+console.log('[10.3] scenario 7 (parentheses + precedence) ✓');
+// 8. Nested object access via dot
+assertTrue((0, ConditionParser_1.evaluateCondition)('user.is_admin', { user: { is_admin: true } }) === true, '8: nested truthy');
+assertTrue((0, ConditionParser_1.evaluateCondition)('user.role == "owner"', { user: { role: 'owner' } }) === true, '8b: nested ==');
+console.log('[10.3] scenario 8 (dotted identifier) ✓');
+// 9. Unknown variable defaults to false
+assertTrue((0, ConditionParser_1.evaluateCondition)('never_set', {}) === false, '9: unknown ident → false');
+assertTrue((0, ConditionParser_1.evaluateCondition)('a OR never_set', { a: true }) === true, '9b: unknown in OR');
+console.log('[10.3] scenario 9 (unknown var) ✓');
+// 10. Empty/invalid expressions
+assertTrue((0, ConditionParser_1.evaluateCondition)('', {}) === true, '10a: empty → true (no condition)');
+assertTrue((0, ConditionParser_1.evaluateCondition)(undefined, {}) === true, '10b: undefined → true');
+assertTrue((0, ConditionParser_1.evaluateCondition)('(((unbalanced', {}) === false, '10c: parse failure → false');
+console.log('[10.3] scenario 10 (empty + invalid) ✓');
+// 11. Parser direct API
+const p = (0, ConditionParser_1.parseCondition)('a AND (b OR NOT c)');
+assertTrue(p.ok && p.ast?.kind === 'and', '11: AST shape');
+assertTrue((0, ConditionParser_1.evaluate)(p.ast, { a: true, b: false, c: false }) === true, '11b: eval');
+console.log('[10.3] scenario 11 (parse API) ✓');
+console.log('TEST_WORKFLOW_CONDITION_PARSER_OK');