@a5c-ai/agent-runtime 5.0.1-staging.04ca6ab00d21

package/dist/daemon/index.d.ts

@@ -0,0 +1,13 @@
+export { startDaemon, stopDaemon, getDaemonStatus } from "./lifecycle";
+export { loadDaemonConfig, writeDaemonConfig } from "./config";
+export { createFileWatcher } from "./fileWatcher";
+export { createWebhookListener } from "./webhookListener";
+export { createTimerScheduler } from "./timerScheduler";
+export { runDaemonLoop, readDaemonLoopStatus } from "./loop";
+export { appendDaemonLog, readDaemonLog } from "./daemonLog";
+export type { DaemonConfig, DaemonStartOptions, DaemonStartOutput, DaemonStopOptions, DaemonStopOutput, DaemonStatusOptions, DaemonStatusOutput, DaemonMetadata, TriggerConfig, TriggerEvent, FileTriggerEvent, AutomationTriggerEvent, FileTriggerConfig, FileWatcherHandle, WebhookListenerOptions, WebhookListenerHandle, TriggerCallback, } from "./types";
+export type { TimerSchedulerHandle } from "./timerScheduler";
+export type { DaemonLoopOptions, DaemonLoopStatus } from "./loop";
+export type { DaemonLogEntry } from "./daemonLog";
+export type { ApiResult } from "../apiResult";
+//# 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,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC7D,YAAY,EACV,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB,EAClB,cAAc,EACd,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,sBAAsB,EACtB,iBAAiB,EACjB,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACrB,eAAe,GAChB,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAC;AAClE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAGlD,YAAY,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC"}

package/dist/daemon/index.js

