@plainconceptsplatform/loop-task 2.6.0

package/dist/daemon/http/sse.js

@@ -0,0 +1,36 @@
+export class SseClientSet {
+    constructor() {
+        this.clients = new Set();
+    }
+    add(res) {
+        this.clients.add(res);
+    }
+    delete(res) {
+        this.clients.delete(res);
+    }
+    destroyAll() {
+        for (const client of this.clients) {
+            client.destroy();
+        }
+        this.clients.clear();
+    }
+    broadcast(event, data) {
+        const payload = `event: ${event}\ndata: ${JSON.stringify(data ?? {})}\n\n`;
+        for (const client of this.clients) {
+            try {
+                client.write(payload);
+            }
+            catch {
+                this.clients.delete(client);
+            }
+        }
+    }
+}
+export function initSseResponse(res) {
+    res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+    });
+    res.write(": connected\n\n");
+}

package/dist/daemon/index.js

@@ -0,0 +1,189 @@
+import { LoopManager } from "./managers/loop-manager.js";
+import { TaskManager } from "./managers/task-manager.js";
+import { IpcServer } from "./server/index.js";
+import { HttpApiServer } from "./http/server.js";
+import { McpApiServer } from "./mcp/index.js";
+import { FileWatcher } from "./watcher/index.js";
+import { SettingsManager } from "./settings-manager.js";
+import { writeDaemonPid, removeDaemonPid, writeDaemonSignature, removeDaemonSignature, computeCodeSignature, migrateTasksToJson, migrateLoopsToJson, setSelfWriteNotifier, readDaemonPid, isDaemonAlive, } from "./state/index.js";
+import { setProjectSelfWriteNotifier } from "./managers/project-manager.js";
+import { t } from "../shared/i18n/index.js";
+import { daemonLog } from "./daemon-log.js";
+import { killAllActiveProcesses, getActivePids } from "../core/command/command-runner.js";
+import { setActivePidsGetter } from "./diagnostics.js";
+import { RecipeScanner } from "./recipe/scanner.js";
+import { RecipeTaskStore } from "./recipe/task-store.js";
+import { DeferredReloadManager } from "./recipe/deferred-reload.js";
+import { setRecipeSelfWriteNotifier } from "./recipe/file-writer.js";
+import { TelemetryManager } from "./telemetry/index.js";
+import path from "node:path";
+function cleanupStaleProcesses() {
+    const oldPid = readDaemonPid();
+    if (oldPid !== null && !isDaemonAlive(oldPid)) {
+        daemonLog(`previous daemon pid=${oldPid} is not running; child processes may be orphaned`);
+    }
+}
+async function main() {
+    const mcpEnabled = (process.env.LOOP_CLI_MCP_ENABLED ?? "true") !== "false";
+    const mcpTransport = process.env.LOOP_CLI_MCP_TRANSPORT === "stdio" ? "stdio" : "sse";
+    const taskManager = new TaskManager();
+    setActivePidsGetter(getActivePids);
+    migrateLoopsToJson();
+    migrateTasksToJson();
+    taskManager.init();
+    const manager = new LoopManager(taskManager);
+    const settingsManager = new SettingsManager();
+    settingsManager.load();
+    const telemetryManager = new TelemetryManager(settingsManager.get());
+    manager.setTelemetryManager(telemetryManager);
+    const server = new IpcServer(manager, taskManager, settingsManager, telemetryManager);
+    const projectManager = manager.projectManager;
+    const httpServer = new HttpApiServer(manager, taskManager, projectManager, settingsManager);
+    const mcpServer = new McpApiServer(manager, taskManager, projectManager, mcpTransport);
+    try {
+        await server.listen();
+    }
+    catch (err) {
+        daemonLog(`listen failed (another daemon already holds the socket): ${String(err)}`);
+        process.exit(0);
+    }
+    const httpPort = parseInt(process.env.LOOP_CLI_HTTP_PORT ?? "", 10);
+    const resolvedHttpPort = Number.isNaN(httpPort) ? undefined : httpPort;
+    let currentHttpHost = settingsManager.get().httpApiHost;
+    if (settingsManager.get().httpApiEnabled) {
+        try {
+            await httpServer.listen(resolvedHttpPort, currentHttpHost);
+        }
+        catch (err) {
+            daemonLog(`HTTP API server failed to start: ${String(err)}`);
+        }
+    }
+    mcpServer.setHost(currentHttpHost);
+    if (mcpEnabled) {
+        try {
+            await mcpServer.start();
+        }
+        catch (err) {
+            daemonLog(`MCP server failed to start: ${String(err)}`);
+        }
+    }
+    settingsManager.onChange((settings) => {
+        const newHost = settings.httpApiHost;
+        const hostChanged = newHost !== currentHttpHost;
+        // HTTP API (8845)
+        if (settings.httpApiEnabled && !httpServer["isListening"]) {
+            httpServer.listen(resolvedHttpPort, newHost).catch((err) => {
+                daemonLog(`HTTP API server failed to restart: ${String(err)}`);
+            });
+        }
+        else if (settings.httpApiEnabled && httpServer["isListening"] && hostChanged) {
+            httpServer.restart(resolvedHttpPort, newHost).catch((err) => {
+                daemonLog(`HTTP API server failed to rebind to ${newHost}: ${String(err)}`);
+            });
+        }
+        else if (!settings.httpApiEnabled && httpServer["isListening"]) {
+            httpServer.close().catch((err) => {
+                daemonLog(`HTTP API server failed to stop: ${String(err)}`);
+            });
+        }
+        // MCP SSE (8846) — shares the same bind host as the HTTP API.
+        mcpServer.setHost(newHost);
+        if (settings.mcpApiEnabled && !mcpServer.isListening) {
+            mcpServer.start().catch((err) => {
+                daemonLog(`MCP server failed to restart: ${String(err)}`);
+            });
+        }
+        else if (settings.mcpApiEnabled && mcpServer.isListening && hostChanged) {
+            mcpServer
+                .close()
+                .then(() => mcpServer.start())
+                .catch((err) => {
+                daemonLog(`MCP server failed to rebind to ${newHost}: ${String(err)}`);
+            });
+        }
+        else if (!settings.mcpApiEnabled && mcpServer.isListening) {
+            mcpServer.close().catch((err) => {
+                daemonLog(`MCP server failed to stop: ${String(err)}`);
+            });
+        }
+        // Telemetry runtime reconfiguration
+        telemetryManager.onSettingsChanged(settings);
+        currentHttpHost = newHost;
+    });
+    manager.init();
+    // Recipe loop infrastructure
+    const recipeTaskStore = new RecipeTaskStore();
+    taskManager.setRecipeTaskStore(recipeTaskStore);
+    const recipeScanner = new RecipeScanner(recipeTaskStore);
+    const deferredReload = new DeferredReloadManager(recipeScanner);
+    recipeScanner.setManagers(manager, manager["projectManager"]);
+    manager.setRecipeScanner(recipeScanner);
+    // Set up project directory change callback for recipe reloading
+    manager["projectManager"].setOnDirectoryChange((projectId, _oldDirectory, newDirectory) => {
+        recipeScanner.unloadRecipesForProject(projectId);
+        if (newDirectory) {
+            recipeScanner.scanDirectory(projectId, newDirectory);
+            fileWatcher.watchRecipeDirectory(projectId, path.join(newDirectory, ".loops/recipes"));
+        }
+    });
+    cleanupStaleProcesses();
+    writeDaemonPid(process.pid);
+    writeDaemonSignature(computeCodeSignature());
+    daemonLog(`started pid=${process.pid}`);
+    const fileWatcher = new FileWatcher();
+    fileWatcher.setManagers(manager, taskManager, manager["projectManager"]);
+    fileWatcher.start();
+    daemonLog(`file watcher started for hot-reloading JSON configs`);
+    setSelfWriteNotifier((filePath, content) => fileWatcher.registerSelfWrite(filePath, content));
+    setProjectSelfWriteNotifier((filePath, content) => fileWatcher.registerSelfWrite(filePath, content));
+    setRecipeSelfWriteNotifier((filePath, content) => fileWatcher.registerSelfWrite(filePath, content));
+    // Scan all project directories for recipe files
+    recipeScanner.scanAllProjects();
+    fileWatcher.setRecipeScanner(recipeScanner, deferredReload);
+    // Watch recipe directories for each project
+    for (const project of manager.listProjects()) {
+        if (project.directory) {
+            const recipesDir = path.join(project.directory, ".loops/recipes");
+            fileWatcher.watchRecipeDirectory(project.id, recipesDir);
+        }
+    }
+    // Reconcile after watchers are attached so files created during startup cannot be missed.
+    recipeScanner.scanAllProjects();
+    daemonLog(`recipe scanner initialized`);
+    let shuttingDown = false;
+    const cleanup = async () => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        daemonLog(`shutting down pid=${process.pid}`);
+        try {
+            killAllActiveProcesses();
+            await telemetryManager.shutdown();
+            fileWatcher.stop();
+            removeDaemonPid();
+            removeDaemonSignature();
+            await manager.shutdown();
+            await server.close();
+            await httpServer.close();
+            await mcpServer.close();
+        }
+        catch (err) {
+            daemonLog(`error during shutdown: ${String(err)}`);
+        }
+        finally {
+            process.exit(0);
+        }
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    process.on("uncaughtException", (err) => {
+        daemonLog(`uncaught exception: ${String(err)}`);
+        console.error(t("errors.daemonUncaught"), err);
+        void cleanup();
+    });
+}
+main().catch((err) => {
+    daemonLog(`failed to start: ${String(err)}`);
+    console.error(t("errors.daemonFailed"), err);
+    process.exit(1);
+});

