loop-task 2.1.12 → 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

@@ -187,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")
@@ -221,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" });
@@ -235,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);
         }
     }
 });
@@ -323,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

@@ -24,7 +24,7 @@ export async function startLoop(options, intervalHuman) {
     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("  Note: manual loop  use 'trigger' to run on demand");
     }
     console.log();
     console.log(t("cli.startedHint"));
@@ -80,6 +80,9 @@ export async function showStatus(id) {
     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

@@ -9,10 +9,10 @@ export function validateContext(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` };
+            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: 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,
@@ -51,8 +57,9 @@ export function executeChain(options) {
             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, logStream, signal, runCount, shouldCaptureStdout)));
+                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") {
@@ -74,7 +81,7 @@ export function executeChain(options) {
                     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 = chainExitCode;

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;
@@ -185,6 +193,7 @@ export class LoopController extends EventEmitter {
             remainingDelayMs: this.remainingDelayMs,
             runHistory: this.runHistory,
             skippedCount: this.skippedCount,
+            silentChainCount: this._silentChainCount,
         };
     }
     clearMaxRunsReached() {

package/dist/daemon/http/openapi.js

@@ -10,6 +10,17 @@ 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" } } } } } },
@@ -22,9 +33,12 @@ 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" } } } },
@@ -37,18 +51,31 @@ export function buildOpenApiSpec() {
                 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() {

package/dist/daemon/http/route-loops.js

@@ -108,6 +108,22 @@ export function registerLoopRoutes(manager, routes, r) {
         }
         sendOk(res);
     });
+    r("POST", "/api/loops/:id/play", (_req, res, params) => {
+        if (manager.isMaxRunsBlocked(params.id)) {
+            sendError(res, 409, "Max runs reached");
+            return;
+        }
+        if (manager.isRunning(params.id)) {
+            sendError(res, 409, "Loop is already running");
+            return;
+        }
+        if (!manager.playLoop(params.id)) {
+            sendNotFound(res, params.id);
+            return;
+        }
+        const meta = manager.status(params.id);
+        sendOk(res, meta);
+    });
     r("POST", "/api/loops/:id/trigger", (_req, res, params) => {
         if (manager.isMaxRunsBlocked(params.id)) {
             sendError(res, 400, "Max runs reached");
@@ -134,6 +150,75 @@ export function registerLoopRoutes(manager, routes, r) {
         const count = manager.stopAllLoops();
         sendOk(res, { count });
     });
+    // --- Run History ---
+    r("GET", "/api/loops/:id/runs", (_req, res, params) => {
+        const meta = manager.status(params.id);
+        if (!meta) {
+            sendNotFound(res, params.id);
+            return;
+        }
+        const query = parseQuery(_req.url);
+        const fromStr = query.get("from");
+        const toStr = query.get("to");
+        let runs = meta.runHistory;
+        if (fromStr) {
+            const fromMs = new Date(fromStr).getTime();
+            if (!Number.isNaN(fromMs)) {
+                runs = runs.filter((r) => new Date(r.startedAt).getTime() >= fromMs);
+            }
+        }
+        if (toStr) {
+            const toMs = new Date(toStr).getTime();
+            if (!Number.isNaN(toMs)) {
+                runs = runs.filter((r) => new Date(r.startedAt).getTime() <= toMs);
+            }
+        }
+        sendOk(res, runs);
+    });
+    // --- Date-Filtered Logs ---
+    r("GET", "/api/loops/:id/logs/date", (_req, res, params) => {
+        const meta = manager.status(params.id);
+        if (!meta) {
+            sendNotFound(res, params.id);
+            return;
+        }
+        const query = parseQuery(_req.url);
+        const fromStr = query.get("from");
+        const toStr = query.get("to");
+        if (!fromStr || !toStr) {
+            sendError(res, 400, "Both 'from' and 'to' query parameters are required (ISO 8601)");
+            return;
+        }
+        const fromMs = new Date(fromStr).getTime();
+        const toMs = new Date(toStr).getTime();
+        if (Number.isNaN(fromMs) || Number.isNaN(toMs)) {
+            sendError(res, 400, "Invalid date format for 'from' or 'to' (use ISO 8601)");
+            return;
+        }
+        const logPath = manager.getLogPath(params.id);
+        if (!logPath || !fs.existsSync(logPath)) {
+            sendOk(res, "");
+            return;
+        }
+        const matching = meta.runHistory.filter((r) => {
+            const t = new Date(r.startedAt).getTime();
+            return t >= fromMs && t <= toMs;
+        });
+        if (matching.length === 0) {
+            sendOk(res, "");
+            return;
+        }
+        matching.sort((a, b) => a.logOffset - b.logOffset);
+        const buffer = fs.readFileSync(logPath);
+        const allSorted = meta.runHistory.slice().sort((a, b) => a.logOffset - b.logOffset);
+        const parts = matching.map((record) => {
+            const start = record.logOffset;
+            const idx = allSorted.indexOf(record);
+            const end = idx < allSorted.length - 1 ? allSorted[idx + 1].logOffset : buffer.length;
+            return buffer.toString("utf-8", start, end);
+        });
+        sendOk(res, parts.join(""));
+    });
     // --- Logs ---
     r("GET", "/api/loops/:id/logs", (_req, res, params) => {
         const logPath = manager.getLogPath(params.id);

package/dist/daemon/http/route-misc.js

@@ -1,5 +1,6 @@
 import { initSseResponse } from "./sse.js";
 import { buildOpenApiSpec, buildSwaggerHtml } from "./openapi.js";
+import { sendOk, sendError, readBody } from "./helpers.js";
 export function registerMiscRoutes(sseClients, r) {
     r("GET", "/api/openapi.json", (_req, res) => {
         const spec = buildOpenApiSpec();
@@ -34,3 +35,18 @@ export function registerMiscRoutes(sseClients, r) {
         });
     });
 }
+export function registerSettingsRoutes(settingsManager, r) {
+    r("GET", "/api/settings", (_req, res) => {
+        sendOk(res, settingsManager.get());
+    });
+    r("PATCH", "/api/settings", async (req, res) => {
+        try {
+            const body = await readBody(req);
+            const updated = settingsManager.set(body);
+            sendOk(res, updated);
+        }
+        catch (err) {
+            sendError(res, 400, err instanceof Error ? err.message : String(err));
+        }
+    });
+}

package/dist/daemon/http/route-projects.js

@@ -10,7 +10,7 @@ export function registerProjectRoutes(projectManager, r) {
                 sendError(res, 400, "Project name is required");
                 return;
             }
-            const project = projectManager.create(body.name.trim(), body.color ?? "#ffffff");
+            const project = projectManager.create(body.name.trim(), body.color ?? "#ffffff", body.directory, body.githubSource);
             sendOk(res, project, 201);
         }
         catch (err) {
@@ -24,7 +24,7 @@ export function registerProjectRoutes(projectManager, r) {
                 sendError(res, 400, "Project name is required");
                 return;
             }
-            projectManager.update(params.id, body.name.trim(), body.color);
+            projectManager.update(params.id, body.name.trim(), body.color, body.directory, body.githubSource);
             sendOk(res);
         }
         catch (err) {

package/dist/daemon/http/route-tasks.js

@@ -67,4 +67,62 @@ export function registerTaskRoutes(taskManager, r) {
         }
         sendOk(res);
     });
+    r("POST", "/api/task-chains", async (req, res) => {
+        try {
+            const body = await readBody(req);
+            if (!body.tasks || !Array.isArray(body.tasks) || body.tasks.length === 0) {
+                sendError(res, 400, "tasks array must not be empty");
+                return;
+            }
+            if (body.chain && body.chain !== "sequential-success" && body.chain !== "sequential-failure" && body.chain !== "none") {
+                sendError(res, 400, `Invalid chain mode: "${body.chain}". Must be "sequential-success", "sequential-failure", or "none"`);
+                return;
+            }
+            for (const task of body.tasks) {
+                if (!task.name?.trim()) {
+                    sendError(res, 400, "Each task must have a name");
+                    return;
+                }
+                if (!task.command?.trim()) {
+                    sendError(res, 400, "Each task must have a command");
+                    return;
+                }
+            }
+            const created = [];
+            try {
+                for (const taskInput of body.tasks) {
+                    const task = taskManager.create(taskInput);
+                    created.push(task);
+                }
+                const chainMode = body.chain ?? "none";
+                if (chainMode === "sequential-success") {
+                    for (let i = 0; i < created.length - 1; i++) {
+                        taskManager.update(created[i].id, {
+                            ...created[i],
+                            onSuccessTaskId: created[i + 1].id,
+                        });
+                    }
+                }
+                else if (chainMode === "sequential-failure") {
+                    for (let i = 0; i < created.length - 1; i++) {
+                        taskManager.update(created[i].id, {
+                            ...created[i],
+                            onFailureTaskId: created[i + 1].id,
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                for (const task of created) {
+                    taskManager.delete(task.id);
+                }
+                sendError(res, 400, err instanceof Error ? err.message : String(err));
+                return;
+            }
+            sendOk(res, { taskIds: created.map((t) => t.id) }, 201);
+        }
+        catch (err) {
+            sendError(res, 400, err instanceof Error ? err.message : String(err));
+        }
+    });
 }

package/dist/daemon/http/routes.js

@@ -1,9 +1,9 @@
 import { registerLoopRoutes } from "./route-loops.js";
 import { registerTaskRoutes } from "./route-tasks.js";
 import { registerProjectRoutes } from "./route-projects.js";
-import { registerMiscRoutes } from "./route-misc.js";
+import { registerMiscRoutes, registerSettingsRoutes } from "./route-misc.js";
 export function registerRoutes(deps) {
-    const { manager, taskManager, projectManager, sseClients } = deps;
+    const { manager, taskManager, projectManager, sseClients, settingsManager } = deps;
     const routes = [];
     const r = (method, path, handler) => {
         const segments = path.split("/").filter((s) => s.length > 0);
@@ -13,5 +13,6 @@ export function registerRoutes(deps) {
     registerTaskRoutes(taskManager, r);
     registerProjectRoutes(projectManager, r);
     registerMiscRoutes(sseClients, r);
+    registerSettingsRoutes(settingsManager, r);
     return routes;
 }

package/dist/daemon/http/server.js

@@ -5,18 +5,21 @@ import { sendError, matchRoute, parsePath } from "./helpers.js";
 import { SseClientSet } from "./sse.js";
 import { registerRoutes } from "./routes.js";
 export class HttpApiServer {
-    constructor(manager, taskManager, projectManager) {
+    constructor(manager, taskManager, projectManager, settingsManager) {
         this.manager = manager;
         this.taskManager = taskManager;
         this.projectManager = projectManager;
+        this.settingsManager = settingsManager;
         this.routes = [];
         this.sseClients = new SseClientSet();
+        this.isListening = false;
         this.server = http.createServer((req, res) => this.handleRequest(req, res));
         this.routes = registerRoutes({
             manager: this.manager,
             taskManager: this.taskManager,
             projectManager: this.projectManager,
             sseClients: this.sseClients,
+            settingsManager: this.settingsManager,
         });
     }
     async listen(port = HTTP_API_PORT, host = HTTP_API_HOST) {
@@ -31,17 +34,32 @@ export class HttpApiServer {
                 }
             });
             this.server.listen(port, host, () => {
+                this.isListening = true;
                 daemonLog(`HTTP API server listening on ${host}:${port}`);
                 resolve();
             });
         });
     }
     async close() {
+        if (!this.isListening)
+            return;
+        this.isListening = false;
         this.sseClients.destroyAll();
         return new Promise((resolve) => {
-            this.server.close(() => resolve());
+            this.server.close(() => {
+                resolve();
+            });
+            // Node's server.close() stops accepting new connections but leaves
+            // existing keep-alive sockets open, so a browser tab (e.g. Swagger UI)
+            // keeps being served on its persistent connection. Force them closed so
+            // the port is actually released when the API is toggled off.
+            this.server.closeAllConnections?.();
         });
     }
+    async restart(port = HTTP_API_PORT, host = HTTP_API_HOST) {
+        await this.close();
+        await this.listen(port, host);
+    }
     broadcastEvent(event, data) {
         this.sseClients.broadcast(event, data);
     }