loop-task 2.1.11 → 2.1.13

package/dist/app/App.js

@@ -2,6 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useMemo, useCallback } from "react";
 import { Box, useApp } from "ink";
 import { useLoopPolling } from "../shared/hooks/useLoopPolling.js";
+import { useDaemonSettings } from "../shared/hooks/useDaemonSettings.js";
 import { useLogStream } from "../shared/hooks/useLogStream.js";
 import { useBreakpoint } from "../shared/hooks/useBreakpoint.js";
 import { useToasts } from "../shared/ui/Toast.js";
@@ -42,6 +43,7 @@ export function App(props) {
     const logService = useInject(TYPES.LogService);
     const exportService = useInject(TYPES.ExportService);
     const { loops, daemonStatus, refresh } = useLoopPolling();
+    const daemonSettings = useDaemonSettings();
     const { view, push, pop } = useRouter("board");
     const { toasts, push: pushToast } = useToasts();
     const breakpoint = useBreakpoint();
@@ -113,7 +115,7 @@ export function App(props) {
         pushToast("success", updated ? t("project.toastUpdated", { name }) : t("project.toastCreated", { name }));
     };
     const commandContext = useMemo(() => ({ activeTab: s.activeTab, selectedLoop: s.selected, selectedTask: s.selectedTask, selectedProject: s.selectedProjectEntity }), [s.activeTab, s.selected, s.selectedTask]);
-    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: process.stdout.rows || 24, backgroundColor: theme.bg.base, children: [_jsx(Header, { daemonStatus: daemonStatus, counts: s.counts, activeTab: s.activeTab, onTabChange: s.setActiveTab, tabCounts: s.tabCounts }), _jsx(Box, { flexGrow: 1, children: isBoardView(view) ? (_jsxs(Box, { flexDirection: breakpoint === "narrow" ? "column" : "row", flexGrow: 1, children: [_jsx(LeftPanel, { isFocused: s.focusedPanel === "left" && !anyModalOpen, navActive: inputOwner === "panel", activeTab: s.activeTab, query: s.leftPanelQuery, loops: s.visible, selectedIndex: s.clampedIndex, filters: s.filters, sort: s.sort, breakpoint: breakpoint, projects: s.projects, onSelect: (i) => s.setSelectedIndex(i), onActivate: (i) => { s.setSelectedIndex(i); }, tasks: s.filteredTasks, taskSelectedIndex: s.taskClampedIndex, onTaskSelect: (i) => s.setTaskSelectedIndex(i), onTaskActivate: (i) => { s.setTaskSelectedIndex(i); s.setEditTask(s.filteredTasks[i] ?? null); push("task-edit"); }, onStatusCycle: () => s.setFilters((prev) => ({ ...prev, status: cycleStatusFilter(prev.status) })), onSortCycle: () => s.setSort(cycleSortMode(s.sort)), onSelectProject: () => s.setActiveTab("projects"), currentProjectName: s.currentProjectId === "all" ? t("project.showAll") : (s.projects.find(p => p.id === s.currentProjectId)?.name ?? "Default"), projectFilters: s.projectFilters, projectSelectedIndex: s.projectClampedIndex, onProjectSelect: (i) => s.setProjectSelectedIndex(i), onProjectActivate: (i) => { s.setProjectSelectedIndex(i); }, projectLoops: loops }), _jsx(RightPanel, { isFocused: s.focusedPanel === "right" && !anyModalOpen, navActive: inputOwner === "panel", activeTab: s.activeTab, loop: s.selected, selectedRunIndex: s.selectedRunIndex, onSelectRun: (i) => s.setSelectedRunIndex(i), onOpenRun: s.handleOpenRunLog, selectedTask: s.selectedTask, allTasks: s.tasks, selectedProject: s.selectedProjectEntity, projectLoopCount: s.projectLoopCount, projects: s.projects, onProjectEdit: () => { if (s.selectedProjectEntity && !s.selectedProjectEntity.isSystem)
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: process.stdout.rows || 24, backgroundColor: theme.bg.base, children: [_jsx(Header, { daemonStatus: daemonStatus, httpApiEnabled: daemonSettings.reachable ? daemonSettings.httpApiEnabled : undefined, mcpApiEnabled: daemonSettings.reachable ? daemonSettings.mcpApiEnabled : undefined, counts: s.counts, activeTab: s.activeTab, onTabChange: s.setActiveTab, tabCounts: s.tabCounts }), _jsx(Box, { flexGrow: 1, children: isBoardView(view) ? (_jsxs(Box, { flexDirection: breakpoint === "narrow" ? "column" : "row", flexGrow: 1, children: [_jsx(LeftPanel, { isFocused: s.focusedPanel === "left" && !anyModalOpen, navActive: inputOwner === "panel", activeTab: s.activeTab, query: s.leftPanelQuery, loops: s.visible, selectedIndex: s.clampedIndex, filters: s.filters, sort: s.sort, breakpoint: breakpoint, projects: s.projects, onSelect: (i) => s.setSelectedIndex(i), onActivate: (i) => { s.setSelectedIndex(i); }, tasks: s.filteredTasks, taskSelectedIndex: s.taskClampedIndex, onTaskSelect: (i) => s.setTaskSelectedIndex(i), onTaskActivate: (i) => { s.setTaskSelectedIndex(i); s.setEditTask(s.filteredTasks[i] ?? null); push("task-edit"); }, onStatusCycle: () => s.setFilters((prev) => ({ ...prev, status: cycleStatusFilter(prev.status) })), onSortCycle: () => s.setSort(cycleSortMode(s.sort)), onSelectProject: () => s.setActiveTab("projects"), currentProjectName: s.currentProjectId === "all" ? t("project.showAll") : (s.projects.find(p => p.id === s.currentProjectId)?.name ?? "Default"), projectFilters: s.projectFilters, projectSelectedIndex: s.projectClampedIndex, onProjectSelect: (i) => s.setProjectSelectedIndex(i), onProjectActivate: (i) => { s.setProjectSelectedIndex(i); }, projectLoops: loops }), _jsx(RightPanel, { isFocused: s.focusedPanel === "right" && !anyModalOpen, navActive: inputOwner === "panel", activeTab: s.activeTab, loop: s.selected, selectedRunIndex: s.selectedRunIndex, onSelectRun: (i) => s.setSelectedRunIndex(i), onOpenRun: s.handleOpenRunLog, selectedTask: s.selectedTask, allTasks: s.tasks, selectedProject: s.selectedProjectEntity, projectLoopCount: s.projectLoopCount, projects: s.projects, onProjectEdit: () => { if (s.selectedProjectEntity && !s.selectedProjectEntity.isSystem)
                                 handleCommand("edit"); }, onProjectDelete: () => { if (s.selectedProjectEntity && !s.selectedProjectEntity.isSystem)
                                 handleCommand("delete"); } }), s.debugMode ? _jsx(DebugPanel, { entries: s.debugEntries }) : null] })) : (_jsx(FormRouter, { view: view, editTarget: s.editTarget, cloneMode: s.cloneMode, editTask: s.editTask, editProject: s.editProject, pendingTaskSelection: s.pendingTaskSelection, tasks: s.tasks, projects: s.projects, currentProjectId: s.currentProjectId, cancelCreate: cancelCreate, onCreateDone: onCreateDone, handleChooseTask: handleChooseTask, cancelTask: cancelTask, onTaskDone: onTaskDone, cancelProject: cancelProject, onProjectDone: onProjectDone })) }, viewKey(view, s.editTarget, s.editTask)), isBoardView(view) ? (_jsx(CommandInput, { context: commandContext, onCommand: handleCommand, confirmState: s.confirmState, searchState: s.searchState, searchValue: s.searchValue, onSearchChange: s.handleSearchChange, onSearchSubmit: s.handleSearchSubmit, onSearchCancel: s.handleSearchCancel, onConfirmYes: handleConfirmYes, onConfirmCancel: handleConfirmCancel, onCopy: handleContextualCopy, onPanelAction: triggerContextualAction, disabled: commandInputDisabled, navOwner: inputOwner, onInputStateChange: (hasText, dropdownOpen) => { s.setCommandBarHasText(hasText); s.setCommandBarDropdownOpen(dropdownOpen); } })) : null, _jsx(OverlayStack, { commandsBrowserOpen: s.commandsBrowserOpen, commandContext: commandContext, onCommandsBrowserClose: () => s.setCommandsBrowserOpen(false), onCommandsBrowserExecute: (v) => { s.setCommandsBrowserOpen(false); handleCommand(v); }, contextHelpOpen: s.contextHelpOpen, onContextHelpClose: () => s.setContextHelpOpen(false), exportModal: s.exportModal, onExportModalClose: () => s.setExportModal(null), onExportCopy: () => pushToast("success", t("board.toastCopied")), logModalRun: s.logModalRun, logModalLoopId: s.logModalLoopId, logModalLines: s.logModalLines, logModalLoading: s.logModalLoading, onLogModalClose: () => { s.setLogModalRun(null); s.setLogModalLoopId(null); }, onLogCopy: () => pushToast("success", t("board.toastCopied")), toasts: toasts })] }));
 }

package/dist/cli.js

@@ -79,12 +79,31 @@ program
     .option("--project <name>", t("cli.optProject"))
     .option("--offset <duration>", "Phase offset (e.g. 5m, 15m)")
     .option("--description <desc>", "Description of the loop")
+    .option("-C, --context <json>", "Initial context JSON (e.g. {\"env\":\"staging\"})")
     .action(async (intervalStr, cmdArgs, opts) => {
     try {
         const projectId = opts.project
             ? await resolveProjectId(opts.project)
             : undefined;
         const offsetMs = opts.offset ? parseDuration(opts.offset) : null;
+        let context;
+        if (opts.context) {
+            const { validateContext } = await import("./core/context/validate-context.js");
+            let parsed;
+            try {
+                parsed = JSON.parse(opts.context);
+            }
+            catch {
+                console.error("Invalid JSON in --context flag");
+                process.exit(1);
+            }
+            const result = validateContext(parsed);
+            if (!result.valid) {
+                console.error(`Invalid context: ${result.error}`);
+                process.exit(1);
+            }
+            context = result.context;
+        }
         const built = buildLoopOptions(intervalStr, {
             ...opts,
             command: cmdArgs[0],
@@ -93,6 +112,7 @@ program
             projectId,
             offset: offsetMs,
             description: opts.description ?? cmdArgs.join(" "),
+            context,
         });
         await startLoop(built.options, built.intervalHuman);
     }
@@ -112,19 +132,43 @@ program
     .option("--verbose", t("cli.optVerbose"))
     .option("--cwd <dir>", t("cli.optCwd"))
     .option("--description <desc>", "Description of the loop")
+    .option("-C, --context <json>", "Initial context JSON (e.g. {\"env\":\"staging\"})")
     .action(async (intervalStr, cmdArgs, opts) => {
     if (!intervalStr || !cmdArgs || cmdArgs.length === 0) {
         program.help();
         return;
     }
     const logger = new Logger(opts.verbose ?? false);
+    let context;
+    if (opts.context) {
+        const { validateContext } = await import("./core/context/validate-context.js");
+        let parsed;
+        try {
+            parsed = JSON.parse(opts.context);
+        }
+        catch {
+            console.error("Invalid JSON in --context flag");
+            process.exit(1);
+        }
+        const result = validateContext(parsed);
+        if (!result.valid) {
+            console.error(`Invalid context: ${result.error}`);
+            process.exit(1);
+        }
+        context = result.context;
+    }
     const built = buildLoopOptions(intervalStr, {
         ...opts,
         command: cmdArgs[0],
         commandArgs: cmdArgs.slice(1),
         cwd: opts.cwd ?? process.cwd(),
         description: opts.description ?? cmdArgs.join(" "),
+        context,
     });
+    if (built.options.interval === 0) {
+        console.error("Manual loops are not supported in foreground mode. Use 'loop-task new manual -- <command>' instead.");
+        process.exit(1);
+    }
     const controller = new AbortController();
     process.on("SIGINT", () => controller.abort());
     process.on("SIGTERM", () => controller.abort());
@@ -143,8 +187,10 @@ projectCmd
     .description(t("cli.projectNewDescription"))
     .argument("<name>", t("cli.projectArgName"))
     .option("--color <color>", t("cli.optProjectColor"))
+    .option("--directory <path>", t("cli.optProjectDirectory"))
+    .option("--github-source <owner/repo>", t("cli.optProjectGithubSource"))
     .action(async (name, opts) => {
-    await createProjectCli(name, opts.color);
+    await createProjectCli(name, opts.color, opts.directory, opts.githubSource);
 });
 projectCmd
     .command("rename")
@@ -177,6 +223,7 @@ program
     .command("status")
     .description("Show status of all loops")
     .option("--json", "Output as JSON")
+    .option("--verbose", "Show extra details (skipped, silent-chain counts)")
     .action(async (opts) => {
     const { sendRequest } = await import("./client/ipc.js");
     const response = await sendRequest({ type: "list" });
@@ -191,7 +238,17 @@ program
     else {
         for (const loop of loops) {
             const { describeLoop, statusLabel } = await import("./shared/ui/format.js");
-            console.log(`${loop.id}  ${statusLabel(loop.status)}  ${describeLoop(loop)}`);
+            let line = `${loop.id}  ${statusLabel(loop.status)}  ${describeLoop(loop)}`;
+            if (opts.verbose) {
+                const extra = [];
+                if (loop.skippedCount > 0)
+                    extra.push(`skipped=${loop.skippedCount}`);
+                if ((loop.silentChainCount ?? 0) > 0)
+                    extra.push(`silent=${loop.silentChainCount}`);
+                if (extra.length)
+                    line += `  [${extra.join(", ")}]`;
+            }
+            console.log(line);
         }
     }
 });
@@ -279,4 +336,33 @@ program
     console.log(`  OpenAPI:    ${baseUrl}/api/openapi.json`);
     console.log(`  Events:     ${baseUrl}/api/events (SSE)`);
 });
+program
+    .command("mcp")
+    .description("Show MCP server info and how to connect an MCP client")
+    .action(() => {
+    const transport = process.env.LOOP_CLI_MCP_TRANSPORT === "stdio" ? "stdio" : "sse";
+    const port = process.env.LOOP_CLI_MCP_PORT ?? "8846";
+    const sseUrl = `http://${HTTP_API_HOST}:${port}/sse`;
+    console.log(`MCP Server`);
+    console.log(`  Transport:  ${transport}`);
+    console.log(`  SSE URL:    ${sseUrl}`);
+    console.log("");
+    console.log(`  Connect an MCP client to the SSE URL above.`);
+    console.log("");
+    if (transport === "stdio") {
+        console.log(`  Currently using stdio transport. To switch to SSE (default),`);
+        console.log(`  restart without LOOP_CLI_MCP_TRANSPORT=stdio.`);
+        console.log("");
+    }
+    console.log(`  Example MCP client configs:`);
+    console.log("");
+    console.log(`  OpenCode (opencode.json):`);
+    console.log(`    { "mcp": { "loop-task": { "type": "remote", "url": "${sseUrl}" } } }`);
+    console.log("");
+    console.log(`  Claude Code (.claude/mcp.json):`);
+    console.log(`    { "mcpServers": { "loop-task": { "type": "sse", "url": "${sseUrl}" } } }`);
+    console.log("");
+    console.log(`  Cursor (.cursor/mcp.json):`);
+    console.log(`    { "mcpServers": { "loop-task": { "type": "sse", "url": "${sseUrl}" } } }`);
+});
 await program.parseAsync(process.argv);

package/dist/client/commands.js

@@ -23,6 +23,9 @@ export async function startLoop(options, intervalHuman) {
     console.log(t("cli.startedCommand", { command: options.command }));
     console.log(t("cli.startedInterval", { interval: intervalHuman }));
     console.log(t("cli.startedStatus"));
+    if (options.interval === 0) {
+        console.log("  Note: manual loop  use 'trigger' to run on demand");
+    }
     console.log();
     console.log(t("cli.startedHint"));
     process.exit(0);
@@ -73,9 +76,13 @@ export async function showStatus(id) {
     const maxRuns = loop.maxRuns !== null ? String(loop.maxRuns) : t("cli.unlimited");
     console.log(t("cli.statusTitle", { id: loop.id }));
     console.log(t("cli.statusCommand", { command: cmd }));
-    console.log(t("cli.statusInterval", { interval: loop.intervalHuman, duration: formatDuration(loop.interval) }));
+    const intervalDisplay = loop.interval === 0 ? "manual" : formatDuration(loop.interval);
+    console.log(t("cli.statusInterval", { interval: loop.intervalHuman, duration: intervalDisplay }));
     console.log(t("cli.statusStatus", { status: loop.status }));
     console.log(t("cli.statusRuns", { runs: loop.runCount, maxRuns }));
+    if ((loop.silentChainCount ?? 0) > 0) {
+        console.log(t("cli.statusSilentChains", { count: loop.silentChainCount.toLocaleString() }));
+    }
     console.log(t("cli.statusCreated", { created: loop.createdAt }));
     if (loop.lastRunAt) {
         const exitInfo = loop.lastExitCode !== null ? t("cli.exitInfo", { code: loop.lastExitCode }) : "";

package/dist/client/project-commands.js

@@ -70,12 +70,17 @@ export async function listProjectsCli() {
         process.exit(1);
     }
 }
-export async function createProjectCli(name, colorInput) {
+export async function createProjectCli(name, colorInput, directory, githubSource) {
     try {
+        if (githubSource !== undefined && githubSource !== "") {
+            if (!/^[a-zA-Z0-9_.\-]+\/[a-zA-Z0-9_.\-]+$/.test(githubSource)) {
+                throw new Error(`Invalid github-source format: "${githubSource}". Expected owner/repo (e.g. CKGrafico/loop-task)`);
+            }
+        }
         const color = colorInput ? resolveColor(colorInput) : PROJECT_COLORS.cyan;
         const response = await sendRequest({
             type: "project-create",
-            payload: { name, color },
+            payload: { name, color, directory, githubSource },
         });
         if (response.type !== "ok") {
             throw new Error(response.message);

package/dist/core/context/template.js

@@ -5,7 +5,7 @@ function shellEscape(value) {
     if (/^[A-Za-z0-9_\-=:./,@]+$/.test(value))
         return value;
     // Escape characters that are dangerous inside double quotes, then wrap
-    // the whole value in single quotes — the strongest shell quoting.
+    // the whole value in single quotes  the strongest shell quoting.
     // Single quotes preserve everything literally (newlines, backticks,
     // $, ", \, parens) except single quotes themselves.
     return "'" + value.replace(/'/g, "'\\''") + "'";

package/dist/core/context/validate-context.js

@@ -0,0 +1,19 @@
+export function validateContext(value) {
+    if (value === undefined || value === null) {
+        return { valid: true, context: {} };
+    }
+    if (typeof value !== "object" || Array.isArray(value) || value === null) {
+        return { valid: false, error: "Context must be a JSON object" };
+    }
+    const obj = value;
+    for (const key of Object.keys(obj)) {
+        const v = obj[key];
+        if (Array.isArray(v)) {
+            return { valid: false, error: `Context key "${key}" has an array  only string values are allowed` };
+        }
+        if (typeof v === "object" && v !== null) {
+            return { valid: false, error: `Context key "${key}" has a nested object  only string values are allowed` };
+        }
+    }
+    return { valid: true, context: obj };
+}

package/dist/core/loop/chain-executor.js

@@ -1,11 +1,13 @@
 import crypto from "node:crypto";
 import fs from "node:fs";
+import { Writable } from "node:stream";
 import { executeCommand } from "../command/command-runner.js";
 import { t } from "../../shared/i18n/index.js";
 import { parseStdout } from "../context/context-parser.js";
 import { interpolate } from "../context/template.js";
 export function executeChain(options) {
     const { chainTargetId, exitCode, task, chainContext, cwd, signal, runCount, logPath, runHistory, logStream, controller } = options;
+    const nullStream = new Writable({ write(_chunk, _enc, cb) { cb(); } });
     if (!chainTargetId) {
         return Promise.resolve({ runHistory, lastExitCode: exitCode, lastDuration: 0 });
     }
@@ -23,11 +25,15 @@ export function executeChain(options) {
             const chainTask = controller.taskResolver(currentTargetId);
             if (!chainTask)
                 break;
-            if (logStream) {
+            const isSilent = chainTask.silentChain === true;
+            if (isSilent) {
+                controller.incrementSilentChainCount();
+            }
+            if (logStream && !isSilent) {
                 logStream.write(t("loop.chainHeader", { name: chainTask.name, branch: prevBranch, prevExit }));
             }
             const chainStartedAt = new Date().toISOString();
-            const chainOffset = fs.existsSync(logPath) ? fs.statSync(logPath).size : 0;
+            const chainOffset = !isSilent && fs.existsSync(logPath) ? fs.statSync(logPath).size : 0;
             runHistory.push({
                 runNumber: runCount,
                 startedAt: chainStartedAt,
@@ -39,28 +45,55 @@ export function executeChain(options) {
                 chainGroupId,
                 chainName: chainTask.name,
             });
-            const interpolatedCommand = interpolate(chainTask.command, chainContext);
-            const interpolatedArgs = chainTask.commandArgs.map(a => interpolate(a, chainContext));
-            const chainResult = await executeCommand(interpolatedCommand, interpolatedArgs, cwd, logStream, signal, runCount, true, true);
-            if (chainResult.stdout) {
-                const parsed = parseStdout(chainResult.stdout);
-                if (parsed !== null) {
-                    Object.assign(chainContext, parsed);
+            const singleCommandFallback = {
+                command: chainTask.command,
+                commandArgs: chainTask.commandArgs,
+                commandRaw: chainTask.commandRaw,
+            };
+            const taskSteps = chainTask.steps?.length
+                ? chainTask.steps
+                : [{ commands: [singleCommandFallback] }];
+            const chainTaskHasChains = !!(chainTask.onSuccessTaskId || chainTask.onFailureTaskId);
+            const shouldCaptureStdout = chainTaskHasChains || taskSteps.length > 1 || taskSteps[0].commands.length > 1;
+            let chainExitCode = 0;
+            let chainDuration = 0;
+            const effectiveStream = isSilent ? nullStream : (logStream ?? nullStream);
+            for (const step of taskSteps) {
+                const stepResults = await Promise.allSettled(step.commands.map((cmd) => executeCommand(interpolate(cmd.command, chainContext), cmd.commandArgs.map(a => interpolate(a, chainContext)), cwd, effectiveStream, signal, runCount, shouldCaptureStdout)));
+                let stepStdout = "";
+                for (const r of stepResults) {
+                    if (r.status === "fulfilled") {
+                        chainDuration += r.value.duration;
+                        if (r.value.stdout)
+                            stepStdout += (stepStdout ? "\n" : "") + r.value.stdout;
+                    }
+                }
+                if (shouldCaptureStdout && stepStdout) {
+                    const parsed = parseStdout(stepStdout);
+                    if (parsed !== null) {
+                        Object.assign(chainContext, parsed);
+                    }
+                }
+                const stepFailure = stepResults.some((r) => r.status === "rejected" || (r.status === "fulfilled" && r.value.exitCode !== 0));
+                if (stepFailure) {
+                    const failed = stepResults.find((r) => r.status === "fulfilled" && r.value.exitCode !== 0);
+                    chainExitCode = failed ? failed.value.exitCode : 1;
+                    break;
                 }
             }
-            const chainLogSize = fs.existsSync(logPath) ? fs.statSync(logPath).size - chainOffset : 0;
+            const chainLogSize = !isSilent && fs.existsSync(logPath) ? fs.statSync(logPath).size - chainOffset : 0;
             const chainRecord = runHistory.find(r => r.chainGroupId === chainGroupId && r.status === "running" && r.chainName === chainTask.name);
             if (chainRecord) {
-                chainRecord.exitCode = chainResult.exitCode;
-                chainRecord.duration = chainResult.duration;
+                chainRecord.exitCode = chainExitCode;
+                chainRecord.duration = chainDuration;
                 chainRecord.logSize = Math.max(0, chainLogSize);
                 chainRecord.status = "completed";
             }
-            totalExtraDuration += chainResult.duration;
-            finalExitCode = chainResult.exitCode;
-            currentTargetId = (chainResult.exitCode === 0 ? chainTask.onSuccessTaskId : chainTask.onFailureTaskId) ?? null;
-            prevBranch = chainResult.exitCode === 0 ? "onSuccess" : "onFailure";
-            prevExit = chainResult.exitCode;
+            totalExtraDuration += chainDuration;
+            finalExitCode = chainExitCode;
+            currentTargetId = (chainExitCode === 0 ? chainTask.onSuccessTaskId : chainTask.onFailureTaskId) ?? null;
+            prevBranch = chainExitCode === 0 ? "onSuccess" : "onFailure";
+            prevExit = chainExitCode;
         }
         return { runHistory, lastExitCode: finalExitCode, lastDuration: totalExtraDuration };
     })();

package/dist/core/loop/loop-controller.js

@@ -27,6 +27,7 @@ export class LoopController extends EventEmitter {
         this.runHistory = [];
         this.currentRunStartOffset = 0;
         this.skippedCount = 0;
+        this._silentChainCount = 0;
         this.id = id;
         this.options = options;
         this.logPath = logPath;
@@ -46,10 +47,17 @@ export class LoopController extends EventEmitter {
         this._paused = state?.status === "paused" || state?.status === "idle";
         this.runHistory = (state?.runHistory ?? []).map((r) => r.status === "running" ? { ...r, status: "completed" } : r).map((r) => ({ ...r, logOffset: r.logOffset ?? 0 }));
         this.skippedCount = state?.skippedCount ?? 0;
+        this._silentChainCount = state?.silentChainCount ?? 0;
     }
     get status() {
         return this._status;
     }
+    get silentChainCount() {
+        return this._silentChainCount;
+    }
+    incrementSilentChainCount() {
+        this._silentChainCount += 1;
+    }
     start() {
         if (this._loopActive)
             return;
@@ -58,6 +66,13 @@ export class LoopController extends EventEmitter {
         this.logStream?.end();
         this.abortController = new AbortController();
         this.logStream = fs.createWriteStream(this.logPath, { flags: "a" });
+        if (this.options.interval === 0 && !this._stopAfterRun) {
+            this._status = "idle";
+            this.nextRunAt = null;
+            this._loopActive = false;
+            this.emit("stopped");
+            return;
+        }
         this.loopPromise = this.run().finally(() => { this._loopActive = false; });
         if (this.sessionStartedAt === null) {
             this.sessionStartedAt = new Date().toISOString();
@@ -112,6 +127,8 @@ export class LoopController extends EventEmitter {
             this._maxRunsReached = true;
             return false;
         }
+        if (this.options.interval === 0)
+            return false;
         this.sessionStartedAt = new Date().toISOString();
         this._resetSchedule = true;
         this._paused = false;
@@ -176,6 +193,7 @@ export class LoopController extends EventEmitter {
             remainingDelayMs: this.remainingDelayMs,
             runHistory: this.runHistory,
             skippedCount: this.skippedCount,
+            silentChainCount: this._silentChainCount,
         };
     }
     clearMaxRunsReached() {

package/dist/core/loop/loop-runner.js

@@ -106,6 +106,14 @@ export async function runLoop(ctrl) {
                 }
             }
             else {
+                if (ctrl.options.interval === 0) {
+                    ctrl._paused = true;
+                    ctrl._status = "idle";
+                    ctrl.remainingDelayMs = null;
+                    ctrl.nextRunAt = null;
+                    ctrl.emit("stopped");
+                    return;
+                }
                 const nextSlotMs = runStartedAtMs + ctrl.options.interval;
                 const overrunMs = Date.now() - nextSlotMs;
                 if (overrunMs >= 0) {

package/dist/core/loop/run-executor.js

@@ -28,7 +28,7 @@ export async function executeRunImpl(ctrl, signal) {
     ctrl.runAbortController = new AbortController();
     const task = ctrl.options.taskId ? ctrl.taskResolver(ctrl.options.taskId) : null;
     const cwd = resolveEffectiveCwd(ctrl.options.cwd, ctrl.projectDirectory);
-    const chainContext = {};
+    const chainContext = { ...(task?.context ?? {}), ...(ctrl.options.context ?? {}) };
     const hasChainTasks = !!(task?.onSuccessTaskId || task?.onFailureTaskId);
     const singleCommandFallback = {
         command: task?.command ?? ctrl.options.command,

package/dist/core/scheduling/index.js

@@ -1,4 +1,6 @@
 export function computePhase(loopId, intervalMs) {
+    if (intervalMs <= 0)
+        return 0;
     let hash = 0;
     for (let i = 0; i < loopId.length; i++) {
         hash = ((hash << 5) - hash + loopId.charCodeAt(i)) | 0;
@@ -6,6 +8,8 @@ export function computePhase(loopId, intervalMs) {
     return Math.abs(hash) % intervalMs;
 }
 export function alignToPhase(now, intervalMs, phaseMs) {
+    if (intervalMs <= 0)
+        return 0;
     const elapsed = now % intervalMs;
     const delay = (phaseMs - elapsed + intervalMs) % intervalMs;
     return delay;

package/dist/daemon/http/openapi.js

@@ -10,10 +10,21 @@ export function buildOpenApiSpec() {
         servers: [
             { url: `http://${HTTP_API_HOST}:${HTTP_API_PORT}`, description: "Local daemon" },
         ],
+        tags: [
+            { name: "Loops", description: "Loop management" },
+            { name: "Tasks", description: "Task management" },
+            { name: "Task Chains", description: "Create chained tasks" },
+            { name: "Projects", description: "Project management" },
+            { name: "Logs", description: "Log retrieval" },
+            { name: "Events", description: "Server-sent events" },
+            { name: "Settings", description: "Daemon settings" },
+            { name: "MCP", description: "Model Context Protocol server" },
+            { name: "Docs", description: "API documentation" },
+        ],
         paths: {
             "/api/loops": {
                 get: { summary: "List all loops", tags: ["Loops"], responses: { "200": { description: "Array of loops", content: { "application/json": { schema: { type: "array" } } } } } },
-                post: { summary: "Create a new loop", tags: ["Loops"], requestBody: { content: { "application/json": { schema: { type: "object", properties: { command: { type: "string" }, commandArgs: { type: "array", items: { type: "string" } }, intervalHuman: { type: "string", example: "5m" }, cwd: { type: "string" }, description: { type: "string" }, taskId: { type: "string" }, now: { type: "boolean" }, maxRuns: { type: "integer" }, verbose: { type: "boolean" }, projectId: { type: "string" }, offset: { type: "integer" } } } } } }, responses: { "201": { description: "Loop created", content: { "application/json": { schema: { type: "object", properties: { id: { type: "string" } } } } } }, "400": { description: "Validation error" } } },
+                post: { summary: "Create a new loop", tags: ["Loops"], requestBody: { content: { "application/json": { schema: { type: "object", properties: { command: { type: "string" }, commandArgs: { type: "array", items: { type: "string" } }, intervalHuman: { type: "string", example: "5m", description: "Interval like 30s, 5m, 1h, or 'manual' for trigger-only loops" }, cwd: { type: "string" }, description: { type: "string" }, taskId: { type: "string" }, now: { type: "boolean" }, maxRuns: { type: "integer" }, verbose: { type: "boolean" }, projectId: { type: "string" }, offset: { type: "integer" }, context: { type: "object", additionalProperties: true, description: "Initial context for chain interpolation" } } } } } }, responses: { "201": { description: "Loop created", content: { "application/json": { schema: { type: "object", properties: { id: { type: "string" } } } } } }, "400": { description: "Validation error" } } },
             },
             "/api/loops/{id}": {
                 get: { summary: "Get loop status", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Loop details" }, "404": { description: "Not found" } } },
@@ -22,33 +33,49 @@ export function buildOpenApiSpec() {
             },
             "/api/loops/{id}/pause": { post: { summary: "Pause a loop", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Paused" }, "404": { description: "Not found" } } } },
             "/api/loops/{id}/resume": { post: { summary: "Resume a loop", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Resumed" }, "404": { description: "Not found" } } } },
+            "/api/loops/{id}/play": { post: { summary: "Play (start) a loop", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Playing", content: { "application/json": { schema: { type: "object" } } } }, "404": { description: "Not found" }, "409": { description: "Already running or max runs blocked" } } } },
             "/api/loops/{id}/trigger": { post: { summary: "Trigger a loop now", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Triggered" }, "404": { description: "Not found" }, "400": { description: "Max runs reached" }, "409": { description: "Already running" } } } },
             "/api/loops/{id}/stop": { post: { summary: "Stop a loop", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Stopped" }, "404": { description: "Not found" } } } },
             "/api/loops/stop-all": { post: { summary: "Stop all loops", tags: ["Loops"], responses: { "200": { description: "All stopped", content: { "application/json": { schema: { type: "object", properties: { count: { type: "integer" } } } } } } } } },
+            "/api/loops/{id}/runs": { get: { summary: "List run history", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }, { name: "from", in: "query", schema: { type: "string", description: "ISO 8601 date" } }, { name: "to", in: "query", schema: { type: "string", description: "ISO 8601 date" } }], responses: { "200": { description: "Run records", content: { "application/json": { schema: { type: "array" } } } }, "404": { description: "Not found" } } } },
+            "/api/loops/{id}/logs/date": { get: { summary: "Date-filtered logs", tags: ["Logs"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }, { name: "from", in: "query", required: true, schema: { type: "string", description: "ISO 8601 start date" } }, { name: "to", in: "query", required: true, schema: { type: "string", description: "ISO 8601 end date" } }], responses: { "200": { description: "Filtered log content" }, "404": { description: "Not found" }, "400": { description: "Missing or invalid date params" } } } },
             "/api/loops/{id}/logs": { get: { summary: "Fetch loop logs", tags: ["Logs"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }, { name: "tail", in: "query", schema: { type: "integer", default: 50 } }], responses: { "200": { description: "Log content" }, "404": { description: "Not found" } } } },
             "/api/loops/{id}/logs/stream": { get: { summary: "Stream logs via SSE", tags: ["Logs"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }, { name: "tail", in: "query", schema: { type: "integer" } }], responses: { "200": { description: "SSE stream" }, "404": { description: "Not found" } } } },
             "/api/loops/{id}/runs/{num}": { get: { summary: "Get run-specific log", tags: ["Logs"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }, { name: "num", in: "path", required: true, schema: { type: "integer" } }], responses: { "200": { description: "Run log content" } } } },
             "/api/tasks": {
                 get: { summary: "List all tasks", tags: ["Tasks"], responses: { "200": { description: "Array of tasks" } } },
-                post: { summary: "Create a task", tags: ["Tasks"], requestBody: { content: { "application/json": { schema: { type: "object", properties: { id: { type: "string" }, name: { type: "string" }, command: { type: "string" }, commandArgs: { type: "array", items: { type: "string" } }, onSuccessTaskId: { type: "string" }, onFailureTaskId: { type: "string" } } } } } }, responses: { "201": { description: "Task created" }, "400": { description: "Validation error" } } },
+                post: { summary: "Create a task", tags: ["Tasks"], requestBody: { content: { "application/json": { schema: { type: "object", properties: { id: { type: "string" }, name: { type: "string" }, command: { type: "string" }, commandArgs: { type: "array", items: { type: "string" } }, onSuccessTaskId: { type: "string" }, onFailureTaskId: { type: "string" }, context: { type: "object", additionalProperties: true, description: "Initial context for chain interpolation" } } } } } }, responses: { "201": { description: "Task created" }, "400": { description: "Validation error" } } },
             },
             "/api/tasks/{id}": {
                 get: { summary: "Get a task", tags: ["Tasks"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Task details" }, "404": { description: "Not found" } } },
                 patch: { summary: "Update a task", tags: ["Tasks"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], requestBody: { content: { "application/json": { schema: { type: "object" } } } }, responses: { "200": { description: "Updated" }, "404": { description: "Not found" } } },
                 delete: { summary: "Delete a task", tags: ["Tasks"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Deleted" }, "404": { description: "Not found" } } },
             },
+            "/api/task-chains": { post: { summary: "Create a chain of tasks", tags: ["Task Chains"], requestBody: { content: { "application/json": { schema: { type: "object", required: ["tasks"], properties: { tasks: { type: "array", items: { type: "object", properties: { id: { type: "string" }, name: { type: "string" }, command: { type: "string" }, commandArgs: { type: "array", items: { type: "string" } }, onSuccessTaskId: { type: "string" }, onFailureTaskId: { type: "string" } } } }, chain: { type: "string", enum: ["sequential-success", "sequential-failure", "none"], description: "How to wire tasks together" } } } } } }, responses: { "201": { description: "Chain created", content: { "application/json": { schema: { type: "object", properties: { taskIds: { type: "array", items: { type: "string" } } } } } } }, "400": { description: "Validation error or rollback" } } } },
             "/api/projects": {
                 get: { summary: "List all projects", tags: ["Projects"], responses: { "200": { description: "Array of projects" } } },
-                post: { summary: "Create a project", tags: ["Projects"], requestBody: { content: { "application/json": { schema: { type: "object", properties: { name: { type: "string" }, color: { type: "string" } } } } } }, responses: { "201": { description: "Project created" }, "400": { description: "Validation error" } } },
+                post: { summary: "Create a project", tags: ["Projects"], requestBody: { content: { "application/json": { schema: { type: "object", properties: { name: { type: "string" }, color: { type: "string" }, directory: { type: "string", description: "Optional local working directory for loops" }, githubSource: { type: "string", description: "Optional GitHub repository in owner/repo format (e.g. CKGrafico/loop-task)" } } } } } }, responses: { "201": { description: "Project created" }, "400": { description: "Validation error" } } },
             },
             "/api/projects/{id}": {
-                patch: { summary: "Update a project", tags: ["Projects"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], requestBody: { content: { "application/json": { schema: { type: "object", properties: { name: { type: "string" }, color: { type: "string" } } } } } }, responses: { "200": { description: "Updated" }, "404": { description: "Not found" }, "400": { description: "Validation error" } } },
+                patch: { summary: "Update a project", tags: ["Projects"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], requestBody: { content: { "application/json": { schema: { type: "object", properties: { name: { type: "string" }, color: { type: "string" }, directory: { type: "string", description: "Optional local working directory for loops" }, githubSource: { type: "string", description: "Optional GitHub repository in owner/repo format (e.g. CKGrafico/loop-task)" } } } } } }, responses: { "200": { description: "Updated" }, "404": { description: "Not found" }, "400": { description: "Validation error" } } },
                 delete: { summary: "Delete a project", tags: ["Projects"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Deleted" }, "400": { description: "Cannot delete system project" } } },
             },
+            "/api/settings": { get: { summary: "Get daemon settings", tags: ["Settings"], responses: { "200": { description: "Current settings", content: { "application/json": { schema: { type: "object", properties: { httpApiEnabled: { type: "boolean" }, mcpApiEnabled: { type: "boolean" } } } } } } } }, patch: { summary: "Update daemon settings", tags: ["Settings"], requestBody: { content: { "application/json": { schema: { type: "object", properties: { httpApiEnabled: { type: "boolean" }, mcpApiEnabled: { type: "boolean" } } } } } }, responses: { "200": { description: "Updated settings", content: { "application/json": { schema: { type: "object", properties: { httpApiEnabled: { type: "boolean" }, mcpApiEnabled: { type: "boolean" } } } } } }, "400": { description: "Validation error" } } } },
             "/api/events": { get: { summary: "Subscribe to daemon events via SSE", tags: ["Events"], responses: { "200": { description: "SSE event stream" } } } },
             "/api/openapi.json": { get: { summary: "OpenAPI 3.0 spec", tags: ["Docs"], responses: { "200": { description: "OpenAPI JSON spec" } } } },
             "/api/docs": { get: { summary: "Swagger UI", tags: ["Docs"], responses: { "200": { description: "HTML page" } } } },
         },
+        components: {
+            schemas: {
+                DaemonSettings: {
+                    type: "object",
+                    properties: {
+                        httpApiEnabled: { type: "boolean", description: "Whether the HTTP API server is enabled" },
+                        mcpApiEnabled: { type: "boolean", description: "Whether the MCP server is enabled" },
+                    },
+                },
+            },
+        },
     };
 }
 export function buildSwaggerHtml() {