@a5c-ai/genty-platform 5.1.1-staging.00ceebd28cf2

package/dist/daemon/durableQueue.js

@@ -0,0 +1,183 @@
+"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.DurableTriggerQueue = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const QUEUE_FILE = "trigger-queue.json";
+class DurableTriggerQueue {
+    filePath;
+    maxAttempts;
+    baseBackoffMs;
+    now;
+    events = [];
+    writeChain = Promise.resolve();
+    constructor(daemonDir, options) {
+        this.filePath = path.join(daemonDir, QUEUE_FILE);
+        this.maxAttempts = options?.maxAttempts ?? 3;
+        this.baseBackoffMs = options?.baseBackoffMs ?? 1_000;
+        this.now = options?.now ?? Date.now;
+    }
+    static async open(daemonDir, options) {
+        const queue = new DurableTriggerQueue(daemonDir, options);
+        await queue.load();
+        return queue;
+    }
+    async enqueue(trigger) {
+        const timestamp = new Date(this.now()).toISOString();
+        const record = {
+            id: (0, node_crypto_1.randomUUID)(),
+            trigger: redactTrigger(trigger),
+            state: "pending",
+            attempts: 0,
+            enqueuedAt: timestamp,
+            updatedAt: timestamp,
+        };
+        this.events.push(record);
+        await this.persist();
+        return { ...record };
+    }
+    async claimDue(limit = Number.POSITIVE_INFINITY) {
+        const now = this.now;
+        const timestamp = new Date(now()).toISOString();
+        const claimed = [];
+        for (const event of this.events) {
+            if (claimed.length >= limit)
+                break;
+            if (event.state !== "pending" && event.state !== "failed")
+                continue;
+            if (event.nextAttemptAt && Date.parse(event.nextAttemptAt) > now())
+                continue;
+            event.state = "running";
+            event.attempts += 1;
+            event.updatedAt = timestamp;
+            claimed.push({ ...event, trigger: cloneTrigger(event.trigger) });
+        }
+        if (claimed.length > 0) {
+            await this.persist();
+        }
+        return claimed;
+    }
+    async ack(id) {
+        const event = this.events.find((item) => item.id === id);
+        if (!event)
+            return;
+        const timestamp = new Date(this.now()).toISOString();
+        event.state = "succeeded";
+        event.ackedAt = timestamp;
+        event.updatedAt = timestamp;
+        await this.persist();
+    }
+    async fail(id, error) {
+        const event = this.events.find((item) => item.id === id);
+        if (!event || event.state === "succeeded")
+            return;
+        const timestamp = new Date(this.now()).toISOString();
+        event.lastError = error instanceof Error ? error.message : String(error);
+        event.updatedAt = timestamp;
+        if (event.attempts >= this.maxAttempts) {
+            event.state = "dead-letter";
+            delete event.nextAttemptAt;
+        }
+        else {
+            event.state = "failed";
+            const delay = this.baseBackoffMs * Math.max(1, 2 ** Math.max(0, event.attempts - 1));
+            event.nextAttemptAt = new Date(this.now() + delay).toISOString();
+        }
+        await this.persist();
+    }
+    async snapshot() {
+        return this.events.map((event) => ({ ...event, trigger: cloneTrigger(event.trigger) }));
+    }
+    counts() {
+        return {
+            active: this.events.filter((event) => event.state === "running").length,
+            pending: this.events.filter((event) => event.state === "pending" || event.state === "failed").length,
+            deadLetter: this.events.filter((event) => event.state === "dead-letter").length,
+        };
+    }
+    async load() {
+        try {
+            const raw = await node_fs_1.promises.readFile(this.filePath, "utf-8");
+            const parsed = JSON.parse(raw);
+            this.events = (parsed.events ?? []).map((event) => ({
+                ...event,
+                state: event.state === "running" ? "pending" : event.state,
+                trigger: cloneTrigger(event.trigger),
+            }));
+            if (this.events.some((event) => event.state === "pending" && event.updatedAt)) {
+                await this.persist();
+            }
+        }
+        catch {
+            this.events = [];
+        }
+    }
+    async persist() {
+        const content = JSON.stringify({ version: 1, events: this.events }, null, 2);
+        this.writeChain = this.writeChain.then(async () => {
+            await node_fs_1.promises.mkdir(path.dirname(this.filePath), { recursive: true });
+            const tmpPath = `${this.filePath}.tmp-${process.pid}-${Date.now()}`;
+            await node_fs_1.promises.writeFile(tmpPath, content, "utf-8");
+            await node_fs_1.promises.rename(tmpPath, this.filePath);
+        });
+        await this.writeChain;
+    }
+}
+exports.DurableTriggerQueue = DurableTriggerQueue;
+function cloneTrigger(trigger) {
+    return JSON.parse(JSON.stringify(trigger));
+}
+const SECRET_KEY_PATTERN = /(secret|token|api[-_]?key|authorization|password|credential|private[-_]?key)/i;
+function redactTrigger(trigger) {
+    return redactValue(cloneTrigger(trigger), "");
+}
+function redactValue(value, key) {
+    if (SECRET_KEY_PATTERN.test(key)) {
+        return "[REDACTED]";
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => redactValue(item, ""));
+    }
+    if (value && typeof value === "object") {
+        const result = {};
+        for (const [childKey, childValue] of Object.entries(value)) {
+            result[childKey] = redactValue(childValue, childKey);
+        }
+        return result;
+    }
+    return value;
+}

