loop-task 2.1.11 → 2.1.12

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());

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,7 +76,8 @@ 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 }));
     console.log(t("cli.statusCreated", { created: loop.createdAt }));

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

@@ -39,28 +39,54 @@ 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;
+            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)));
+                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 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

@@ -58,6 +58,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 +119,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;

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

@@ -13,7 +13,7 @@ export function buildOpenApiSpec() {
         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" } } },
@@ -30,7 +30,7 @@ export function buildOpenApiSpec() {
             "/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" } } },

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

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import { LOG_TAIL_DEFAULT } from "../../shared/config/constants.js";
 import { tail } from "../../shared/tail.js";
 import { buildLoopOptions } from "../../loop-config.js";
+import { validateContext } from "../../core/context/validate-context.js";
 import { sendOk, sendError, sendNotFound, parseQuery, readBody } from "./helpers.js";
 export function registerLoopRoutes(manager, routes, r) {
     r("GET", "/api/loops", (_req, res) => {
@@ -18,6 +19,15 @@ export function registerLoopRoutes(manager, routes, r) {
     r("POST", "/api/loops", async (req, res) => {
         try {
             const body = await readBody(req);
+            let context;
+            if (body.context !== undefined) {
+                const result = validateContext(body.context);
+                if (!result.valid) {
+                    sendError(res, 400, result.error);
+                    return;
+                }
+                context = result.context;
+            }
             const intervalHuman = body.intervalHuman ?? "5m";
             const { options } = buildLoopOptions(intervalHuman, {
                 command: body.command,
@@ -30,6 +40,7 @@ export function registerLoopRoutes(manager, routes, r) {
                 description: body.description,
                 projectId: body.projectId,
                 offset: body.offset,
+                context,
             });
             const id = manager.start(options, intervalHuman);
             sendOk(res, { id }, 201);
@@ -41,6 +52,15 @@ export function registerLoopRoutes(manager, routes, r) {
     r("PATCH", "/api/loops/:id", async (req, res, params) => {
         try {
             const body = await readBody(req);
+            let context;
+            if (body.context !== undefined) {
+                const result = validateContext(body.context);
+                if (!result.valid) {
+                    sendError(res, 400, result.error);
+                    return;
+                }
+                context = result.context;
+            }
             const intervalHuman = body.intervalHuman ?? "5m";
             const { options } = buildLoopOptions(intervalHuman, {
                 command: body.command,
@@ -53,6 +73,7 @@ export function registerLoopRoutes(manager, routes, r) {
                 description: body.description,
                 projectId: body.projectId,
                 offset: body.offset,
+                context,
             });
             const ok = await manager.update(params.id, options, intervalHuman);
             if (!ok) {

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

@@ -1,3 +1,4 @@
+import { validateContext } from "../../core/context/validate-context.js";
 import { sendOk, sendError, sendNotFound, readBody } from "./helpers.js";
 export function registerTaskRoutes(taskManager, r) {
     r("GET", "/api/tasks", (_req, res) => {
@@ -22,6 +23,14 @@ export function registerTaskRoutes(taskManager, r) {
                 sendError(res, 400, "Task command is required");
                 return;
             }
+            if (body.context !== undefined) {
+                const result = validateContext(body.context);
+                if (!result.valid) {
+                    sendError(res, 400, result.error);
+                    return;
+                }
+                body.context = result.context;
+            }
             const task = taskManager.create(body);
             sendOk(res, task, 201);
         }
@@ -32,6 +41,14 @@ export function registerTaskRoutes(taskManager, r) {
     r("PATCH", "/api/tasks/:id", async (req, res, params) => {
         try {
             const body = await readBody(req);
+            if (body.context !== undefined) {
+                const result = validateContext(body.context);
+                if (!result.valid) {
+                    sendError(res, 400, result.error);
+                    return;
+                }
+                body.context = result.context;
+            }
             const updated = taskManager.update(params.id, body);
             if (!updated) {
                 sendNotFound(res, params.id);

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

@@ -12,5 +12,6 @@ export function buildLoopOptions(meta) {
         description: meta.description ?? "",
         projectId: meta.projectId ?? "default",
         offset: meta.offset ?? null,
+        context: meta.context,
     };
 }

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

@@ -27,6 +27,7 @@ export function toMeta(controller, options, intervalHuman, taskManager) {
         pid: process.pid,
         projectId: options.projectId ?? "default",
         offset: options.offset,
+        context: options.context,
     };
 }
 export function persistLoop(id, controller, options, intervalHuman, taskManager, lastSerialized) {

package/dist/duration.js

@@ -5,6 +5,9 @@ export function parseDuration(input) {
     if (!trimmed) {
         throw new Error(t("errors.durationEmpty"));
     }
+    if (trimmed === "manual" || trimmed === "0") {
+        return 0;
+    }
     const result = ms(trimmed);
     if (typeof result !== "number" || isNaN(result)) {
         throw new Error(t("errors.durationInvalid", { input }));
@@ -15,5 +18,7 @@ export function parseDuration(input) {
     return result;
 }
 export function formatDuration(value) {
+    if (value === 0)
+        return t("format.durationManual");
     return ms(value, { long: true });
 }

package/dist/entities/loops/filters.js

@@ -12,6 +12,8 @@ const statusOrder = {
     stopped: 4,
 };
 function intervalBucketOf(interval) {
+    if (interval === 0)
+        return "manual";
     if (interval <= 60_000)
         return "short";
     if (interval <= 3_600_000)

package/dist/features/forms/FormRouter.js

@@ -15,6 +15,7 @@ function createInitialValues(editTarget, currentProjectId) {
             runNow: "y",
             maxRuns: "",
             project: currentProjectId,
+            context: "",
         };
     }
     return {
@@ -27,6 +28,7 @@ function createInitialValues(editTarget, currentProjectId) {
         runNow: "y",
         maxRuns: editTarget.maxRuns?.toString() ?? "",
         project: editTarget.projectId ?? "default",
+        context: editTarget.context ? JSON.stringify(editTarget.context) : "",
     };
 }
 export function FormRouter(props) {

package/dist/loop-config.js

@@ -129,20 +129,24 @@ export function buildLoopOptions(intervalHuman, input = {}) {
     if (!description) {
         throw new Error(t("errors.descriptionEmpty"));
     }
+    const parsedInterval = parseDuration(intervalHuman);
+    const isManual = parsedInterval === 0;
+    const normalizedIntervalHuman = isManual ? "manual" : intervalHuman;
     return {
-        intervalHuman,
+        intervalHuman: normalizedIntervalHuman,
         options: {
-            interval: parseDuration(intervalHuman),
+            interval: parsedInterval,
             taskId,
             command,
             commandArgs,
             cwd: input.cwd ?? "",
-            immediate: input.now ?? false,
+            immediate: isManual ? false : (input.now ?? false),
             maxRuns: parseMaxRuns(input.maxRuns),
             verbose: input.verbose ?? false,
             description,
             projectId: input.projectId ?? "default",
             offset: input.offset ?? null,
+            context: input.context,
         },
     };
 }

package/dist/shared/i18n/en.json

@@ -4,7 +4,7 @@
     "cli.startDescription": "Start the background daemon (restores persisted loops)",
     "cli.newDescription": "Create a new loop in the background",
     "cli.runDescription": "Run a loop in the foreground",
-    "cli.argInterval": "Interval between runs (e.g. 30s, 5m, 1h)",
+    "cli.argInterval": "Interval between runs (e.g. 30s, 5m, 1h, or manual)",
     "cli.argCommand": "Command to execute",
     "cli.optNow": "Run immediately before waiting",
     "cli.optMaxRuns": "Stop after N executions",
@@ -83,7 +83,7 @@
     "loop.debugDuration": "Duration:    {duration}",
     "loop.nextRun": "Next run in {duration} (at {time})",
     "errors.durationEmpty": "Duration cannot be empty",
-    "errors.durationInvalid": "Invalid duration: \"{input}\". Use formats like 10s, 5m, 1h, 1d, 1w",
+    "errors.durationInvalid": "Invalid duration: \"{input}\". Use formats like 10s, 5m, 1h, 1d, 1w, or manual",
     "errors.durationNotPositive": "Duration must be positive, got: \"{input}\"",
     "errors.maxRunsInvalid": "--max-runs must be a positive integer",
     "errors.unbalancedQuote": "Unbalanced quote in command",
@@ -117,6 +117,7 @@
     "format.daysAhead": "{days}d",
     "format.timingPaused": "paused",
     "format.timingIdle": "not scheduled",
+    "format.durationManual": "manual trigger only",
     "format.timingNext": "in {timeAgo}",
     "format.timingLast": "last {timeAgo}",
     "format.timingNew": "new",
@@ -257,7 +258,7 @@
     "board.taskCreateTitle": " New Task ",
     "board.taskEditTitle": " Edit Task ",
     "board.hintTaskMode": "type a command inline, or pick an existing task",
-    "board.hintInterval": "How often to run, e.g. 30s, 5m, 30m, 1h, 1d",
+    "board.hintInterval": "How often to run, e.g. 30s, 5m, 30m, 1h, 1d, or manual",
     "board.hintCommand": "Full command line. Quote args with spaces",
     "board.hintDescription": "Short label shown in the list. Blank uses the command",
     "board.hintCwd": "Leave blank to inherit from project directory, or set a specific path",
@@ -574,7 +575,7 @@
     "wizard.newTask": "New task",
     "wizard.stepOf": "Step {current} of {total}",
     "wizard.intervalPrompt": "How often should it run?",
-    "wizard.intervalHint": "e.g. 30s, 5m, 30m, 1h, 1d",
+    "wizard.intervalHint": "e.g. 30s, 5m, 30m, 1h, 1d, or manual for trigger-only",
     "wizard.commandPrompt": "What command should run?",
     "wizard.commandHint": "Full command line. Quote args with spaces",
     "wizard.taskModePrompt": "Inline command or existing task?",
@@ -596,6 +597,9 @@
     "wizard.taskCommandPrompt": "What command should this task run?",
     "wizard.onSuccessPrompt": "On success, chain to? (optional)",
     "wizard.onFailurePrompt": "On failure, chain to? (optional)",
+    "wizard.contextPrompt": "Initial context? (optional)",
+    "wizard.contextHint": "JSON object with string values, e.g. {\"env\":\"staging\"}",
+    "wizard.contextInvalid": "Invalid context: must be a flat JSON object with non-nested, non-array values",
     "wizard.created": "Created",
     "wizard.filled": "{filled}/{total} filled",
     "wizard.footerHints": "tab next . ctrl+s save . esc cancel",

package/dist/shared/ui/format.js

@@ -66,6 +66,8 @@ export function statusColor(status) {
     return STATUS_COLORS[status] ?? "#ffffff";
 }
 export function timingLabel(loop) {
+    if (loop.interval === 0)
+        return t("format.durationManual");
     if (loop.status === "paused")
         return t("format.timingPaused");
     if (loop.status === "idle")

package/dist/widgets/loop-form/CreateForm.js

@@ -15,7 +15,9 @@ export function CreateView(props) {
     const [taskPickerOpen, setTaskPickerOpen] = useState(false);
     const [openSelect, setOpenSelect] = useState(null);
     const [commandEditorOpen, setCommandEditorOpen] = useState(false);
+    const [contextEditorOpen, setContextEditorOpen] = useState(false);
     const [commandValue, setCommandValue] = useState(initial.command ?? "");
+    const [contextValue, setContextValue] = useState(initial.context ?? "");
     const fieldCallbacksRef = useRef({});
     const taskModeInitial = initial.taskMode === "existing" ? "Existing task" : "Inline command";
     const resolvedTaskName = useMemo(() => {
@@ -32,10 +34,12 @@ export function CreateView(props) {
         selectedTaskId,
         resolvedTaskName,
         commandValue,
+        contextValue,
         projects: props.projects,
         setOpenSelect,
         setTaskPickerOpen,
         setCommandEditorOpen,
+        setContextEditorOpen,
         fieldCallbacksRef,
         taskModeInitial,
     });
@@ -61,7 +65,7 @@ export function CreateView(props) {
     const selectTitleFor = (field) => field === "taskMode" ? t("wizard.taskModePrompt")
         : field === "runNow" ? t("wizard.runNowPrompt")
             : t("wizard.projectPrompt");
-    return (_jsxs(_Fragment, { children: [_jsx(WizardForm, { title: mode === "edit" ? t("wizard.editLoop") : t("wizard.newLoop"), steps: steps, onComplete: handleComplete, onCancel: onCancel, disabled: taskPickerOpen || openSelect !== null || commandEditorOpen }), taskPickerOpen ? (_jsx(TaskPickerModal, { tasks: tasks, onSelect: (task) => {
+    return (_jsxs(_Fragment, { children: [_jsx(WizardForm, { title: mode === "edit" ? t("wizard.editLoop") : t("wizard.newLoop"), steps: steps, onComplete: handleComplete, onCancel: onCancel, disabled: taskPickerOpen || openSelect !== null || commandEditorOpen || contextEditorOpen }), taskPickerOpen ? (_jsx(TaskPickerModal, { tasks: tasks, onSelect: (task) => {
                     onChooseTask({ id: task.id, name: task.name });
                     setTaskPickerOpen(false);
                 }, onClose: () => setTaskPickerOpen(false) })) : null, openSelect ? (_jsx(SelectModal, { title: selectTitleFor(openSelect), options: selectOptionsFor(openSelect), initialValue: fieldCallbacksRef.current[openSelect]?.value, onSelect: (option) => {
@@ -71,5 +75,8 @@ export function CreateView(props) {
                 }, onClose: () => setOpenSelect(null) })) : null, commandEditorOpen ? (_jsx(CodeEditorModal, { initialValue: commandValue, onSave: (v) => {
                     setCommandValue(v);
                     setCommandEditorOpen(false);
-                }, onCancel: () => setCommandEditorOpen(false) })) : null] }));
+                }, onCancel: () => setCommandEditorOpen(false) })) : null, contextEditorOpen ? (_jsx(CodeEditorModal, { initialValue: contextValue, onSave: (v) => {
+                    setContextValue(v);
+                    setContextEditorOpen(false);
+                }, onCancel: () => setContextEditorOpen(false) })) : null] }));
 }

package/dist/widgets/loop-form/WizardForm.js

@@ -59,6 +59,9 @@ export function WizardForm(props) {
             const err = validateField(s.key, resolvedValues);
             if (err)
                 errors[s.key] = err;
+            if (s.validate && !s.validate(valueFor(s))) {
+                errors[s.key] = s.validationError ?? t("wizard.validationError");
+            }
         }
         if (Object.keys(errors).length > 0) {
             setValidationErrors(errors);
@@ -99,6 +102,13 @@ export function WizardForm(props) {
                 setError(step.key, err);
                 return;
             }
+            if (step.validate) {
+                const value = valueFor(step);
+                if (!step.validate(value)) {
+                    setError(step.key, step.validationError ?? t("wizard.validationError"));
+                    return;
+                }
+            }
             clearError(step.key);
         }
         const next = findNextField(activeField, delta);

package/dist/widgets/loop-form/useCreateSteps.js

@@ -3,8 +3,9 @@ import { useMemo } from "react";
 import { t } from "../../shared/i18n/index.js";
 import { SelectValueField } from "../../shared/ui/SelectModal.js";
 import { CodeEditorPreview } from "../../features/code-editor/CodeEditorPreview.js";
+import { validateContext } from "../../core/context/validate-context.js";
 export function useCreateSteps(params) {
-    const { initial, selectedTaskId, resolvedTaskName, commandValue, projects, setOpenSelect, setTaskPickerOpen, setCommandEditorOpen, fieldCallbacksRef, taskModeInitial, } = params;
+    const { initial, selectedTaskId, resolvedTaskName, commandValue, contextValue, projects, setOpenSelect, setTaskPickerOpen, setCommandEditorOpen, setContextEditorOpen, fieldCallbacksRef, taskModeInitial, } = params;
     return useMemo(() => {
         const list = [
             {
@@ -59,6 +60,10 @@ export function useCreateSteps(params) {
                 defaultValue: initial.runNow === "true" || initial.runNow === "yes"
                     ? t("wizard.runNowNow")
                     : t("wizard.runNowWait"),
+                skip: (values) => {
+                    const v = (values.interval ?? "").trim().toLowerCase();
+                    return v === "manual" || v === "0";
+                },
                 onActivate: () => setOpenSelect("runNow"),
                 renderCustom: ({ value, isActive, onChange, onAdvance }) => {
                     fieldCallbacksRef.current.runNow = { value, onChange, onAdvance };
@@ -101,7 +106,30 @@ export function useCreateSteps(params) {
                     return (_jsx(SelectValueField, { label: value || null, placeholder: t("wizard.projectPrompt"), isActive: isActive }));
                 },
             },
+            {
+                key: "context",
+                prompt: t("wizard.contextPrompt"),
+                hint: t("wizard.contextHint"),
+                required: false,
+                inputType: "text",
+                defaultValue: contextValue || undefined,
+                onActivate: () => setContextEditorOpen(true),
+                validate: (value) => {
+                    if (!value?.trim())
+                        return true;
+                    try {
+                        const parsed = JSON.parse(value);
+                        const result = validateContext(parsed);
+                        return result.valid;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                validationError: t("wizard.contextInvalid"),
+                renderCustom: ({ isActive }) => (_jsx(CodeEditorPreview, { value: contextValue, hint: t("wizard.contextHint"), isActive: isActive, onActivate: () => setContextEditorOpen(true) })),
+            },
         ];
         return list;
-    }, [taskModeInitial, selectedTaskId, resolvedTaskName, initial, commandValue, projects]);
+    }, [taskModeInitial, selectedTaskId, resolvedTaskName, initial, commandValue, contextValue, projects]);
 }

package/dist/widgets/loop-form/useHandleComplete.js

@@ -2,6 +2,7 @@ import { useCallback } from "react";
 import { t } from "../../shared/i18n/index.js";
 import { parseDuration } from "../../duration.js";
 import { parseCommandLine, joinCommandLines } from "../../loop-config.js";
+import { validateContext } from "../../core/context/validate-context.js";
 export function useHandleComplete(params) {
     const { selectedTaskId, mode, editId, currentProjectId, onDone, commandValue, projects, loopService, } = params;
     return useCallback((values) => {
@@ -15,7 +16,8 @@ export function useHandleComplete(params) {
         catch {
             return;
         }
-        const intervalHuman = intervalInput.trim();
+        const isManual = interval === 0;
+        const intervalHuman = isManual ? "manual" : intervalInput.trim();
         const isExistingTask = !!values.taskMode?.includes("Existing");
         if (isExistingTask && !selectedTaskId && !values.taskId?.trim())
             return;
@@ -41,6 +43,20 @@ export function useHandleComplete(params) {
         const projectName = values.project ?? "";
         const project = projects.find((p) => p.name === projectName);
         const projectId = project?.id ?? currentProjectId;
+        let context;
+        const contextStr = (values.context ?? "").trim();
+        if (contextStr) {
+            try {
+                const parsed = JSON.parse(contextStr);
+                const result = validateContext(parsed);
+                if (result.valid) {
+                    context = result.context;
+                }
+            }
+            catch {
+                // invalid context, skip
+            }
+        }
         const options = {
             interval,
             taskId: isExistingTask
@@ -50,7 +66,7 @@ export function useHandleComplete(params) {
             commandArgs: args,
             commandRaw: isExistingTask ? undefined : cmdValue,
             cwd: (values.cwd ?? "").trim() || process.cwd(),
-            immediate: runNowValue,
+            immediate: isManual ? false : runNowValue,
             maxRuns: (values.maxRuns ?? "").trim()
                 ? parseInt(values.maxRuns, 10)
                 : null,
@@ -58,6 +74,7 @@ export function useHandleComplete(params) {
             description: (values.description ?? "").trim(),
             projectId,
             offset: null,
+            context,
         };
         const desc = (values.description ?? "").trim() || [cmdOnly, ...args].join(" ").trim();
         if (mode === "edit" && editId) {

package/dist/widgets/task-form/TaskForm.js

@@ -6,6 +6,7 @@ import { CodeEditorPreview } from "../../features/code-editor/CodeEditorPreview.
 import { CodeEditorModal } from "../../features/code-editor/CodeEditorModal.js";
 import { useInject } from "../../shared/hooks/useInject.js";
 import { TYPES } from "../../shared/services/types.js";
+import { validateContext } from "../../core/context/validate-context.js";
 import crypto from "node:crypto";
 import { t } from "../../shared/i18n/index.js";
 import { joinCommandLines, parseCommandLine } from "../../loop-config.js";
@@ -36,6 +37,8 @@ export function TaskForm(props) {
     const chainOptions = useMemo(() => [t("wizard.chainNone"), ...tasks.map((task) => task.name)], [tasks]);
     const chainSelectOptions = useMemo(() => chainOptions.map((v) => ({ value: v, label: v })), [chainOptions]);
     const [commandEditorOpen, setCommandEditorOpen] = useState(false);
+    const [contextEditorOpen, setContextEditorOpen] = useState(false);
+    const [contextValue, setContextValue] = useState(editTask?.context ? JSON.stringify(editTask.context) : "");
     const [openChainField, setOpenChainField] = useState(null);
     const chainFieldsRef = useRef({});
     const resolveChainId = useCallback((val) => {
@@ -94,9 +97,32 @@ export function TaskForm(props) {
                     return (_jsx(SelectValueField, { label: value || null, placeholder: t("wizard.onFailurePrompt"), isActive: isActive }));
                 },
             },
+            {
+                key: "context",
+                prompt: t("wizard.contextPrompt"),
+                hint: t("wizard.contextHint"),
+                required: false,
+                inputType: "text",
+                defaultValue: contextValue || undefined,
+                onActivate: () => setContextEditorOpen(true),
+                validate: (value) => {
+                    if (!value?.trim())
+                        return true;
+                    try {
+                        const parsed = JSON.parse(value);
+                        const result = validateContext(parsed);
+                        return result.valid;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                validationError: t("wizard.contextInvalid"),
+                renderCustom: ({ isActive }) => (_jsx(CodeEditorPreview, { value: contextValue, hint: t("wizard.contextHint"), isActive: isActive, onActivate: () => setContextEditorOpen(true) })),
+            },
         ];
         return list;
-    }, [commandValue, chainOptions, editTask, resolveChainName]);
+    }, [commandValue, chainOptions, editTask, resolveChainName, contextValue]);
     const handleComplete = useCallback((values) => {
         const name = values.name?.trim() ?? "";
         const rawCommand = joinCommandLines(commandValue);
@@ -104,6 +130,20 @@ export function TaskForm(props) {
             return;
         const onSuccessTaskId = resolveChainId(values.onSuccess ?? "");
         const onFailureTaskId = resolveChainId(values.onFailure ?? "");
+        let context;
+        const contextStr = contextValue?.trim();
+        if (contextStr) {
+            try {
+                const parsed = JSON.parse(contextStr);
+                const result = validateContext(parsed);
+                if (result.valid) {
+                    context = result.context;
+                }
+            }
+            catch {
+                // invalid context, skip
+            }
+        }
         const commandSegments = commandValue
             .split(/\n&&\n|\n&&|&&\n|&&/)
             .map(s => s.trim())
@@ -136,6 +176,7 @@ export function TaskForm(props) {
                 steps,
                 onSuccessTaskId,
                 onFailureTaskId,
+                context,
             };
         }
         else {
@@ -146,6 +187,7 @@ export function TaskForm(props) {
                 commandRaw: commandValue,
                 onSuccessTaskId,
                 onFailureTaskId,
+                context,
             };
         }
         if (mode === "edit" && editTask) {
@@ -159,16 +201,19 @@ export function TaskForm(props) {
                 .then((result) => onDone(false, result.id))
                 .catch(() => { });
         }
-    }, [commandValue, resolveChainId, mode, editTask, onDone]);
+    }, [commandValue, resolveChainId, mode, editTask, onDone, contextValue]);
     const title = mode === "edit"
         ? t("board.taskEditTitle")
         : t("board.taskCreateTitle");
-    return (_jsxs(_Fragment, { children: [_jsx(WizardForm, { title: title, steps: steps, onComplete: handleComplete, onCancel: onCancel, disabled: openChainField !== null || commandEditorOpen }), openChainField ? (_jsx(SelectModal, { title: openChainField === "onSuccess" ? t("wizard.onSuccessPrompt") : t("wizard.onFailurePrompt"), options: chainSelectOptions, initialValue: chainFieldsRef.current[openChainField]?.value, onSelect: (option) => {
+    return (_jsxs(_Fragment, { children: [_jsx(WizardForm, { title: title, steps: steps, onComplete: handleComplete, onCancel: onCancel, disabled: openChainField !== null || commandEditorOpen || contextEditorOpen }), openChainField ? (_jsx(SelectModal, { title: openChainField === "onSuccess" ? t("wizard.onSuccessPrompt") : t("wizard.onFailurePrompt"), options: chainSelectOptions, initialValue: chainFieldsRef.current[openChainField]?.value, onSelect: (option) => {
                     chainFieldsRef.current[openChainField]?.onChange(option.value);
                     chainFieldsRef.current[openChainField]?.onAdvance();
                     setOpenChainField(null);
                 }, onClose: () => setOpenChainField(null) })) : null, commandEditorOpen ? (_jsx(CodeEditorModal, { initialValue: commandValue, onSave: (v) => {
                     setCommandValue(v);
                     setCommandEditorOpen(false);
-                }, onCancel: () => setCommandEditorOpen(false) })) : null] }));
+                }, onCancel: () => setCommandEditorOpen(false) })) : null, contextEditorOpen ? (_jsx(CodeEditorModal, { initialValue: contextValue, onSave: (v) => {
+                    setContextValue(v);
+                    setContextEditorOpen(false);
+                }, onCancel: () => setContextEditorOpen(false) })) : null] }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loop-task",
-  "version": "2.1.11",
+  "version": "2.1.12",
   "description": "Loop engineering toolkit. Run any command on a cadence, in the background, managed from a terminal board. Schedule tests, builds, syncs, or agent prompts.",
   "type": "module",
   "bin": {