@@ -0,0 +1,22 @@
+"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;
+var lifecycle_1 = require("./lifecycle");
+Object.defineProperty(exports, "startDaemon", { enumerable: true, get: function () { return lifecycle_1.startDaemon; } });
+Object.defineProperty(exports, "stopDaemon", { enumerable: true, get: function () { return lifecycle_1.stopDaemon; } });
+Object.defineProperty(exports, "getDaemonStatus", { enumerable: true, get: function () { return lifecycle_1.getDaemonStatus; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "loadDaemonConfig", { enumerable: true, get: function () { return config_1.loadDaemonConfig; } });
+Object.defineProperty(exports, "writeDaemonConfig", { enumerable: true, get: function () { return config_1.writeDaemonConfig; } });
+var fileWatcher_1 = require("./fileWatcher");
+Object.defineProperty(exports, "createFileWatcher", { enumerable: true, get: function () { return fileWatcher_1.createFileWatcher; } });
+var webhookListener_1 = require("./webhookListener");
+Object.defineProperty(exports, "createWebhookListener", { enumerable: true, get: function () { return webhookListener_1.createWebhookListener; } });
+var timerScheduler_1 = require("./timerScheduler");
+Object.defineProperty(exports, "createTimerScheduler", { enumerable: true, get: function () { return timerScheduler_1.createTimerScheduler; } });
+var loop_1 = require("./loop");
+Object.defineProperty(exports, "runDaemonLoop", { enumerable: true, get: function () { return loop_1.runDaemonLoop; } });
+Object.defineProperty(exports, "readDaemonLoopStatus", { enumerable: true, get: function () { return loop_1.readDaemonLoopStatus; } });
+var daemonLog_1 = require("./daemonLog");
+Object.defineProperty(exports, "appendDaemonLog", { enumerable: true, get: function () { return daemonLog_1.appendDaemonLog; } });
+Object.defineProperty(exports, "readDaemonLog", { enumerable: true, get: function () { return daemonLog_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 "../apiResult";
+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,cAAc,CAAC;AAE9C,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 apiResult_1 = require("../apiResult");
+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, apiResult_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, apiResult_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, apiResult_1.ok)({
+            pid,
+            daemonDir,
+            startedAt,
+        });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, apiResult_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, apiResult_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, apiResult_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, apiResult_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, apiResult_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, apiResult_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, apiResult_1.ok)({ pid, stoppedAt: new Date().toISOString() });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, apiResult_1.fail)("INTERNAL_ERROR", msg);
+    }
+}
+// ── getDaemonStatus ─────────────────────────────────────────────────────────
+async function getDaemonStatus(options) {
+    try {
+        const { daemonDir } = options;
+        const pid = await readPidFile(daemonDir);
+        if (pid === null) {
+            return (0, apiResult_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, apiResult_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, apiResult_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, apiResult_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"}

package/dist/daemon/loop.js

@@ -0,0 +1,196 @@
+"use strict";
+/**
+ * GAP-REMOTE-001: Daemon Loop — main event loop with concurrent run pool.
+ */
+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.runDaemonLoop = runDaemonLoop;
+exports.readDaemonLoopStatus = readDaemonLoopStatus;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const types_1 = require("./types");
+const fileWatcher_1 = require("./fileWatcher");
+const webhookListener_1 = require("./webhookListener");
+const timerScheduler_1 = require("./timerScheduler");
+const daemonLog_1 = require("./daemonLog");
+async function runDaemonLoop(config, options) {
+    const maxConcurrent = config.maxConcurrentRuns ?? 4;
+    const handles = [];
+    const activeRuns = new Set();
+    const queue = [];
+    let statusWriteChain = Promise.resolve();
+    function scheduleStatusWrite() {
+        statusWriteChain = statusWriteChain.then(() => writeLoopStatus()).catch(() => {
+            // Status persistence is best-effort and must not surface as an
+            // unhandled rejection during trigger dispatch or shutdown races.
+        });
+    }
+    function drainQueue() {
+        while (queue.length > 0 && activeRuns.size < maxConcurrent) {
+            const next = queue.shift();
+            dispatchTrigger(next);
+        }
+        scheduleStatusWrite();
+    }
+    function dispatchTrigger(trigger) {
+        if (options?.onTrigger) {
+            const result = options.onTrigger(trigger);
+            // If onTrigger returns a Promise, track it for concurrency
+            if (result != null && typeof result.then === "function") {
+                const promise = result.then(() => {
+                    activeRuns.delete(promise);
+                    drainQueue();
+                }, () => {
+                    activeRuns.delete(promise);
+                    drainQueue();
+                });
+                activeRuns.add(promise);
+            }
+        }
+    }
+    async function writeLoopStatus() {
+        if (!options?.logDir)
+            return;
+        const statusPath = path.join(options.logDir, "daemon.status.json");
+        const status = {
+            activeRuns: activeRuns.size,
+            pendingRuns: queue.length,
+            updatedAt: new Date().toISOString(),
+        };
+        const tmpPath = `${statusPath}.tmp-${process.pid}-${Date.now()}`;
+        await node_fs_1.promises.writeFile(tmpPath, JSON.stringify(status), "utf-8");
+        await node_fs_1.promises.rename(tmpPath, statusPath);
+    }
+    const triggerCallback = (trigger) => {
+        // Log the activation
+        if (options?.logDir) {
+            const data = (0, types_1.isAutomationTriggerEvent)(trigger)
+                ? {
+                    type: "automation",
+                    ruleId: trigger.rule.id,
+                    triggerType: trigger.rule.trigger.type,
+                    projectId: trigger.rule.target.projectId,
+                    boardProjectId: trigger.rule.target.boardProjectId,
+                }
+                : {
+                    type: trigger.type,
+                    processId: trigger.processId,
+                    entrypoint: trigger.entrypoint,
+                };
+            void (0, daemonLog_1.appendDaemonLog)(options.logDir, {
+                timestamp: new Date().toISOString(),
+                event: "TRIGGER_ACTIVATED",
+                data,
+            }).catch(() => {
+                // Activation logging is best-effort and should never interrupt the loop.
+            });
+        }
+        if (activeRuns.size >= maxConcurrent) {
+            queue.push(trigger);
+            scheduleStatusWrite();
+            return;
+        }
+        dispatchTrigger(trigger);
+        scheduleStatusWrite();
+    };
+    // Set up file triggers
+    const fileTriggers = config.triggers
+        .filter(types_1.isFileTriggerConfig);
+    if (fileTriggers.length > 0) {
+        const handle = (0, fileWatcher_1.createFileWatcher)(fileTriggers, triggerCallback);
+        handles.push(handle);
+    }
+    // Set up webhook triggers
+    const webhookTriggers = config.triggers.filter(types_1.isWebhookAutomationRule);
+    for (const rule of webhookTriggers) {
+        try {
+            const handle = await (0, webhookListener_1.createWebhookListener)({
+                rule,
+                onTrigger: triggerCallback,
+            });
+            handles.push(handle);
+        }
+        catch {
+            // Port in use or other error — skip
+        }
+    }
+    // Set up timer/cron triggers
+    const timerTriggers = config.triggers.filter(types_1.isTimerAutomationRule);
+    if (timerTriggers.length > 0) {
+        const handle = (0, timerScheduler_1.createTimerScheduler)(timerTriggers, triggerCallback);
+        handles.push(handle);
+    }
+    // Wait for abort signal
+    if (options?.signal) {
+        await new Promise((resolve) => {
+            if (options.signal.aborted) {
+                resolve();
+                return;
+            }
+            options.signal.addEventListener("abort", () => resolve(), { once: true });
+        });
+    }
+    // Cleanup all handles
+    for (const handle of handles) {
+        if (handle.dispose)
+            handle.dispose();
+        if (handle.close)
+            await handle.close();
+    }
+    // Wait for active runs to finish
+    if (activeRuns.size > 0) {
+        await Promise.allSettled([...activeRuns]);
+    }
+    // Wait for any in-flight status writes then write final status
+    await statusWriteChain;
+    try {
+        await writeLoopStatus();
+    }
+    catch { /* directory may be gone in tests */ }
+}
+/**
+ * Read the daemon loop's runtime status from its status file.
+ * Returns null if the file doesn't exist or is unreadable.
+ */
+async function readDaemonLoopStatus(daemonDir) {
+    try {
+        const statusPath = path.join(daemonDir, "daemon.status.json");
+        const content = await node_fs_1.promises.readFile(statusPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/daemon/timerScheduler.d.ts

@@ -0,0 +1,13 @@
+/**
+ * GAP-REMOTE-001: Timer Scheduler — cron-expression-based trigger scheduling.
+ *
+ * Supports a subset of cron syntax: minute, hour, day-of-month, month, day-of-week.
+ * Uses setInterval to check the cron expression against current time.
+ */
+import type { TimerAutomationRule } from "@a5c-ai/agent-comm-mux";
+import type { TriggerCallback } from "./types";
+export interface TimerSchedulerHandle {
+    dispose(): void;
+}
+export declare function createTimerScheduler(triggers: TimerAutomationRule[], onTrigger: TriggerCallback): TimerSchedulerHandle;
+//# sourceMappingURL=timerScheduler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"timerScheduler.d.ts","sourceRoot":"","sources":["../../src/daemon/timerScheduler.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,MAAM,WAAW,oBAAoB;IACnC,OAAO,IAAI,IAAI,CAAC;CACjB;AAyFD,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,mBAAmB,EAAE,EAC/B,SAAS,EAAE,eAAe,GACzB,oBAAoB,CA6BtB"}

package/dist/daemon/timerScheduler.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * GAP-REMOTE-001: Timer Scheduler — cron-expression-based trigger scheduling.
+ *
+ * Supports a subset of cron syntax: minute, hour, day-of-month, month, day-of-week.
+ * Uses setInterval to check the cron expression against current time.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTimerScheduler = createTimerScheduler;
+/**
+ * Parse a simple 5-field cron expression into match arrays.
+ * Fields: minute hour day-of-month month day-of-week
+ * Supports: *, specific numbers, comma-separated values.
+ */
+function parseCronField(field, min, max) {
+    if (field === "*")
+        return null; // matches all
+    const values = [];
+    for (const part of field.split(",")) {
+        const trimmed = part.trim();
+        // Step syntax: */N or M-N/S
+        if (trimmed.includes("/")) {
+            const [rangeStr, stepStr] = trimmed.split("/");
+            const step = parseInt(stepStr, 10);
+            if (isNaN(step) || step <= 0)
+                return [];
+            let start = min;
+            let end = max;
+            if (rangeStr !== "*") {
+                if (rangeStr.includes("-")) {
+                    const [rMin, rMax] = rangeStr.split("-").map((s) => parseInt(s, 10));
+                    if (isNaN(rMin) || isNaN(rMax))
+                        return [];
+                    start = rMin;
+                    end = rMax;
+                }
+                else {
+                    start = parseInt(rangeStr, 10);
+                    if (isNaN(start))
+                        return [];
+                }
+            }
+            for (let i = start; i <= end; i += step) {
+                values.push(i);
+            }
+        }
+        // Range syntax: M-N
+        else if (trimmed.includes("-")) {
+            const [rMin, rMax] = trimmed.split("-").map((s) => parseInt(s, 10));
+            if (isNaN(rMin) || isNaN(rMax) || rMin < min || rMax > max)
+                return [];
+            for (let i = rMin; i <= rMax; i++) {
+                values.push(i);
+            }
+        }
+        // Simple number
+        else {
+            const num = parseInt(trimmed, 10);
+            if (isNaN(num) || num < min || num > max)
+                return [];
+            values.push(num);
+        }
+    }
+    return values.length > 0 ? values : [];
+}
+function parseCron(expression) {
+    const fields = expression.trim().split(/\s+/);
+    if (fields.length !== 5)
+        return null;
+    return {
+        minutes: parseCronField(fields[0], 0, 59),
+        hours: parseCronField(fields[1], 0, 23),
+        daysOfMonth: parseCronField(fields[2], 1, 31),
+        months: parseCronField(fields[3], 1, 12),
+        daysOfWeek: parseCronField(fields[4], 0, 6),
+    };
+}
+function matchesCron(parsed, date) {
+    const minute = date.getMinutes();
+    const hour = date.getHours();
+    const dayOfMonth = date.getDate();
+    const month = date.getMonth() + 1;
+    const dayOfWeek = date.getDay();
+    if (parsed.minutes && !parsed.minutes.includes(minute))
+        return false;
+    if (parsed.hours && !parsed.hours.includes(hour))
+        return false;
+    if (parsed.daysOfMonth && !parsed.daysOfMonth.includes(dayOfMonth))
+        return false;
+    if (parsed.months && !parsed.months.includes(month))
+        return false;
+    if (parsed.daysOfWeek && !parsed.daysOfWeek.includes(dayOfWeek))
+        return false;
+    return true;
+}
+function createTimerScheduler(triggers, onTrigger) {
+    const parsedTriggers = triggers
+        .map((t) => ({ trigger: t, parsed: parseCron(t.trigger.cron) }))
+        .filter((t) => t.parsed !== null);
+    let lastMinute = -1;
+    const interval = setInterval(() => {
+        const now = new Date();
+        const currentMinute = now.getMinutes() + now.getHours() * 60;
+        // Only check once per minute
+        if (currentMinute === lastMinute)
+            return;
+        lastMinute = currentMinute;
+        for (const { trigger, parsed } of parsedTriggers) {
+            if (matchesCron(parsed, now)) {
+                void onTrigger({
+                    type: "automation",
+                    rule: trigger,
+                });
+            }
+        }
+    }, 30_000); // Check every 30 seconds
+    return {
+        dispose() {
+            clearInterval(interval);
+        },
+    };
+}