package/dist/daemon/fileWatcher.d.ts

@@ -0,0 +1,9 @@
+/**
+ * GAP-REMOTE-001: File Watcher — debounced fs.watch trigger.
+ *
+ * Watches directories for file changes matching glob patterns,
+ * firing trigger callbacks with configurable debounce.
+ */
+import type { FileTriggerConfig, FileWatcherHandle, TriggerCallback } from "./types";
+export declare function createFileWatcher(triggers: FileTriggerConfig[], onTrigger: TriggerCallback): FileWatcherHandle;
+//# sourceMappingURL=fileWatcher.d.ts.map

package/dist/daemon/fileWatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileWatcher.d.ts","sourceRoot":"","sources":["../../src/daemon/fileWatcher.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAoDrF,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,iBAAiB,EAAE,EAC7B,SAAS,EAAE,eAAe,GACzB,iBAAiB,CAgEnB"}

package/dist/daemon/fileWatcher.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * GAP-REMOTE-001: File Watcher — debounced fs.watch trigger.
+ *
+ * Watches directories for file changes matching glob patterns,
+ * firing trigger callbacks with configurable debounce.
+ */
+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.createFileWatcher = createFileWatcher;
+const fsSync = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const DEFAULT_DEBOUNCE_MS = 500;
+/**
+ * Extract the extension pattern from a glob (e.g., "**\/*.ts" -> ".ts").
+ * Returns null if no extension can be extracted.
+ */
+function extractExtension(pattern) {
+    const normalized = pattern.replace(/\\/g, "/");
+    // Match patterns like **/*.ts, **/*.test.ts, *.js
+    const match = normalized.match(/\*(\.[a-zA-Z0-9.]+)$/);
+    return match ? match[1] : null;
+}
+/**
+ * Check if a filename matches the pattern's file extension filter.
+ * This is a simplified matcher that works with common glob patterns like:
+ * - path/to/**\/*.ts  -> matches any .ts file under path/to/
+ * - path/to/**\/*.test.ts -> matches any .test.ts file under path/to/
+ */
+function matchesExtension(filename, pattern) {
+    const ext = extractExtension(pattern);
+    if (!ext)
+        return true; // No extension filter = match all
+    return filename.endsWith(ext);
+}
+/**
+ * Extract the base directory from a glob pattern (everything before the first glob segment).
+ */
+function getWatchDir(pattern) {
+    const normalized = pattern.replace(/\\/g, "/");
+    const parts = normalized.split("/");
+    const dirParts = [];
+    for (const part of parts) {
+        if (part.includes("*") || part.includes("?") || part.includes("{")) {
+            break;
+        }
+        dirParts.push(part);
+    }
+    return dirParts.join(path.sep) || ".";
+}
+function createFileWatcher(triggers, onTrigger) {
+    const entries = [];
+    let disposed = false;
+    for (const trigger of triggers) {
+        const watchDir = getWatchDir(trigger.pattern);
+        const debounceMs = trigger.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+        const entry = {
+            trigger,
+            watcher: null,
+            debounceTimer: null,
+            lastPath: null,
+        };
+        try {
+            entry.watcher = fsSync.watch(watchDir, { recursive: true }, (_eventType, filename) => {
+                if (disposed || !filename)
+                    return;
+                if (!matchesExtension(filename, trigger.pattern))
+                    return;
+                entry.lastPath = path.resolve(watchDir, filename.toString());
+                // Debounce: clear previous timer and set a new one
+                if (entry.debounceTimer) {
+                    clearTimeout(entry.debounceTimer);
+                }
+                entry.debounceTimer = setTimeout(() => {
+                    if (disposed)
+                        return;
+                    void onTrigger({
+                        type: "file",
+                        processId: trigger.processId,
+                        entrypoint: trigger.entrypoint,
+                        inputs: entry.lastPath ? { path: entry.lastPath } : undefined,
+                    });
+                }, debounceMs);
+            });
+            entry.watcher.on("error", () => {
+                if (entry.watcher) {
+                    entry.watcher.close();
+                    entry.watcher = null;
+                }
+            });
+        }
+        catch {
+            // Watch dir doesn't exist yet — skip
+        }
+        entries.push(entry);
+    }
+    return {
+        dispose() {
+            disposed = true;
+            for (const entry of entries) {
+                if (entry.debounceTimer) {
+                    clearTimeout(entry.debounceTimer);
+                    entry.debounceTimer = null;
+                }
+                if (entry.watcher) {
+                    entry.watcher.close();
+                    entry.watcher = null;
+                }
+            }
+        },
+    };
+}