package/dist/daemon/ipc/send.js

@@ -0,0 +1,5 @@
+export function send(socket, message) {
+    if (!socket.destroyed) {
+        socket.write(JSON.stringify(message) + "\n");
+    }
+}

package/dist/daemon/managers/loop-entry.js

@@ -0,0 +1,27 @@
+import { LoopController } from "../../core/loop/loop-controller.js";
+import { getLogPath } from "../state/index.js";
+import { buildLoopOptions } from "./loop-options.js";
+export function createLoopEntry(meta, taskResolver, getProjectDirectory, state, telemetryManager) {
+    const options = buildLoopOptions(meta);
+    const logPath = getLogPath(meta.id);
+    const projectDir = getProjectDirectory(options.projectId ?? "default");
+    const controller = new LoopController(meta.id, options, logPath, taskResolver, state, projectDir, telemetryManager);
+    return { controller, options, intervalHuman: meta.intervalHuman };
+}
+export function metaToState(meta) {
+    return {
+        status: meta.status,
+        createdAt: meta.createdAt,
+        runCount: meta.runCount,
+        sessionStartedAt: meta.sessionStartedAt,
+        lastRunAt: meta.lastRunAt,
+        lastExitCode: meta.lastExitCode,
+        lastDuration: meta.lastDuration,
+        nextRunAt: meta.nextRunAt,
+        remainingDelayMs: meta.remainingDelayMs,
+        runHistory: meta.runHistory,
+        skippedCount: meta.skippedCount,
+        silentChainCount: meta.silentChainCount,
+        totalRunCount: meta.totalRunCount,
+    };
+}

