@a5c-ai/agent-platform 5.0.1-staging.b436b3b3e611

package/dist/daemon/daemonLog.d.ts

@@ -0,0 +1,13 @@
+/**
+ * GAP-REMOTE-001: Daemon JSONL logging.
+ *
+ * Appends structured JSON lines to a daemon activation log file.
+ */
+export interface DaemonLogEntry {
+    timestamp: string;
+    event: string;
+    data?: Record<string, unknown>;
+}
+export declare function appendDaemonLog(logDir: string, entry: DaemonLogEntry): Promise<void>;
+export declare function readDaemonLog(logDir: string): Promise<DaemonLogEntry[]>;
+//# sourceMappingURL=daemonLog.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"daemonLog.d.ts","sourceRoot":"","sources":["../../src/daemon/daemonLog.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED,wBAAsB,eAAe,CACnC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,cAAc,GACpB,OAAO,CAAC,IAAI,CAAC,CAKf;AAED,wBAAsB,aAAa,CACjC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,cAAc,EAAE,CAAC,CAY3B"}

package/dist/daemon/daemonLog.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * GAP-REMOTE-001: Daemon JSONL logging.
+ *
+ * Appends structured JSON lines to a daemon activation log file.
+ */
+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.appendDaemonLog = appendDaemonLog;
+exports.readDaemonLog = readDaemonLog;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+async function appendDaemonLog(logDir, entry) {
+    await node_fs_1.promises.mkdir(logDir, { recursive: true });
+    const logPath = path.join(logDir, "daemon.jsonl");
+    const line = JSON.stringify(entry) + "\n";
+    await node_fs_1.promises.appendFile(logPath, line, "utf-8");
+}
+async function readDaemonLog(logDir) {
+    const logPath = path.join(logDir, "daemon.jsonl");
+    try {
+        const content = await node_fs_1.promises.readFile(logPath, "utf-8");
+        return content
+            .trim()
+            .split("\n")
+            .filter((line) => line.trim())
+            .map((line) => JSON.parse(line));
+    }
+    catch {
+        return [];
+    }
+}

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;AAmDrF,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,iBAAiB,EAAE,EAC7B,SAAS,EAAE,eAAe,GACzB,iBAAiB,CA6DnB"}

package/dist/daemon/fileWatcher.js

@@ -0,0 +1,141 @@
+"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,
+        };
+        try {
+            entry.watcher = fsSync.watch(watchDir, { recursive: true }, (_eventType, filename) => {
+                if (disposed || !filename)
+                    return;
+                if (!matchesExtension(filename, trigger.pattern))
+                    return;
+                // 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,
+                    });
+                }, 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,7 @@
+/**
+ * Re-export shim — canonical implementation lives in @a5c-ai/agent-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, 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 TimerSchedulerHandle, type DaemonLoopOptions, type DaemonLoopStatus, type DaemonLogEntry, } from "@a5c-ai/agent-runtime/daemon";
+//# 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,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,oBAAoB,EACzB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,cAAc,GACpB,MAAM,8BAA8B,CAAC"}

package/dist/daemon/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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/agent-runtime.
+ * Internal agent-platform consumers continue to import via relative paths
+ * through this barrel file.
+ */
+var daemon_1 = require("@a5c-ai/agent-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; } });

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);
+    }
+}

package/dist/daemon/loop.d.ts

@@ -0,0 +1,21 @@
+/**
+ * GAP-REMOTE-001: Daemon Loop — main event loop with concurrent run pool.
+ */
+import type { DaemonConfig, TriggerCallback } from "./types";
+export interface DaemonLoopOptions {
+    onTrigger?: TriggerCallback;
+    signal?: AbortSignal;
+    logDir?: string;
+}
+export interface DaemonLoopStatus {
+    activeRuns: number;
+    pendingRuns: number;
+    updatedAt: string;
+}
+export declare function runDaemonLoop(config: DaemonConfig, options?: DaemonLoopOptions): Promise<void>;
+/**
+ * Read the daemon loop's runtime status from its status file.
+ * Returns null if the file doesn't exist or is unreadable.
+ */
+export declare function readDaemonLoopStatus(daemonDir: string): Promise<DaemonLoopStatus | null>;
+//# sourceMappingURL=loop.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/daemon/loop.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAgB,MAAM,SAAS,CAAC;AAY3E,MAAM,WAAW,iBAAiB;IAChC,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,wBAAsB,aAAa,CACjC,MAAM,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,IAAI,CAAC,CA+If;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAQ9F"}