package/dist/daemon/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Re-export shim — canonical implementation lives in @a5c-ai/genty-runtime.
+ * Internal agent-platform consumers continue to import via relative paths
+ * through this barrel file.
+ */
+export { startDaemon, stopDaemon, getDaemonStatus, loadDaemonConfig, writeDaemonConfig, createFileWatcher, createWebhookListener, createTimerScheduler, runDaemonLoop, readDaemonLoopStatus, appendDaemonLog, readDaemonLog, DurableTriggerQueue, type DaemonConfig, type DaemonStartOptions, type DaemonStartOutput, type DaemonStopOptions, type DaemonStopOutput, type DaemonStatusOptions, type DaemonStatusOutput, type DaemonMetadata, type TriggerConfig, type TriggerEvent, type FileTriggerEvent, type AutomationTriggerEvent, type FileTriggerConfig, type FileWatcherHandle, type WebhookListenerOptions, type WebhookListenerHandle, type TriggerCallback, type TriggerAdmissionConfig, type TriggerAdmissionResult, type TriggerAdmissionStatus, type TriggerRateLimitConfig, type TimerSchedulerHandle, type DaemonLoopOptions, type DaemonLoopStatus, type DaemonLogEntry, type DurableTriggerQueueOptions, type DurableTriggerRecord, type DurableTriggerState, } from "@a5c-ai/genty-runtime/daemon";
+export { executeAutomationTrigger } from "./automationExecutor";
+export { isAutomationTriggerEvent } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/daemon/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/daemon/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EACL,WAAW,EACX,UAAU,EACV,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACrB,oBAAoB,EACpB,aAAa,EACb,oBAAoB,EACpB,eAAe,EACf,aAAa,EACb,mBAAmB,EACnB,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC3B,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,0BAA0B,EAC/B,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,GACzB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC"}