package/dist/daemon/managers/loop-manager.js

@@ -0,0 +1,346 @@
+import crypto from "node:crypto";
+import { LoopController } from "../../core/loop/loop-controller.js";
+import { ProjectManager } from "./project-manager.js";
+import { saveLoop, loadAllLoops, deleteLoop as deleteLoopState, getLogPath, } from "../state/index.js";
+import { daemonLog } from "../daemon-log.js";
+import { createLoopEntry, metaToState } from "./loop-entry.js";
+import { wireEvents, persistLoop, buildMeta, buildRecipeMeta } from "./loop-serialization.js";
+import { writeRecipeOverrides } from "../recipe/file-writer.js";
+export class LoopManager {
+    constructor(taskManager, projectManager) {
+        this.loops = new Map();
+        this.recipes = new Map();
+        this.recipeMeta = new Map();
+        this.lastSerialized = new Map();
+        this.recipeScanner = null;
+        this.telemetryManager = null;
+        this.taskResolver = (taskId) => this.taskManager.get(taskId);
+        this.taskManager = taskManager;
+        this.projectManager = projectManager || new ProjectManager();
+    }
+    setTelemetryManager(mgr) {
+        this.telemetryManager = mgr;
+    }
+    setRecipeScanner(scanner) {
+        this.recipeScanner = scanner;
+    }
+    getProjectDirectory(projectId) {
+        return this.projectManager.get(projectId)?.directory;
+    }
+    persist(id, controller, options, intervalHuman) {
+        persistLoop(id, controller, options, intervalHuman, this.taskManager, this.lastSerialized);
+    }
+    wireUp(id, entry) {
+        wireEvents(id, entry.controller, entry.options, entry.intervalHuman, () => this.persist(id, entry.controller, entry.options, entry.intervalHuman));
+    }
+    init() {
+        this.projectManager.init();
+        const saved = loadAllLoops();
+        let restarted = 0;
+        const shouldAutoStart = (s) => s !== "idle";
+        for (const meta of saved) {
+            if (!meta.projectId) {
+                meta.projectId = "default";
+                saveLoop(meta);
+            }
+            const entry = createLoopEntry(meta, this.taskResolver, this.getProjectDirectory.bind(this), metaToState(meta), this.telemetryManager ?? undefined);
+            this.loops.set(meta.id, entry);
+            this.wireUp(meta.id, entry);
+            if (shouldAutoStart(meta.status)) {
+                entry.controller.start();
+                restarted += 1;
+            }
+        }
+        if (restarted > 0) {
+            daemonLog(`restarted ${restarted} loop(s) from persisted state`);
+        }
+    }
+    start(options, intervalHuman) {
+        const id = crypto.randomUUID().slice(0, 8);
+        const logPath = getLogPath(id);
+        const projectDir = this.getProjectDirectory(options.projectId ?? "default");
+        const controller = new LoopController(id, options, logPath, this.taskResolver, undefined, projectDir, this.telemetryManager ?? undefined);
+        const entry = { controller, options, intervalHuman };
+        this.loops.set(id, entry);
+        controller.start();
+        this.wireUp(id, entry);
+        this.persist(id, controller, options, intervalHuman);
+        return id;
+    }
+    async update(id, options, intervalHuman) {
+        const recipeEntry = this.recipes.get(id);
+        if (recipeEntry) {
+            return this.updateRecipe(id, options, intervalHuman, recipeEntry);
+        }
+        const entry = this.loops.get(id);
+        if (!entry)
+            return false;
+        const executionChanged = entry.options.interval !== options.interval ||
+            entry.options.taskId !== options.taskId ||
+            entry.options.command !== options.command ||
+            entry.options.commandArgs.join(" ") !== options.commandArgs.join(" ") ||
+            entry.options.immediate !== options.immediate ||
+            entry.options.maxRuns !== options.maxRuns ||
+            entry.options.verbose !== options.verbose;
+        const maxRunsChanged = entry.options.maxRuns !== options.maxRuns;
+        Object.assign(entry.options, options);
+        entry.intervalHuman = intervalHuman;
+        if (maxRunsChanged) {
+            entry.controller.clearMaxRunsReached();
+        }
+        if (entry.controller.status === "running") {
+            entry.controller.pause(true);
+        }
+        else if (executionChanged && entry.controller.status !== "paused" && entry.controller.status !== "idle") {
+            entry.controller.pause();
+        }
+        this.persist(id, entry.controller, entry.options, entry.intervalHuman);
+        return true;
+    }
+    updateRecipe(id, options, intervalHuman, entry) {
+        if (options.taskId !== entry.options.taskId ||
+            options.command !== entry.options.command ||
+            options.commandArgs.join(" ") !== entry.options.commandArgs.join(" ") ||
+            options.cwd !== entry.options.cwd ||
+            options.immediate !== entry.options.immediate ||
+            options.verbose !== entry.options.verbose ||
+            options.description !== entry.options.description ||
+            options.offset !== entry.options.offset ||
+            options.projectId !== entry.options.projectId) {
+            throw new Error("Recipe loops only allow editing interval, maxRuns, and context");
+        }
+        const intervalChanged = entry.options.interval !== options.interval;
+        const maxRunsChanged = entry.options.maxRuns !== options.maxRuns;
+        const contextChanged = JSON.stringify(entry.options.context) !== JSON.stringify(options.context);
+        Object.assign(entry.options, options);
+        entry.intervalHuman = intervalHuman;
+        if (maxRunsChanged) {
+            entry.controller.clearMaxRunsReached();
+        }
+        if (intervalChanged || maxRunsChanged || contextChanged) {
+            const recipeInfo = this.recipeMeta.get(id);
+            if (recipeInfo && this.recipeScanner) {
+                const recipeEntry = this.recipeScanner.getRecipe(id);
+                if (recipeEntry) {
+                    try {
+                        writeRecipeOverrides(recipeEntry.filePath, {
+                            intervalHuman,
+                            maxRuns: options.maxRuns,
+                            context: options.context,
+                        });
+                    }
+                    catch (err) {
+                        daemonLog(`error writing recipe overrides for ${id}: ${String(err)}`);
+                    }
+                }
+            }
+        }
+        if (entry.controller.status === "running" && intervalChanged) {
+            entry.controller.pause(true);
+        }
+        return true;
+    }
+    list() {
+        const result = [];
+        for (const [id, entry] of this.loops) {
+            result.push(buildMeta(id, entry, this.taskManager));
+        }
+        for (const [id, entry] of this.recipes) {
+            const meta = this.recipeMeta.get(id);
+            result.push(buildRecipeMeta(id, entry, this.taskManager, meta?.recipeFile, meta?.recipeFilePath));
+        }
+        return result;
+    }
+    listProjects() {
+        return this.projectManager.getAll();
+    }
+    createProject(name, color, directory, githubSource) {
+        return this.projectManager.create(name, color, directory, githubSource);
+    }
+    updateProject(id, name, color, directory, githubSource) {
+        this.projectManager.update(id, name, color, directory, githubSource);
+    }
+    deleteProject(id) {
+        for (const [loopId, entry] of this.loops) {
+            if (entry.options.projectId === id) {
+                entry.options.projectId = "default";
+                this.persist(loopId, entry.controller, entry.options, entry.intervalHuman);
+            }
+        }
+        if (this.recipeScanner) {
+            this.recipeScanner.unloadRecipesForProject(id);
+        }
+        this.projectManager.delete(id);
+    }
+    status(id) {
+        const userEntry = this.loops.get(id);
+        if (userEntry)
+            return buildMeta(id, userEntry, this.taskManager);
+        const recipeEntry = this.recipes.get(id);
+        if (recipeEntry) {
+            const meta = this.recipeMeta.get(id);
+            return buildRecipeMeta(id, recipeEntry, this.taskManager, meta?.recipeFile, meta?.recipeFilePath);
+        }
+        return null;
+    }
+    pause(id) {
+        const entry = this.loops.get(id) ?? this.recipes.get(id);
+        if (!entry)
+            return false;
+        entry.controller.pause();
+        if (this.loops.has(id)) {
+            this.persist(id, entry.controller, entry.options, entry.intervalHuman);
+        }
+        return true;
+    }
+    resume(id) {
+        const entry = this.loops.get(id) ?? this.recipes.get(id);
+        if (!entry)
+            return false;
+        entry.controller.resume();
+        if (this.loops.has(id)) {
+            this.persist(id, entry.controller, entry.options, entry.intervalHuman);
+        }
+        return true;
+    }
+    async stopLoop(id) {
+        const entry = this.loops.get(id) ?? this.recipes.get(id);
+        if (!entry)
+            return false;
+        await entry.controller.stopLoop(true);
+        if (this.loops.has(id)) {
+            this.persist(id, entry.controller, entry.options, entry.intervalHuman);
+        }
+        return true;
+    }
+    async stopAllLoops() {
+        const stops = [];
+        for (const [, entry] of this.loops) {
+            stops.push(entry.controller.stopLoop(true));
+        }
+        await Promise.all(stops);
+        let count = 0;
+        for (const [id, entry] of this.loops) {
+            this.persist(id, entry.controller, entry.options, entry.intervalHuman);
+            count++;
+        }
+        for (const [, entry] of this.recipes) {
+            entry.controller.stopLoop(true);
+            count++;
+        }
+        return count;
+    }
+    playLoop(id) {
+        const entry = this.loops.get(id) ?? this.recipes.get(id);
+        if (!entry)
+            return false;
+        const ok = entry.controller.playLoop();
+        if (ok && this.loops.has(id)) {
+            this.persist(id, entry.controller, entry.options, entry.intervalHuman);
+        }
+        return ok;
+    }
+    trigger(id) {
+        const entry = this.loops.get(id) ?? this.recipes.get(id);
+        if (!entry)
+            return false;
+        const ok = entry.controller.triggerNow();
+        if (ok && this.loops.has(id)) {
+            this.persist(id, entry.controller, entry.options, entry.intervalHuman);
+        }
+        return ok;
+    }
+    isMaxRunsBlocked(id) {
+        const entry = this.loops.get(id) ?? this.recipes.get(id);
+        return !!entry?.controller.isMaxRunsReached();
+    }
+    isRunning(id) {
+        const entry = this.loops.get(id) ?? this.recipes.get(id);
+        return entry?.controller.status === "running";
+    }
+    async delete(id) {
+        if (this.recipes.has(id)) {
+            throw new Error("Recipe loops cannot be deleted; remove the recipe file instead");
+        }
+        const entry = this.loops.get(id);
+        if (!entry)
+            return false;
+        await entry.controller.stop();
+        this.loops.delete(id);
+        this.lastSerialized.delete(id);
+        deleteLoopState(id);
+        return true;
+    }
+    getLogPath(id) {
+        if (this.loops.has(id) || this.recipes.has(id))
+            return getLogPath(id);
+        return null;
+    }
+    async shutdown() {
+        const stops = [];
+        for (const [, entry] of this.loops) {
+            stops.push(entry.controller.stop());
+        }
+        for (const [, entry] of this.recipes) {
+            stops.push(entry.controller.stop());
+        }
+        await Promise.all(stops);
+        this.loops.clear();
+        this.recipes.clear();
+    }
+    reconcile(newLoops) {
+        const newIds = new Set(newLoops.map((l) => l.id));
+        const shouldAutoStart = (s) => s !== "idle";
+        for (const [existingId, entry] of this.loops) {
+            if (!newIds.has(existingId)) {
+                void entry.controller.stop().then(() => {
+                    this.loops.delete(existingId);
+                    this.lastSerialized.delete(existingId);
+                    deleteLoopState(existingId);
+                });
+            }
+        }
+        for (const meta of newLoops) {
+            const existing = this.loops.get(meta.id);
+            if (existing) {
+                const configChanged = existing.options.interval !== meta.interval ||
+                    existing.options.command !== meta.command ||
+                    existing.options.cwd !== (meta.cwd ?? "");
+                if (configChanged) {
+                    void existing.controller.stop().then(() => {
+                        const entry = createLoopEntry(meta, this.taskResolver, this.getProjectDirectory.bind(this), metaToState(meta), this.telemetryManager ?? undefined);
+                        this.loops.set(meta.id, entry);
+                        this.wireUp(meta.id, entry);
+                        if (shouldAutoStart(meta.status)) {
+                            entry.controller.start();
+                        }
+                    });
+                }
+            }
+            else {
+                const entry = createLoopEntry(meta, this.taskResolver, this.getProjectDirectory.bind(this), metaToState(meta), this.telemetryManager ?? undefined);
+                this.loops.set(meta.id, entry);
+                this.wireUp(meta.id, entry);
+                if (shouldAutoStart(meta.status)) {
+                    entry.controller.start();
+                }
+            }
+        }
+    }
+    addRecipeLoop(id, entry, recipeFile, recipeFilePath, persist) {
+        this.recipes.set(id, entry);
+        this.recipeMeta.set(id, { isRecipe: true, recipeFile, recipeFilePath });
+        wireEvents(id, entry.controller, entry.options, entry.intervalHuman, persist);
+    }
+    removeRecipeLoop(id) {
+        const entry = this.recipes.get(id);
+        if (entry) {
+            entry.controller.stopLoop(true);
+            this.recipes.delete(id);
+            this.recipeMeta.delete(id);
+        }
+    }
+    isRecipeLoop(id) {
+        return this.recipes.has(id);
+    }
+}

