@plainconceptsplatform/loop-task 2.6.0 → 2.6.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Quique Fdez Guerra
+Copyright (c) 2026 Plain Concepts
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -5,14 +5,14 @@
 
 **Loop engineering for your terminal. Run any command on a cadence.**
 
-`@plainconceptsplatform/loop-task` is a cross-platform CLI that runs shell commands at human-readable intervals. Create loops in the background, manage them from an interactive TUI board, or run them in the foreground. It is the **heartbeat** primitive for [loop engineering](#loop-engineering): instead of running a task by hand every time, you schedule it once and let it run.
+`loop-task` is a cross-platform CLI that runs shell commands at human-readable intervals. Create loops in the background, manage them from an interactive TUI board, or run them in the foreground. It is the **heartbeat** primitive for [loop engineering](#loop-engineering): instead of running a task by hand every time, you schedule it once and let it run.
 
-**[loop.ckgrafico.com](https://loop.ckgrafico.com)**
+**[plainconceptsplatform.github.io/loop-task](https://plainconceptsplatform.github.io/loop-task)**
 
-[![npm version](https://img.shields.io/npm/v/@plainconceptsplatform/loop-task?style=flat-square&color=black)](https://www.npmjs.com/package/@plainconceptsplatform/loop-task)
-[![npm downloads](https://img.shields.io/npm/dm/@plainconceptsplatform/loop-task?style=flat-square&color=black)](https://www.npmjs.com/package/@plainconceptsplatform/loop-task)
-[![license](https://img.shields.io/npm/l/@plainconceptsplatform/loop-task?style=flat-square&color=black)](./LICENSE)
-[![node](https://img.shields.io/node/v/@plainconceptsplatform/loop-task?style=flat-square&color=black)](https://nodejs.org)
+[![npm version](https://img.shields.io/npm/v/loop-task?style=flat-square&color=black)](https://www.npmjs.com/package/loop-task)
+[![npm downloads](https://img.shields.io/npm/dm/loop-task?style=flat-square&color=black)](https://www.npmjs.com/package/loop-task)
+[![license](https://img.shields.io/npm/l/loop-task?style=flat-square&color=black)](./LICENSE)
+[![node](https://img.shields.io/node/v/loop-task?style=flat-square&color=black)](https://nodejs.org)
 
 </div>
 
@@ -23,7 +23,7 @@
 `loop-task` is that heartbeat as a tiny local primitive. Some examples:
 
 <div align="center">
-<img src="https://raw.githubusercontent.com/plainconceptsplatform/loop-task/refs/heads/main/demo.gif" alt="loop-task demo" width="700" />
+<img src="https://raw.githubusercontent.com/PlainConceptsPlatform/loop-task/refs/heads/main/demo.gif" alt="loop-task demo" width="700" />
 </div>
 
 ```bash
@@ -47,7 +47,7 @@ No cron files to maintain and no daemon to babysit: loops persist across reboots
 ## Quick start
 
 ```bash
-npm install -g @plainconceptsplatform/loop-task
+npm install -g loop-task
 loop-task                          # open the board
 loop-task start                    # start the daemon, restore persisted loops
 loop-task new 30m -- npm test      # create a background loop
@@ -60,28 +60,28 @@ loop-task api                      # show HTTP API endpoints (Swagger, OpenAPI)
 Or run it directly:
 
 ```bash
-npx @plainconceptsplatform/loop-task
-npx @plainconceptsplatform/loop-task new 30m -- npm test
-```
-
-## Agent skills
-
-Install the public Loop Task skills with:
-
-```bash
-npx skills add plainconceptsplatform/loop-task
-```
-
-The repository also contains internal development skills under `.agents/skills/`.
-They are marked internal automatically by the repository pre-commit hook and are
-not intended for installation by Loop Task users.
-
-## Requirements
+npx loop-task
+npx loop-task new 30m -- npm test
+```
+
+## Agent skills
+
+Install the public Loop Task skills with:
+
+```bash
+npx skills add PlainConceptsPlatform/loop-task
+```
+
+The repository also contains internal development skills under `.agents/skills/`.
+They are marked internal automatically by the repository pre-commit hook and are
+not intended for installation by Loop Task users.
+
+## Requirements
 
 - **Node.js >= 20** - required for all commands including the board
 
 ```bash
-npm install -g @plainconceptsplatform/loop-task
+npm install -g loop-task
 ```
 
 All commands (`start`, `new`, `run`, `board`) work with Node alone.
@@ -284,15 +284,15 @@ When tasks are arranged in a chain (on-success or on-failure), context flows bet
 
 ### How it works
 
-1. **Auto-capture** - stdout and stderr from every task in the chain are captured before the next task starts.
-2. **Parse rules** - stdout is parsed by content type:
-    - **JSON object** (`{"key": "value"}`) - each key is merged into the shared context.
+1. **Auto-capture** - stdout and stderr from every task in the chain are captured before the next task starts.
+2. **Parse rules** - stdout is parsed by content type:
+    - **JSON object** (`{"key": "value"}`) - each key is merged into the shared context.
    - **JSONL** (one JSON object per line) - each line's keys are merged in order.
-    - **Plain text** - stored under a single `output` key.
+    - **Plain text** - stored under a single `output` key.
    - **Empty output** - no change to context.
 3. **Template interpolation** - use `{{key}}` in the command or arguments of any task. Before spawning, `{{key}}` is replaced with the current value of `key` from the shared context.
 4. **Merge semantics** - keys accumulate across the chain. Task 1 produces `{ "id": "42" }`, task 2 can use `{{id}}` and also add `{ "status": "ok" }`. Task 3 sees both.
-5. **Latest command output** - `{{output}}` always contains stdout plus stderr from the immediately preceding task. JSON fields such as `{{number}}`, `{{title}}`, and `{{body}}` remain available until a later task explicitly emits the same key.
+5. **Latest command output** - `{{output}}` always contains stdout plus stderr from the immediately preceding task. JSON fields such as `{{number}}`, `{{title}}`, and `{{body}}` remain available until a later task explicitly emits the same key.
 6. **Context lifecycle** - context is built fresh each loop iteration and exists only in memory. It is never persisted to disk.
 
 ### Example: Issue Refinement Chain

package/dist/client/project-commands.js

@@ -74,7 +74,7 @@ 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)`);
+                throw new Error(`Invalid github-source format: "${githubSource}". Expected owner/repo (e.g. PlainConceptsPlatform/loop-task)`);
             }
         }
         const color = colorInput ? resolveColor(colorInput) : PROJECT_COLORS.cyan;

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

@@ -8,6 +8,7 @@ import { StdoutCaptureTransform } from "./stdout-capture-transform.js";
 import { killProcessTree } from "./process-tree.js";
 import { getAgentIntegrations } from "../../daemon/telemetry/agent-integrations/index.js";
 import { getDataDir } from "../../shared/config/paths.js";
+import { parseOpencodeJsonOutput } from "../context/opencode-json-parser.js";
 function quoteArg(arg) {
     if (arg.length === 0)
         return "''";
@@ -82,8 +83,6 @@ export async function executeCommand(command, commandArgs, cwd, logStream, signa
         logStream.write(t("loop.exitMarker", { code: 1, duration: formatDuration(0) }));
         return { exitCode: 1, duration: 0, startedAt, endedAt };
     }
-    const shellCommand = formatCommandLine(command, commandArgs);
-    const needShell = /(\$\(|`|&&|\|\||;|>|<|\|)/.test(shellCommand);
     // Per-task telemetry override: skip telemetry for this command entirely
     const taskTelemetryDisabled = telemetryCtx?.telemetryConfig?.enabled === false;
     // Telemetry: create command span and prepare child env
@@ -121,6 +120,56 @@ export async function executeCommand(command, commandArgs, cwd, logStream, signa
             commandSpan.setAttribute("loop_task.agent.integration", detectedIntegrationId);
         }
     }
+    // Serve lifecycle: if an agent integration with serve support is detected,
+    // ensure the serve sidecar is running and inject --attach + --dir into args.
+    let effectiveCommand = command;
+    let effectiveArgs = commandArgs;
+    if (detectedIntegrationId) {
+        const allIntegrations = getAgentIntegrations();
+        const integration = allIntegrations.find((i) => i.id === detectedIntegrationId);
+        if (integration?.ensureServe && integration?.isServeAlive && integration?.prepareRunArgs) {
+            try {
+                // Ensure serve is started (no-op if already running)
+                const serveEnv = {};
+                // If we have telemetry env with OTEL config, pass it to serve
+                if (telemetryEnv.OTEL_EXPORTER_OTLP_ENDPOINT) {
+                    serveEnv.OTEL_EXPORTER_OTLP_ENDPOINT = telemetryEnv.OTEL_EXPORTER_OTLP_ENDPOINT;
+                    serveEnv.OTEL_EXPORTER_OTLP_PROTOCOL = telemetryEnv.OTEL_EXPORTER_OTLP_PROTOCOL ?? "http/protobuf";
+                    serveEnv.OTEL_TRACES_EXPORTER = "otlp";
+                    serveEnv.OTEL_METRICS_EXPORTER = "otlp";
+                    serveEnv.OTEL_LOGS_EXPORTER = "otlp";
+                    if (telemetryEnv.OTEL_RESOURCE_ATTRIBUTES) {
+                        serveEnv.OTEL_RESOURCE_ATTRIBUTES = telemetryEnv.OTEL_RESOURCE_ATTRIBUTES;
+                    }
+                    if (telemetryEnv.OPENCODE_EXPERIMENTAL_OPEN_TELEMETRY) {
+                        serveEnv.OPENCODE_EXPERIMENTAL_OPEN_TELEMETRY = telemetryEnv.OPENCODE_EXPERIMENTAL_OPEN_TELEMETRY;
+                    }
+                }
+                await integration.ensureServe(cwd || process.cwd(), serveEnv);
+                if (integration.isServeAlive()) {
+                    effectiveArgs = integration.prepareRunArgs(commandArgs, cwd || undefined);
+                    if (commandSpan) {
+                        commandSpan.setAttribute("loop_task.agent.serve_attached", true);
+                    }
+                }
+            }
+            catch (err) {
+                // Serve failure is non-fatal — fall back to cold start
+                if (commandSpan) {
+                    commandSpan.setAttribute("loop_task.agent.serve_error", String(err));
+                }
+            }
+        }
+    }
+    // Auto-inject --format json for opencode run so we can parse structured output
+    if (detectedIntegrationId === "opencode" && effectiveArgs[0] === "run") {
+        if (!effectiveArgs.includes("--format") && !effectiveArgs.includes("-f")) {
+            effectiveArgs = [...effectiveArgs.slice(0, 1), "--format", "json", ...effectiveArgs.slice(1)];
+        }
+    }
+    // Compute shell command after potential --attach injection
+    const shellCommand = formatCommandLine(effectiveCommand, effectiveArgs);
+    const needShell = /(\$\(|`|&&|\|\||;|>|<|\|)/.test(shellCommand);
     const baseEnv = childEnv();
     const fileEnv = loadEnvFile();
     const mergedEnv = {
@@ -194,6 +243,24 @@ export async function executeCommand(command, commandArgs, cwd, logStream, signa
         if (detectedIntegrationId && stdoutCapture) {
             tryParseAgentUsage(telemetryCtx.telemetry, detectedIntegrationId, { exitCode: result.exitCode ?? 0, stdout: stdoutCapture.getCaptured(), duration }, commandSpan);
         }
+        // Parse opencode JSONL output into context.opencode.*
+        if (detectedIntegrationId === "opencode" && stdoutCapture) {
+            const opencodeCtx = parseOpencodeJsonOutput(stdoutCapture.getCaptured());
+            if (opencodeCtx) {
+                // Emit structured log for observability
+                if (commandSpan) {
+                    commandSpan.setAttribute("loop_task.opencode.session_id", opencodeCtx.session.id);
+                    commandSpan.setAttribute("loop_task.opencode.cost", opencodeCtx.cost);
+                    commandSpan.setAttribute("loop_task.opencode.tools_count", opencodeCtx.tools.count);
+                    if (opencodeCtx.error) {
+                        commandSpan.setAttribute("loop_task.opencode.error", opencodeCtx.error.name);
+                    }
+                }
+                // The parsed context is returned as part of the result so context-parser
+                // can merge it into the loop chain context
+                result.opencode = opencodeCtx;
+            }
+        }
         if (commandSpan) {
             commandSpan.ok();
         }

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

@@ -53,13 +53,98 @@ export function parseStdout(raw) {
     }
     return { output: trimmed };
 }
-export function mergeCommandOutput(context, stdout, stderr) {
+export function mergeCommandOutput(context, stdout, stderr, opencode) {
     const parsed = parseStdout(stdout);
     if (parsed !== null) {
         Object.assign(context, parsed);
     }
+    // Merge structured opencode context under the "opencode" namespace.
+    // When the new opencode context references the same session as the existing
+    // one, accumulate tokens/cost/tools instead of overwriting. This gives the
+    // last task in a chain visibility into total session usage, not just the
+    // last task's usage.
+    if (opencode && typeof opencode === "object") {
+        const incoming = opencode;
+        const existing = context.opencode;
+        if (existing &&
+            typeof existing === "object" &&
+            existing.session &&
+            incoming.session &&
+            existing.session.id === incoming.session.id) {
+            // Same session — accumulate
+            context.opencode = accumulateOpencodeContext(existing, incoming);
+        }
+        else {
+            // Different session or no existing context — overwrite
+            context.opencode = opencode;
+        }
+    }
     const output = [stdout, stderr].filter(Boolean).join("\n").trim();
     if (output.length > 0) {
         context.output = output;
     }
 }
+/**
+ * Accumulate tokens, cost, and tool counts across two opencode context objects
+ * that share the same session ID. Non-accumulatable fields (session, gitSnapshot,
+ * error, text) are overwritten with the latest values.
+ */
+function accumulateOpencodeContext(existing, incoming) {
+    const existingTokens = (existing.tokens ?? {});
+    const incomingTokens = (incoming.tokens ?? {});
+    const existingCache = (existingTokens.cache ?? {});
+    const incomingCache = (incomingTokens.cache ?? {});
+    const existingTools = (existing.tools ?? {});
+    const incomingTools = (incoming.tools ?? {});
+    const existingToolNames = (existingTools.names ?? []);
+    const incomingToolNames = (incomingTools.names ?? []);
+    return {
+        // Session: keep latest (messageId may differ per task, but session.id is the same)
+        session: incoming.session,
+        // Tokens: sum across all tasks in the same session
+        tokens: {
+            input: (existingTokens.input ?? 0) + (incomingTokens.input ?? 0),
+            output: (existingTokens.output ?? 0) + (incomingTokens.output ?? 0),
+            reasoning: (existingTokens.reasoning ?? 0) + (incomingTokens.reasoning ?? 0),
+            cache: {
+                read: (existingCache.read ?? 0) + (incomingCache.read ?? 0),
+                write: (existingCache.write ?? 0) + (incomingCache.write ?? 0),
+            },
+        },
+        // Cost: sum
+        cost: (existing.cost ?? 0) + (incoming.cost ?? 0),
+        // Tools: sum counts, union names
+        tools: {
+            count: (existingTools.count ?? 0) + (incomingTools.count ?? 0),
+            names: [...new Set([...existingToolNames, ...incomingToolNames])],
+        },
+        // Latest values (overwrite, not accumulate)
+        gitSnapshot: incoming.gitSnapshot ?? existing.gitSnapshot,
+        error: incoming.error ?? existing.error,
+        text: incoming.text ?? existing.text,
+    };
+}
+/**
+ * Resolve a dotted key path (e.g., "opencode.tokens.input") from a context object.
+ * When the resolved value is an object (not array, not null), render as indented JSON.
+ * Returns the string representation for interpolation into command args.
+ */
+export function resolveContextValue(context, key) {
+    const parts = key.split(".");
+    let current = context;
+    for (const part of parts) {
+        if (current && typeof current === "object" && !Array.isArray(current)) {
+            current = current[part];
+        }
+        else {
+            return undefined;
+        }
+    }
+    if (current === undefined || current === null)
+        return undefined;
+    // Objects and arrays render as indented JSON
+    if (typeof current === "object") {
+        return JSON.stringify(current, null, 2);
+    }
+    return String(current);
+}

package/dist/core/context/opencode-json-parser.js

@@ -0,0 +1,129 @@
+/**
+ * Parse the JSONL stdout stream from `opencode run --format json`.
+ *
+ * Each line is a JSON object with a `type` field. The parser extracts:
+ * - step_start: session ID, message ID, git snapshot
+ * - tool_use: tool name, accumulated count
+ * - text: last text before step_finish with reason=stop (Option B)
+ * - step_finish: tokens, cost (accumulated across all steps), final git snapshot
+ * - error: error name and message
+ *
+ * Returns null if the input is not valid JSONL with a `type` field.
+ */
+export function parseOpencodeJsonOutput(stdout) {
+    const lines = stdout.trim().split("\n").filter((l) => l.trim());
+    if (lines.length === 0)
+        return null;
+    // Verify first line is valid JSON with a `type` field
+    let firstParsed;
+    try {
+        firstParsed = JSON.parse(lines[0]);
+    }
+    catch {
+        return null;
+    }
+    if (typeof firstParsed !== "object" || firstParsed === null || !("type" in firstParsed)) {
+        return null;
+    }
+    const result = {
+        session: { id: "", messageId: "" },
+        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+        cost: 0,
+        tools: { count: 0, names: [] },
+        gitSnapshot: "",
+        error: null,
+        text: null,
+    };
+    let lastTextBeforeStop = null;
+    let sawStepFinishStop = false;
+    for (const line of lines) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const type = event.type;
+        const part = event.part;
+        switch (type) {
+            case "step_start": {
+                if (event.sessionID) {
+                    result.session.id = event.sessionID;
+                }
+                if (part?.messageID) {
+                    result.session.messageId = part.messageID;
+                }
+                if (part?.snapshot) {
+                    result.gitSnapshot = part.snapshot;
+                }
+                break;
+            }
+            case "tool_use": {
+                result.tools.count++;
+                const toolName = part?.tool;
+                if (toolName && !result.tools.names.includes(toolName)) {
+                    result.tools.names.push(toolName);
+                }
+                break;
+            }
+            case "text": {
+                // Track text events; we'll capture the last one before step_finish(reason=stop)
+                const textContent = part?.text;
+                if (textContent) {
+                    lastTextBeforeStop = textContent;
+                }
+                break;
+            }
+            case "step_finish": {
+                if (part?.reason === "stop") {
+                    sawStepFinishStop = true;
+                    // Capture the text accumulated so far
+                    result.text = lastTextBeforeStop;
+                    lastTextBeforeStop = null;
+                }
+                // Accumulate tokens and cost
+                const tokens = part?.tokens;
+                if (tokens) {
+                    if (typeof tokens.input === "number")
+                        result.tokens.input += tokens.input;
+                    if (typeof tokens.output === "number")
+                        result.tokens.output += tokens.output;
+                    if (typeof tokens.reasoning === "number")
+                        result.tokens.reasoning += tokens.reasoning;
+                    const cache = tokens.cache;
+                    if (cache) {
+                        if (typeof cache.read === "number")
+                            result.tokens.cache.read += cache.read;
+                        if (typeof cache.write === "number")
+                            result.tokens.cache.write += cache.write;
+                    }
+                }
+                if (typeof part?.cost === "number") {
+                    result.cost += part.cost;
+                }
+                if (part?.snapshot) {
+                    result.gitSnapshot = part.snapshot;
+                }
+                break;
+            }
+            case "error": {
+                const error = event.error;
+                if (error) {
+                    const name = error.name;
+                    const data = error.data;
+                    result.error = {
+                        name: name ?? "UnknownError",
+                        message: data?.message ?? "Unknown error",
+                    };
+                }
+                break;
+            }
+        }
+    }
+    // If we never saw a step_finish with reason=stop, don't set text
+    if (!sawStepFinishStop) {
+        result.text = null;
+    }
+    return result;
+}

package/dist/core/context/template.js

@@ -10,11 +10,29 @@ function shellEscape(value) {
     // $, ", \, parens) except single quotes themselves.
     return "'" + value.replace(/'/g, "'\\''") + "'";
 }
+function resolveNestedValue(context, key) {
+    const parts = key.split(".");
+    let current = context;
+    for (const part of parts) {
+        if (current && typeof current === "object" && !Array.isArray(current)) {
+            current = current[part];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return current;
+}
 export function interpolate(input, context) {
-    return input.replace(/{{(\w+)}}/g, (_, key) => {
-        const raw = context[key];
+    // Support nested keys like {{opencode.tokens.input}} and {{opencode.tokens}}
+    return input.replace(/{{([\w.]+)}}/g, (_, key) => {
+        const raw = resolveNestedValue(context, key);
         if (raw === undefined || raw === null)
             return "";
+        // Objects and arrays render as indented JSON
+        if (typeof raw === "object") {
+            return shellEscape(JSON.stringify(raw, null, 2));
+        }
         return shellEscape(String(raw));
     });
 }

package/dist/core/context/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -130,7 +130,10 @@ export function executeChain(options) {
                     }
                 }
                 if (shouldCaptureStdout && (stepStdout || stepStderr)) {
-                    mergeCommandOutput(chainContext, stepStdout, stepStderr);
+                    const opencodeCtx = stepResults
+                        .filter((r) => r.status === "fulfilled")
+                        .find((r) => r.value.opencode)?.value?.opencode;
+                    mergeCommandOutput(chainContext, stepStdout, stepStderr, opencodeCtx);
                 }
                 const stepFailure = stepResults.some((r) => r.status === "rejected" || (r.status === "fulfilled" && r.value.exitCode !== 0));
                 if (stepFailure) {

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

@@ -98,7 +98,11 @@ export async function executeRunImpl(ctrl, signal) {
                 }
             }
             if (shouldCaptureStdout && (stepStdout || stepStderr)) {
-                mergeCommandOutput(chainContext, stepStdout, stepStderr);
+                // Extract opencode context from the first fulfilled step result
+                const opencodeCtx = stepResults
+                    .filter((r) => r.status === "fulfilled")
+                    .find((r) => r.value.opencode)?.value?.opencode;
+                mergeCommandOutput(chainContext, stepStdout, stepStderr, opencodeCtx);
             }
             const stepFailure = stepResults.some((r) => r.status === "rejected" || (r.status === "fulfilled" && r.value.exitCode !== 0));
             if (stepFailure) {

package/dist/daemon/http/openapi.js

@@ -54,10 +54,10 @@ export function buildOpenApiSpec() {
             "/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" }, maxRuns: { type: "integer" } } } }, 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" }, 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" } } },
+                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. PlainConceptsPlatform/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" }, 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" } } },
+                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. PlainConceptsPlatform/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" } } } },

package/dist/daemon/index.js

@@ -16,6 +16,7 @@ import { RecipeTaskStore } from "./recipe/task-store.js";
 import { DeferredReloadManager } from "./recipe/deferred-reload.js";
 import { setRecipeSelfWriteNotifier } from "./recipe/file-writer.js";
 import { TelemetryManager } from "./telemetry/index.js";
+import { AgentServeManager } from "./telemetry/agent-serve-manager.js";
 import path from "node:path";
 function cleanupStaleProcesses() {
     const oldPid = readDaemonPid();
@@ -36,6 +37,7 @@ async function main() {
     settingsManager.load();
     const telemetryManager = new TelemetryManager(settingsManager.get());
     manager.setTelemetryManager(telemetryManager);
+    const agentServeManager = new AgentServeManager(settingsManager.get(), telemetryManager);
     const server = new IpcServer(manager, taskManager, settingsManager, telemetryManager);
     const projectManager = manager.projectManager;
     const httpServer = new HttpApiServer(manager, taskManager, projectManager, settingsManager);
@@ -150,6 +152,12 @@ async function main() {
     // Reconcile after watchers are attached so files created during startup cannot be missed.
     recipeScanner.scanAllProjects();
     daemonLog(`recipe scanner initialized`);
+    // Start agent serve sidecars (e.g., opencode serve) after core services are up
+    if (settingsManager.get().telemetryEnabled) {
+        agentServeManager.ensureAllServe(process.cwd()).catch((err) => {
+            daemonLog(`agent serve startup failed: ${String(err)}`);
+        });
+    }
     let shuttingDown = false;
     const cleanup = async () => {
         if (shuttingDown)
@@ -158,6 +166,7 @@ async function main() {
         daemonLog(`shutting down pid=${process.pid}`);
         try {
             killAllActiveProcesses();
+            await agentServeManager.shutdownAll();
             await telemetryManager.shutdown();
             fileWatcher.stop();
             removeDaemonPid();

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

@@ -11,7 +11,7 @@ export function setProjectSelfWriteNotifier(notifier) {
 const GITHUB_SOURCE_REGEX = /^[a-zA-Z0-9_.\-]+\/[a-zA-Z0-9_.\-]+$/;
 function validateGithubSource(githubSource) {
     if (!GITHUB_SOURCE_REGEX.test(githubSource)) {
-        throw new Error(`Invalid githubSource format: "${githubSource}". Expected owner/repo (e.g. CKGrafico/loop-task)`);
+        throw new Error(`Invalid githubSource format: "${githubSource}". Expected owner/repo (e.g. PlainConceptsPlatform/loop-task)`);
     }
 }
 export class ProjectManager {

package/dist/daemon/telemetry/agent-integrations/claude-code-integration.js

@@ -2,6 +2,12 @@ const CLAUDE_BINARIES = ["claude"];
 /**
  * Detects `claude -p ...` or `claude --print ...` invocations and
  * enables Claude Code's native telemetry, routing to loop-task's endpoint.
+ *
+ * Claude Code does not support a persistent serve model with `--attach`
+ * equivalent. All telemetry env is injected per-task as fallback.
+ * When Claude Code adds serve-attach support, implement the serve
+ * lifecycle methods (ensureServe, isServeAlive, prepareRunArgs,
+ * shutdownServe) here.
  */
 export class ClaudeCodeTelemetryIntegration {
     constructor() {