package/dist/daemon/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAutomationTriggerEvent = exports.executeAutomationTrigger = exports.DurableTriggerQueue = exports.readDaemonLog = exports.appendDaemonLog = exports.readDaemonLoopStatus = exports.runDaemonLoop = exports.createTimerScheduler = exports.createWebhookListener = exports.createFileWatcher = exports.writeDaemonConfig = exports.loadDaemonConfig = exports.getDaemonStatus = exports.stopDaemon = exports.startDaemon = void 0;
+/**
+ * Re-export shim — canonical implementation lives in @a5c-ai/genty-runtime.
+ * Internal agent-platform consumers continue to import via relative paths
+ * through this barrel file.
+ */
+var daemon_1 = require("@a5c-ai/genty-runtime/daemon");
+Object.defineProperty(exports, "startDaemon", { enumerable: true, get: function () { return daemon_1.startDaemon; } });
+Object.defineProperty(exports, "stopDaemon", { enumerable: true, get: function () { return daemon_1.stopDaemon; } });
+Object.defineProperty(exports, "getDaemonStatus", { enumerable: true, get: function () { return daemon_1.getDaemonStatus; } });
+Object.defineProperty(exports, "loadDaemonConfig", { enumerable: true, get: function () { return daemon_1.loadDaemonConfig; } });
+Object.defineProperty(exports, "writeDaemonConfig", { enumerable: true, get: function () { return daemon_1.writeDaemonConfig; } });
+Object.defineProperty(exports, "createFileWatcher", { enumerable: true, get: function () { return daemon_1.createFileWatcher; } });
+Object.defineProperty(exports, "createWebhookListener", { enumerable: true, get: function () { return daemon_1.createWebhookListener; } });
+Object.defineProperty(exports, "createTimerScheduler", { enumerable: true, get: function () { return daemon_1.createTimerScheduler; } });
+Object.defineProperty(exports, "runDaemonLoop", { enumerable: true, get: function () { return daemon_1.runDaemonLoop; } });
+Object.defineProperty(exports, "readDaemonLoopStatus", { enumerable: true, get: function () { return daemon_1.readDaemonLoopStatus; } });
+Object.defineProperty(exports, "appendDaemonLog", { enumerable: true, get: function () { return daemon_1.appendDaemonLog; } });
+Object.defineProperty(exports, "readDaemonLog", { enumerable: true, get: function () { return daemon_1.readDaemonLog; } });
+Object.defineProperty(exports, "DurableTriggerQueue", { enumerable: true, get: function () { return daemon_1.DurableTriggerQueue; } });
+var automationExecutor_1 = require("./automationExecutor");
+Object.defineProperty(exports, "executeAutomationTrigger", { enumerable: true, get: function () { return automationExecutor_1.executeAutomationTrigger; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "isAutomationTriggerEvent", { enumerable: true, get: function () { return types_1.isAutomationTriggerEvent; } });

package/dist/daemon/lifecycle.d.ts

@@ -0,0 +1,12 @@
+/**
+ * GAP-REMOTE-001: Daemon Lifecycle — start/stop/status management.
+ *
+ * In foreground mode, the daemon runs in the current process (for dev/debug).
+ * In background mode, it spawns a detached child process.
+ */
+import type { ApiResult } from "../api/runs";
+import type { DaemonStartOptions, DaemonStartOutput, DaemonStopOptions, DaemonStopOutput, DaemonStatusOptions, DaemonStatusOutput } from "./types";
+export declare function startDaemon(options: DaemonStartOptions): Promise<ApiResult<DaemonStartOutput>>;
+export declare function stopDaemon(options: DaemonStopOptions): Promise<ApiResult<DaemonStopOutput>>;
+export declare function getDaemonStatus(options: DaemonStatusOptions): Promise<ApiResult<DaemonStatusOutput>>;
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/daemon/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../src/daemon/lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,KAAK,EACV,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB,EAEnB,MAAM,SAAS,CAAC;AAwDjB,wBAAsB,WAAW,CAC/B,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC,CAoEvC;AAID,wBAAsB,UAAU,CAC9B,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC,CAwEtC;AAID,wBAAsB,eAAe,CACnC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,SAAS,CAAC,kBAAkB,CAAC,CAAC,CAmCxC"}

package/dist/daemon/lifecycle.js

@@ -0,0 +1,257 @@
+"use strict";
+/**
+ * GAP-REMOTE-001: Daemon Lifecycle — start/stop/status management.
+ *
+ * In foreground mode, the daemon runs in the current process (for dev/debug).
+ * In background mode, it spawns a detached child process.
+ */
+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.startDaemon = startDaemon;
+exports.stopDaemon = stopDaemon;
+exports.getDaemonStatus = getDaemonStatus;
+const node_fs_1 = require("node:fs");
+const node_child_process_1 = require("node:child_process");
+const path = __importStar(require("node:path"));
+const utils_1 = require("../api/utils");
+const loop_1 = require("./loop");
+const daemonLog_1 = require("./daemonLog");
+const DEFAULT_GRACE_PERIOD_MS = 10_000;
+// ── Atomic write helper ─────────────────────────────────────────────────────
+async function atomicWrite(filePath, content) {
+    const dir = path.dirname(filePath);
+    await node_fs_1.promises.mkdir(dir, { recursive: true });
+    const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    await node_fs_1.promises.writeFile(tmpPath, content, "utf-8");
+    await node_fs_1.promises.rename(tmpPath, filePath);
+}
+// ── PID checking ────────────────────────────────────────────────────────────
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readPidFile(daemonDir) {
+    try {
+        const content = await node_fs_1.promises.readFile(path.join(daemonDir, "daemon.pid"), "utf-8");
+        const pid = parseInt(content.trim(), 10);
+        return isNaN(pid) ? null : pid;
+    }
+    catch {
+        return null;
+    }
+}
+async function readDaemonMetadata(daemonDir) {
+    try {
+        const content = await node_fs_1.promises.readFile(path.join(daemonDir, "daemon.json"), "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+async function cleanupDaemonFiles(daemonDir) {
+    await node_fs_1.promises.unlink(path.join(daemonDir, "daemon.pid")).catch(() => { });
+    await node_fs_1.promises.unlink(path.join(daemonDir, "daemon.json")).catch(() => { });
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// ── startDaemon ─────────────────────────────────────────────────────────────
+async function startDaemon(options) {
+    try {
+        const { daemonDir, workspace, foreground = false, config } = options;
+        // Check for existing daemon
+        const existingPid = await readPidFile(daemonDir);
+        if (existingPid !== null) {
+            if (isProcessAlive(existingPid)) {
+                return (0, utils_1.fail)("DAEMON_RUNNING", `Daemon already running with PID ${existingPid}`);
+            }
+            // Stale PID — clean up both files
+            await cleanupDaemonFiles(daemonDir);
+        }
+        await node_fs_1.promises.mkdir(daemonDir, { recursive: true });
+        let pid;
+        const startedAt = new Date().toISOString();
+        const maxConcurrentRuns = config?.maxConcurrentRuns ?? 4;
+        if (foreground) {
+            pid = process.pid;
+        }
+        else {
+            // Spawn detached child process running daemon:run
+            const child = (0, node_child_process_1.spawn)(process.execPath, [process.argv[1], "daemon:run", "--daemon-dir", daemonDir], {
+                detached: true,
+                stdio: "ignore",
+                cwd: workspace,
+            });
+            child.unref();
+            if (child.pid == null) {
+                return (0, utils_1.fail)("SPAWN_FAILED", "Failed to spawn daemon process — no PID returned");
+            }
+            pid = child.pid;
+        }
+        // Write PID file atomically
+        await atomicWrite(path.join(daemonDir, "daemon.pid"), String(pid));
+        // Write daemon.json metadata atomically
+        const metadata = {
+            workspace,
+            startedAt,
+            triggers: config?.triggers ?? [],
+            maxConcurrentRuns,
+            pid,
+        };
+        await atomicWrite(path.join(daemonDir, "daemon.json"), JSON.stringify(metadata, null, 2));
+        // Log daemon start
+        await (0, daemonLog_1.appendDaemonLog)(daemonDir, {
+            timestamp: startedAt,
+            event: "DAEMON_STARTED",
+            data: { pid, workspace, foreground },
+        });
+        return (0, utils_1.ok)({
+            pid,
+            daemonDir,
+            startedAt,
+        });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, utils_1.fail)("INTERNAL_ERROR", msg);
+    }
+}
+// ── stopDaemon ──────────────────────────────────────────────────────────────
+async function stopDaemon(options) {
+    try {
+        const { daemonDir, gracePeriodMs = DEFAULT_GRACE_PERIOD_MS } = options;
+        const pid = await readPidFile(daemonDir);
+        if (pid === null) {
+            return (0, utils_1.fail)("DAEMON_NOT_RUNNING", "No daemon PID file found");
+        }
+        const stoppedAt = new Date().toISOString();
+        if (!isProcessAlive(pid)) {
+            // PID exists but process is dead — clean up stale files
+            await cleanupDaemonFiles(daemonDir);
+            return (0, utils_1.ok)({ pid, stoppedAt });
+        }
+        // For foreground mode (same process), just clean up files
+        if (pid === process.pid) {
+            await cleanupDaemonFiles(daemonDir);
+            await (0, daemonLog_1.appendDaemonLog)(daemonDir, {
+                timestamp: stoppedAt,
+                event: "DAEMON_STOPPED",
+                data: { pid, reason: "foreground-stop" },
+            }).catch(() => { });
+            return (0, utils_1.ok)({ pid, stoppedAt });
+        }
+        // Send SIGTERM first
+        try {
+            process.kill(pid, "SIGTERM");
+        }
+        catch {
+            // Process may have exited between check and kill
+            await cleanupDaemonFiles(daemonDir);
+            return (0, utils_1.ok)({ pid, stoppedAt });
+        }
+        // Wait for graceful shutdown with polling
+        const pollInterval = 100;
+        const maxPolls = Math.ceil(gracePeriodMs / pollInterval);
+        for (let i = 0; i < maxPolls; i++) {
+            await sleep(pollInterval);
+            if (!isProcessAlive(pid)) {
+                await cleanupDaemonFiles(daemonDir);
+                await (0, daemonLog_1.appendDaemonLog)(daemonDir, {
+                    timestamp: new Date().toISOString(),
+                    event: "DAEMON_STOPPED",
+                    data: { pid, reason: "sigterm" },
+                }).catch(() => { });
+                return (0, utils_1.ok)({ pid, stoppedAt: new Date().toISOString() });
+            }
+        }
+        // Escalate to SIGKILL after grace period
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch {
+            // Already exited
+        }
+        await cleanupDaemonFiles(daemonDir);
+        await (0, daemonLog_1.appendDaemonLog)(daemonDir, {
+            timestamp: new Date().toISOString(),
+            event: "DAEMON_KILLED",
+            data: { pid, reason: "sigkill-after-grace-period", gracePeriodMs },
+        }).catch(() => { });
+        return (0, utils_1.ok)({ pid, stoppedAt: new Date().toISOString() });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, utils_1.fail)("INTERNAL_ERROR", msg);
+    }
+}
+// ── getDaemonStatus ─────────────────────────────────────────────────────────
+async function getDaemonStatus(options) {
+    try {
+        const { daemonDir } = options;
+        const pid = await readPidFile(daemonDir);
+        if (pid === null) {
+            return (0, utils_1.ok)({ running: false });
+        }
+        if (!isProcessAlive(pid)) {
+            // Stale PID — clean up
+            await node_fs_1.promises.unlink(path.join(daemonDir, "daemon.pid")).catch(() => { });
+            return (0, utils_1.ok)({ running: false });
+        }
+        const metadata = await readDaemonMetadata(daemonDir);
+        const startedAt = metadata?.startedAt;
+        const uptime = startedAt
+            ? Math.floor((Date.now() - new Date(startedAt).getTime()) / 1000)
+            : 0;
+        const loopStatus = await (0, loop_1.readDaemonLoopStatus)(daemonDir);
+        return (0, utils_1.ok)({
+            running: true,
+            pid,
+            uptime,
+            startedAt,
+            activeTriggers: metadata?.triggers?.length ?? 0,
+            pendingRuns: loopStatus?.pendingRuns ?? 0,
+        });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, utils_1.fail)("INTERNAL_ERROR", msg);
+    }
+}