package/dist/daemon/managers/loop-options.js

@@ -0,0 +1,17 @@
+export function buildLoopOptions(meta) {
+    return {
+        interval: meta.interval,
+        taskId: meta.taskId ?? null,
+        command: meta.command,
+        commandArgs: meta.commandArgs,
+        commandRaw: meta.commandRaw,
+        cwd: meta.cwd ?? "",
+        immediate: false,
+        maxRuns: meta.maxRuns,
+        verbose: meta.verbose,
+        description: meta.description ?? "",
+        projectId: meta.projectId ?? "default",
+        offset: meta.offset ?? null,
+        context: meta.context,
+    };
+}

package/dist/daemon/managers/loop-serialization.js

@@ -0,0 +1,53 @@
+import { saveLoop } from "../state/index.js";
+export function wireEvents(id, controller, options, intervalHuman, persist) {
+    controller.on("run:start", persist);
+    controller.on("run:end", persist);
+    controller.on("paused", persist);
+    controller.on("resumed", persist);
+    controller.on("triggered", persist);
+    controller.on("waiting", persist);
+    controller.on("stopped", persist);
+}
+export function toMeta(controller, options, intervalHuman, taskManager) {
+    const runtime = controller.getMeta();
+    const task = options.taskId ? taskManager.get(options.taskId) : null;
+    return {
+        ...runtime,
+        command: task?.command ?? options.command,
+        commandArgs: task?.commandArgs ?? options.commandArgs,
+        commandRaw: options.commandRaw,
+        cwd: options.cwd || "",
+        interval: options.interval,
+        intervalHuman,
+        immediate: options.immediate,
+        maxRuns: options.maxRuns,
+        verbose: options.verbose,
+        description: options.description,
+        remainingDelayMs: runtime.remainingDelayMs,
+        pid: process.pid,
+        projectId: options.projectId ?? "default",
+        offset: options.offset,
+        context: options.context,
+    };
+}
+export function persistLoop(id, controller, options, intervalHuman, taskManager, lastSerialized) {
+    const meta = toMeta(controller, options, intervalHuman, taskManager);
+    const serialized = JSON.stringify(meta);
+    if (lastSerialized.get(id) === serialized) {
+        return;
+    }
+    lastSerialized.set(id, serialized);
+    saveLoop(meta);
+}
+export function buildMeta(id, entry, taskManager) {
+    return toMeta(entry.controller, entry.options, entry.intervalHuman, taskManager);
+}
+export function buildRecipeMeta(id, entry, taskManager, recipeFile, recipeFilePath) {
+    const base = toMeta(entry.controller, entry.options, entry.intervalHuman, taskManager);
+    return {
+        ...base,
+        isRecipe: true,
+        recipeFile: recipeFile ?? "",
+        recipeFilePath: recipeFilePath ?? "",
+    };
+}