@openlife/cli 1.7.3

package/dist/orchestrator/toolset/ToolsetSchema.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * ToolsetSchema — toolset categories + per-profile allow/deny lists.
+ *
+ * Story 5.3 — OpenLife v1.3 Agent OS Integration.
+ *
+ * A Toolset is a named category of tools an agent might want to use.
+ * Profiles allowlist toolsets; the runtime enforcement point (Gatekeeper)
+ * checks before dispatch.
+ *
+ * v1.3 ships the registry + decision API. Actual kernel-level
+ * enforcement of fs/bash inside executor sandboxes is v1.4.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_TOOLSETS = void 0;
+exports.ALL_TOOLSETS = [
+    'file', 'terminal', 'web', 'browser',
+    'memory', 'skills', 'workflows', 'squads',
+    'gateway', 'cron', 'delegation', 'mcp',
+    'vision', 'tts', 'image_gen',
+];

package/dist/orchestrator/util/AtomicWriter.js

@@ -0,0 +1,204 @@
+"use strict";
+/**
+ * AtomicWriter — crash-safe persistence helpers for OpenLife state files.
+ *
+ * Pattern:
+ *   1. Write payload to `<filePath>.tmp.<pid>.<ts>`
+ *   2. fsync the temp file (flush OS buffer to disk)
+ *   3. Atomically rename temp → final (single syscall on POSIX, MoveFileEx on Windows)
+ *   4. On any error: best-effort cleanup of temp file
+ *
+ * The rename step is atomic per the OS (POSIX rename(2), NTFS MoveFile), so a
+ * `kill -9` mid-operation leaves either the old file intact, or the fully new
+ * one. There is no partial-write window observable by other processes.
+ *
+ * Concurrency: each writer uses a unique temp suffix (`pid.ts.rand`), so
+ * multiple processes writing the same final path do not collide on the temp.
+ * The final rename is last-writer-wins, which is acceptable for our state
+ * files (the loser's data is discarded, not corrupted).
+ *
+ * Feature flag: `OPENLIFE_ATOMIC_WRITES=off` disables atomicity and falls
+ * back to plain writeFileSync / appendFileSync. Default is 'on'.
+ *
+ * Story 6.1 — OpenLife v1.2 Royal Stack.
+ */
+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.writeJsonAtomic = writeJsonAtomic;
+exports.writeStringAtomic = writeStringAtomic;
+exports.appendJsonlAtomic = appendJsonlAtomic;
+exports.appendStringAtomic = appendStringAtomic;
+exports.purgeStaleTempFiles = purgeStaleTempFiles;
+exports._isAtomicEnabled = _isAtomicEnabled;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ATOMIC_FLAG_ENV = 'OPENLIFE_ATOMIC_WRITES';
+function atomicEnabled() {
+    const v = (process.env[ATOMIC_FLAG_ENV] || 'on').toLowerCase();
+    return v !== 'off' && v !== '0' && v !== 'false';
+}
+function tempPath(filePath) {
+    const rand = Math.random().toString(36).slice(2, 8);
+    return `${filePath}.tmp.${process.pid}.${Date.now()}.${rand}`;
+}
+function fsyncFile(p) {
+    // writeFileSync does NOT fsync — we must open + fsync + close ourselves
+    // so the rename below sees a durable file on disk.
+    const fd = fs.openSync(p, 'r+');
+    try {
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/**
+ * Write a JSON-serializable object to `filePath` atomically.
+ *
+ * Writes pretty-printed JSON (2-space indent) followed by a trailing newline.
+ * Parent directory is created recursively if it does not exist.
+ */
+function writeJsonAtomic(filePath, obj) {
+    const payload = `${JSON.stringify(obj, null, 2)}\n`;
+    writeStringAtomic(filePath, payload);
+}
+/**
+ * Write a raw string to `filePath` atomically. Used by writeJsonAtomic
+ * internally; exported for callers that need control over serialization
+ * (e.g. markdown templates).
+ */
+function writeStringAtomic(filePath, content) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    if (!atomicEnabled()) {
+        fs.writeFileSync(filePath, content, 'utf-8');
+        return;
+    }
+    const tmp = tempPath(filePath);
+    try {
+        fs.writeFileSync(tmp, content, 'utf-8');
+        fsyncFile(tmp);
+        fs.renameSync(tmp, filePath);
+    }
+    catch (err) {
+        // Best-effort cleanup; ignore failures here, the original error is what matters
+        try {
+            if (fs.existsSync(tmp))
+                fs.unlinkSync(tmp);
+        }
+        catch {
+            /* swallow */
+        }
+        throw err;
+    }
+}
+/**
+ * Append one JSON object as a single line to a JSONL event log,
+ * atomically with respect to crash.
+ *
+ * Implementation reads the existing file into memory, appends the new line,
+ * and rewrites the whole file via the atomic temp+rename dance. This is
+ * O(n) per append; suitable for event logs that stay under a few MB
+ * (the typical case for `.openlife/*.jsonl` and `.artifacts/**\/events/*.jsonl`).
+ *
+ * For high-volume logs this becomes expensive; consider sharding or a
+ * dedicated append-with-lock implementation if hot paths emerge.
+ */
+function appendJsonlAtomic(filePath, obj) {
+    const line = `${JSON.stringify(obj)}\n`;
+    if (!atomicEnabled()) {
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        fs.appendFileSync(filePath, line, 'utf-8');
+        return;
+    }
+    const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '';
+    // Ensure existing content ends with a newline boundary before appending,
+    // so a previously truncated final line does not merge with our new entry.
+    const sep = existing.length === 0 || existing.endsWith('\n') ? '' : '\n';
+    writeStringAtomic(filePath, `${existing}${sep}${line}`);
+}
+/**
+ * Append a raw string (already-terminated line, no JSON wrapping) atomically.
+ * Used by callers that already control their own serialization format.
+ */
+function appendStringAtomic(filePath, line) {
+    if (!atomicEnabled()) {
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        fs.appendFileSync(filePath, line, 'utf-8');
+        return;
+    }
+    const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '';
+    writeStringAtomic(filePath, `${existing}${line}`);
+}
+/**
+ * Remove orphaned `.tmp.<pid>.<ts>.<rand>` files older than `olderThanMs`.
+ * Returns the count of files removed.
+ *
+ * Use during boot to clean up after a previous crash that left temp files
+ * lingering. Safe to call even when atomic writes are disabled — it only
+ * targets the `.tmp.<pid>.*` naming convention we control.
+ */
+function purgeStaleTempFiles(dir, olderThanMs) {
+    if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory())
+        return 0;
+    const cutoff = Date.now() - olderThanMs;
+    let removed = 0;
+    for (const entry of fs.readdirSync(dir)) {
+        if (!/\.tmp\.\d+\.\d+\.[a-z0-9]+$/i.test(entry))
+            continue;
+        const full = path.join(dir, entry);
+        try {
+            const st = fs.statSync(full);
+            if (st.mtimeMs < cutoff) {
+                fs.unlinkSync(full);
+                removed += 1;
+            }
+        }
+        catch {
+            /* race: file deleted by another process — ignore */
+        }
+    }
+    return removed;
+}
+/** Internal — exposed for tests so they can assert the flag wiring. */
+function _isAtomicEnabled() {
+    return atomicEnabled();
+}

package/dist/orchestrator/util/DistributedLock.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * DistributedLock — file-based cross-process lock with TTL + heartbeat.
+ *
+ * Story 6.4 — OpenLife v1.2 Royal Stack.
+ *
+ * Use case: prevent two OpenLife instances (e.g. dev + autonomous
+ * daemon) from running the same WorkflowEngine run or mission
+ * concurrently. The lock is a file under `<stateDir>/locks/<key>.lock`
+ * containing `{pid, host, lockId, ts, ttlMs}`. Crash safety: if the
+ * holder dies, the next contender sees a stale `ts` and can take over
+ * after `ttlMs` elapses (no manual unlock needed).
+ *
+ * Atomicity: lock creation uses `O_EXCL | O_CREAT` so two processes
+ * racing for the same key see exactly one winner. AtomicWriter is used
+ * for renewals.
+ */
+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.DistributedLock = void 0;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const AtomicWriter_1 = require("./AtomicWriter");
+class DistributedLock {
+    baseDir;
+    /** In-process registry of held locks, keyed by lockId. */
+    heldByLockId = new Map();
+    constructor(opts = {}) {
+        this.baseDir = opts.baseDir
+            || path.join(process.env.OPENLIFE_STATE_DIR || path.join(process.cwd(), '.openlife'), 'locks');
+    }
+    /**
+     * Attempt to acquire the lock for `key`. Succeeds if (a) no lock file
+     * exists, or (b) the existing lock has expired (ts + ttlMs <= now).
+     *
+     * If `startHeartbeat: true` (default true), the caller's lock TTL is
+     * auto-renewed at ttlMs/3 intervals via setInterval. Call release()
+     * to stop the heartbeat.
+     */
+    acquire(key, ttlMs, opts = {}) {
+        if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+            return { ok: false, error: 'io_error', message: 'ttlMs must be a positive number' };
+        }
+        this.ensureBaseDir();
+        const filePath = this.lockPath(key);
+        const lockId = this.newLockId();
+        const now = Date.now();
+        const record = {
+            pid: process.pid,
+            host: os.hostname(),
+            lockId,
+            key,
+            acquiredAt: now,
+            ts: now,
+            ttlMs,
+        };
+        // First attempt: exclusive create
+        try {
+            const fd = fs.openSync(filePath, 'wx');
+            try {
+                fs.writeFileSync(fd, JSON.stringify(record, null, 2), 'utf-8');
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            this.trackHeld(lockId, filePath, ttlMs, opts.startHeartbeat !== false);
+            return { ok: true, lockId, filePath };
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== 'EEXIST') {
+                return { ok: false, error: 'io_error', message: err instanceof Error ? err.message : String(err) };
+            }
+            // Lock file exists — check if it's expired
+        }
+        // Second attempt: takeover if existing lock is stale
+        const existing = this.readLock(filePath);
+        if (existing && now - existing.ts > existing.ttlMs) {
+            // Expired — overwrite atomically with our record
+            (0, AtomicWriter_1.writeJsonAtomic)(filePath, record);
+            this.trackHeld(lockId, filePath, ttlMs, opts.startHeartbeat !== false);
+            return { ok: true, lockId, filePath };
+        }
+        return { ok: false, error: 'collision', heldBy: existing ?? undefined };
+    }
+    /**
+     * Update the heartbeat (ts field) on a lock we hold. Returns true if
+     * the renewal succeeded (file still exists and our lockId is intact),
+     * false if the lock was stolen or removed.
+     */
+    renew(lockId) {
+        const tracked = this.heldByLockId.get(lockId);
+        if (!tracked)
+            return false;
+        const existing = this.readLock(tracked.filePath);
+        if (!existing || existing.lockId !== lockId) {
+            // Lock was stolen or removed — stop our heartbeat
+            this.stopHeartbeat(lockId);
+            return false;
+        }
+        existing.ts = Date.now();
+        try {
+            (0, AtomicWriter_1.writeJsonAtomic)(tracked.filePath, existing);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Release the lock we hold. Removes the lock file (if we still own it)
+     * and stops the heartbeat. Idempotent.
+     */
+    release(lockId) {
+        const tracked = this.heldByLockId.get(lockId);
+        if (!tracked)
+            return;
+        this.stopHeartbeat(lockId);
+        const existing = this.readLock(tracked.filePath);
+        if (existing && existing.lockId === lockId) {
+            try {
+                fs.unlinkSync(tracked.filePath);
+            }
+            catch { /* race or already gone */ }
+        }
+        this.heldByLockId.delete(lockId);
+    }
+    /**
+     * Inspect the current holder for `key` (or null if unlocked).
+     */
+    peek(key) {
+        return this.readLock(this.lockPath(key));
+    }
+    /**
+     * Release all locks currently held by this process. Useful for clean
+     * shutdown of a daemon.
+     */
+    releaseAll() {
+        for (const lockId of Array.from(this.heldByLockId.keys())) {
+            this.release(lockId);
+        }
+    }
+    // ─────────────────────────────────────────────────────────
+    // Internals
+    // ─────────────────────────────────────────────────────────
+    trackHeld(lockId, filePath, ttlMs, startHeartbeat) {
+        let heartbeat = null;
+        if (startHeartbeat) {
+            const interval = Math.max(50, Math.floor(ttlMs / 3));
+            heartbeat = setInterval(() => {
+                this.renew(lockId);
+            }, interval);
+            // Don't keep the process alive just for the heartbeat
+            if (typeof heartbeat.unref === 'function')
+                heartbeat.unref();
+        }
+        this.heldByLockId.set(lockId, { filePath, heartbeat });
+    }
+    stopHeartbeat(lockId) {
+        const tracked = this.heldByLockId.get(lockId);
+        if (tracked?.heartbeat) {
+            clearInterval(tracked.heartbeat);
+            tracked.heartbeat = null;
+        }
+    }
+    readLock(filePath) {
+        if (!fs.existsSync(filePath))
+            return null;
+        try {
+            const raw = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            if (typeof raw?.lockId === 'string' && typeof raw?.ts === 'number')
+                return raw;
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    ensureBaseDir() {
+        if (!fs.existsSync(this.baseDir)) {
+            fs.mkdirSync(this.baseDir, { recursive: true });
+        }
+    }
+    lockPath(key) {
+        return path.join(this.baseDir, `${this.sanitize(key)}.lock`);
+    }
+    sanitize(key) {
+        return key.replace(/[^a-zA-Z0-9._-]/g, '_');
+    }
+    newLockId() {
+        return `${process.pid}-${Date.now().toString(36)}-${crypto.randomBytes(4).toString('hex')}`;
+    }
+    /** Exposed for tests so they can assert resolved storage location. */
+    _baseDir() {
+        return this.baseDir;
+    }
+}
+exports.DistributedLock = DistributedLock;

package/dist/orchestrator/util/TemplateRenderer.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * TemplateRenderer — minimalist {{VAR}} substitution.
+ *
+ * Story 5.1 — OpenLife v1.2 Royal Stack.
+ *
+ * Zero external dependencies. Replaces `{{VAR}}` tokens with literal
+ * string values from a flat object. Unknown variables are left in place
+ * (so missing vars are visible in output rather than silently empty).
+ *
+ * NOT a templating engine — no conditionals, loops, or HTML escaping.
+ * If those become needed in v1.3, swap to Handlebars at this same
+ * surface.
+ *
+ * Use case: SquadCreator / SkillCreator render `dist-templates/{squad,
+ * skill}-template/` markdown files with operator-supplied values.
+ */
+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.renderTemplate = renderTemplate;
+exports.renderTemplateFile = renderTemplateFile;
+exports.listTemplateVars = listTemplateVars;
+const fs = __importStar(require("fs"));
+/**
+ * Render a template string by substituting `{{VAR}}` tokens. Unknown
+ * tokens are returned verbatim (intentional — surfaces missing vars).
+ */
+function renderTemplate(template, vars) {
+    return template.replace(/\{\{([A-Z_][A-Z0-9_]*)\}\}/g, (match, name) => {
+        return Object.prototype.hasOwnProperty.call(vars, name) ? vars[name] : match;
+    });
+}
+/**
+ * Render a template file from disk. Throws if the source file does not
+ * exist (caller is expected to verify dist-templates layout up-front).
+ */
+function renderTemplateFile(filePath, vars) {
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`template not found: ${filePath}`);
+    }
+    return renderTemplate(fs.readFileSync(filePath, 'utf-8'), vars);
+}
+/**
+ * Inspect a template for required variables — returns the sorted list of
+ * unique `{{VAR}}` tokens. Useful for tooling that wants to surface
+ * "missing required variables" before render.
+ */
+function listTemplateVars(template) {
+    const found = new Set();
+    template.replace(/\{\{([A-Z_][A-Z0-9_]*)\}\}/g, (_, name) => {
+        found.add(name);
+        return '';
+    });
+    return Array.from(found).sort();
+}

package/dist/orchestrator/util/WatchdogHeartbeat.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * WatchdogHeartbeat — periodic liveness signal for external supervisors.
+ *
+ * Story 6.6 — OpenLife v1.2 Royal Stack.
+ *
+ * The daemon emits a heartbeat file every `intervalMs` so an external
+ * supervisor (systemd `WatchdogSec=`, supervisord `eventlistener`, k8s
+ * livenessProbe via a file mtime check) can detect hangs even when the
+ * HTTP `/health` endpoint becomes unresponsive (e.g. event-loop block).
+ *
+ * Format: `.openlife/heartbeat.json` with `{ pid, host, ts, uptime_s,
+ * startedAt }`. ts is updated atomically each tick so a torn read is
+ * impossible.
+ */
+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.WatchdogHeartbeat = void 0;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const AtomicWriter_1 = require("./AtomicWriter");
+class WatchdogHeartbeat {
+    filePath;
+    intervalMs;
+    startedAt;
+    version;
+    timer = null;
+    constructor(opts = {}) {
+        const stateDir = process.env.OPENLIFE_STATE_DIR || path.join(process.cwd(), '.openlife');
+        this.filePath = opts.filePath || path.join(stateDir, 'heartbeat.json');
+        this.intervalMs = opts.intervalMs ?? 30_000;
+        this.startedAt = Date.now();
+        this.version = opts.version;
+    }
+    /**
+     * Emit one heartbeat immediately and schedule periodic re-emission.
+     * Idempotent: calling start() while already running is a no-op.
+     */
+    start() {
+        if (this.timer)
+            return;
+        this.emit(); // immediate tick so external supervisor sees freshness on boot
+        this.timer = setInterval(() => {
+            try {
+                this.emit();
+            }
+            catch { /* swallow — best-effort writes */ }
+        }, this.intervalMs);
+        if (typeof this.timer.unref === 'function')
+            this.timer.unref();
+    }
+    /**
+     * Stop emitting heartbeats. Idempotent. Does not delete the heartbeat
+     * file (so post-shutdown the supervisor still sees the last known
+     * good ts; staleness is the supervisor's signal that we are down).
+     */
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    /**
+     * Force-emit one heartbeat now (used by tests and graceful shutdown).
+     */
+    emit() {
+        const now = Date.now();
+        const rec = {
+            pid: process.pid,
+            host: os.hostname(),
+            ts: now,
+            uptime_s: Math.floor((now - this.startedAt) / 1000),
+            startedAt: this.startedAt,
+            version: this.version,
+        };
+        (0, AtomicWriter_1.writeJsonAtomic)(this.filePath, rec);
+        return rec;
+    }
+    /** Exposed for tests. */
+    _filePath() {
+        return this.filePath;
+    }
+}
+exports.WatchdogHeartbeat = WatchdogHeartbeat;