@plainconceptsplatform/loop-task 2.6.0 → 2.8.0

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

@@ -0,0 +1,126 @@
+/**
+ * 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 allLines = stdout.trim().split("\n").filter((l) => l.trim());
+    if (allLines.length === 0)
+        return null;
+    const jsonLines = [];
+    for (const line of allLines) {
+        try {
+            const parsed = JSON.parse(line);
+            if (typeof parsed === "object" && parsed !== null && "type" in parsed) {
+                jsonLines.push(parsed);
+            }
+        }
+        catch {
+            // skip non-JSON lines (opencode prints status lines)
+        }
+    }
+    if (jsonLines.length === 0)
+        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,
+        model: null,
+    };
+    let lastTextBeforeStop = null;
+    let sawStepFinishStop = false;
+    for (const event of jsonLines) {
+        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,27 @@ 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];
+    return input.replace(/{{([\w.]+)}}/g, (_, key) => {
+        const raw = resolveNestedValue(context, key);
         if (raw === undefined || raw === null)
             return "";
+        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

@@ -110,6 +110,7 @@ export function executeChain(options) {
                     taskId: chainTask.id,
                     taskName: chainTask.name,
                     telemetryConfig: chainTask.telemetry,
+                    chainContext,
                 }
                 : undefined;
             for (const step of taskSteps) {
@@ -130,7 +131,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

@@ -73,6 +73,7 @@ export async function executeRunImpl(ctrl, signal) {
             taskName: task?.name,
             projectId: ctrl.options.projectId,
             telemetryConfig: task?.telemetry,
+            chainContext,
         }
         : undefined;
     let exitCode = 0;
@@ -98,7 +99,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);
@@ -50,23 +52,19 @@ async function main() {
     const httpPort = parseInt(process.env.LOOP_CLI_HTTP_PORT ?? "", 10);
     const resolvedHttpPort = Number.isNaN(httpPort) ? undefined : httpPort;
     let currentHttpHost = settingsManager.get().httpApiHost;
+    const startupTasks = [];
     if (settingsManager.get().httpApiEnabled) {
-        try {
-            await httpServer.listen(resolvedHttpPort, currentHttpHost);
-        }
-        catch (err) {
+        startupTasks.push(httpServer.listen(resolvedHttpPort, currentHttpHost).catch((err) => {
             daemonLog(`HTTP API server failed to start: ${String(err)}`);
-        }
+        }));
     }
     mcpServer.setHost(currentHttpHost);
     if (mcpEnabled) {
-        try {
-            await mcpServer.start();
-        }
-        catch (err) {
+        startupTasks.push(mcpServer.start().catch((err) => {
             daemonLog(`MCP server failed to start: ${String(err)}`);
-        }
+        }));
     }
+    await Promise.all(startupTasks);
     settingsManager.onChange((settings) => {
         const newHost = settings.httpApiHost;
         const hostChanged = newHost !== currentHttpHost;
@@ -150,6 +148,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 +162,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() {

package/dist/daemon/telemetry/agent-integrations/opencode-integration.js

@@ -1,11 +1,24 @@
+import { execa } from "execa";
+import { daemonLog } from "../../daemon-log.js";
 const OPENCODE_BINARIES = ["opencode"];
+const SERVE_PORT = 4096;
+const SERVE_URL = `http://localhost:${SERVE_PORT}`;
+const HEALTH_CHECK_TIMEOUT_MS = 120_000;
+const HEALTH_CHECK_INTERVAL_MS = 1_000;
+const SHUTDOWN_TIMEOUT_MS = 5_000;
 /**
  * Detects `opencode run ...` invocations and enables OpenCode's
  * native OpenTelemetry support, routing to loop-task's endpoint.
+ *
+ * Also manages a persistent `opencode serve` sidecar process so that
+ * `opencode run` tasks delegate to a warm serve instance via `--attach`,
+ * eliminating per-task cold-start time.
  */
 export class OpenCodeTelemetryIntegration {
     constructor() {
         this.id = "opencode";
+        this.serveProcess = null;
+        this.serveInfo = null;
     }
     matches(command, args) {
         const basename = command.split("/").pop()?.replace(/\.exe$/, "").toLowerCase() ?? "";
@@ -15,19 +28,53 @@ export class OpenCodeTelemetryIntegration {
         const env = { ...invocation.env };
         // Enable OpenCode's experimental OpenTelemetry
         env.OPENCODE_EXPERIMENTAL_OPEN_TELEMETRY = "true";
-        // Adapt the OTLP endpoint/proprotocol from the parent context
-        // OpenCode currently reads the standard OTEL_* environment variables
-        // which are already set by the adapter's prepareChildProcess
-        // We just need to make sure the integration is activated.
         return { command: invocation.command, args: [...invocation.args], env };
     }
     parseUsage(result) {
         if (result.exitCode !== 0 || !result.stdout)
             return undefined;
         try {
-            // OpenCode may output JSON with --format json
-            // Try to parse structured output for usage data
+            // With --format json, opencode emits JSONL. The last step_finish event
+            // has token/cost info. Try parsing as JSONL first.
             const lines = result.stdout.trim().split("\n");
+            const jsonlLines = [];
+            let allJson = true;
+            for (const line of lines) {
+                try {
+                    jsonlLines.push(JSON.parse(line));
+                }
+                catch {
+                    allJson = false;
+                    break;
+                }
+            }
+            if (allJson && jsonlLines.length > 0) {
+                // Find the last step_finish event
+                let accumulated = {};
+                for (const evt of jsonlLines) {
+                    if (typeof evt === "object" && evt !== null && evt.type === "step_finish") {
+                        const part = evt.part;
+                        const tokens = part?.tokens;
+                        if (tokens) {
+                            accumulated.inputTokens = (accumulated.inputTokens ?? 0) + (typeof tokens.input === "number" ? tokens.input : 0);
+                            accumulated.outputTokens = (accumulated.outputTokens ?? 0) + (typeof tokens.output === "number" ? tokens.output : 0);
+                            const cache = tokens.cache;
+                            if (cache) {
+                                accumulated.cacheReadTokens = (accumulated.cacheReadTokens ?? 0) + (typeof cache.read === "number" ? cache.read : 0);
+                                accumulated.cacheWriteTokens = (accumulated.cacheWriteTokens ?? 0) + (typeof cache.write === "number" ? cache.write : 0);
+                            }
+                        }
+                        if (typeof part?.cost === "number") {
+                            accumulated.costUsd = (accumulated.costUsd ?? 0) + part.cost;
+                        }
+                    }
+                }
+                if (Object.keys(accumulated).length > 0) {
+                    accumulated.integration = "opencode";
+                    return accumulated;
+                }
+            }
+            // Fallback: try parsing the last line as JSON (legacy --format json without JSONL)
             const lastLine = lines[lines.length - 1];
             if (!lastLine)
                 return undefined;
@@ -63,10 +110,133 @@ export class OpenCodeTelemetryIntegration {
                 usage.sessionId = parsed.sessionId;
             if (Object.keys(usage).length === 0)
                 return undefined;
+            usage.integration = "opencode";
             return usage;
         }
         catch {
             return undefined;
         }
     }
+    async ensureServe(cwd, env) {
+        // Already running and healthy
+        if (this.serveInfo && this.isServeAlive()) {
+            return this.serveInfo;
+        }
+        try {
+            daemonLog("opencode-serve: starting opencode serve sidecar");
+            this.serveProcess = execa("opencode", [
+                "serve",
+                "--port", String(SERVE_PORT),
+                "--hostname", "127.0.0.1",
+            ], {
+                cwd,
+                env: { ...process.env, ...env },
+                stdout: "pipe",
+                stderr: "pipe",
+                buffer: false,
+                detached: false,
+            });
+            this.serveProcess.catch((err) => {
+                daemonLog(`opencode-serve: process error: ${String(err)}`);
+            });
+            this.serveProcess.on("exit", (code) => {
+                daemonLog(`opencode-serve: process exited with code ${code}`);
+                if (code !== 0 && code !== null) {
+                    this.serveProcess = null;
+                    this.serveInfo = null;
+                }
+            });
+            // Wait for health check
+            const healthy = await this.waitForHealth();
+            if (healthy) {
+                const pid = this.serveProcess?.pid;
+                if (pid) {
+                    this.serveInfo = { port: SERVE_PORT, pid, url: SERVE_URL };
+                    daemonLog(`opencode-serve: healthy, pid=${pid}, port=${SERVE_PORT}`);
+                    return this.serveInfo;
+                }
+            }
+            daemonLog("opencode-serve: health check timed out");
+            return;
+        }
+        catch (err) {
+            daemonLog(`opencode-serve: failed to start: ${String(err)}`);
+            this.serveProcess = null;
+            this.serveInfo = null;
+            return;
+        }
+    }
+    isServeAlive() {
+        if (!this.serveInfo)
+            return false;
+        return true;
+    }
+    prepareRunArgs(args, cwd) {
+        const modified = [...args];
+        // Inject --attach after "run" (args[0] === "run")
+        const runIndex = modified.indexOf("run");
+        if (runIndex === -1)
+            return modified;
+        // Check if --attach is already present
+        const hasAttach = modified.includes("--attach");
+        if (!hasAttach) {
+            modified.splice(runIndex + 1, 0, "--attach", SERVE_URL);
+        }
+        // Inject --dir so serve knows which directory to work in
+        const hasDir = modified.includes("--dir");
+        if (!hasDir && cwd) {
+            // Find the position after --attach (or after "run" if --attach wasn't added by us)
+            const attachIdx = modified.indexOf("--attach");
+            const insertPos = attachIdx >= 0 ? attachIdx + 2 : runIndex + 1;
+            modified.splice(insertPos, 0, "--dir", cwd);
+        }
+        return modified;
+    }
+    async shutdownServe() {
+        if (!this.serveProcess)
+            return;
+        daemonLog("opencode-serve: shutting down serve process");
+        const proc = this.serveProcess;
+        this.serveProcess = null;
+        this.serveInfo = null;
+        try {
+            proc.kill("SIGTERM");
+            await Promise.race([
+                proc,
+                new Promise((_, reject) => setTimeout(() => reject(new Error("shutdown timeout")), SHUTDOWN_TIMEOUT_MS)),
+            ]);
+        }
+        catch {
+            // Force kill if SIGTERM didn't work
+            try {
+                proc.kill("SIGKILL");
+            }
+            catch {
+                // best effort
+            }
+        }
+    }
+    async waitForHealth() {
+        const start = Date.now();
+        while (Date.now() - start < HEALTH_CHECK_TIMEOUT_MS) {
+            if (!this.serveProcess)
+                return false; // process exited
+            try {
+                const controller = new AbortController();
+                const timeout = setTimeout(() => controller.abort(), 3_000);
+                const res = await fetch(`${SERVE_URL}/global/health`, { signal: controller.signal });
+                clearTimeout(timeout);
+                if (res.ok) {
+                    const data = await res.json();
+                    if (data.healthy === true)
+                        return true;
+                }
+            }
+            catch {
+                // server not ready yet
+            }
+            await new Promise((r) => setTimeout(r, HEALTH_CHECK_INTERVAL_MS));
+        }
+        return false;
+    }
 }

package/dist/daemon/telemetry/agent-serve-manager.js

@@ -0,0 +1,78 @@
+import { daemonLog } from "../daemon-log.js";
+import { getAgentIntegrations } from "./agent-integrations/index.js";
+/**
+ * Manages the lifecycle of persistent agent serve sidecars (e.g., opencode serve).
+ *
+ * On daemon boot, starts serve processes for integrations that support them.
+ * On daemon shutdown, gracefully stops all serve processes.
+ *
+ * The serve manager is the single owner of serve process lifecycle.
+ * The TelemetryManager and command-runner reference the integration's
+ * isServeAlive() to check state, but never start/stop serve processes directly.
+ */
+export class AgentServeManager {
+    constructor(settings, telemetryManager) {
+        this.settings = settings;
+        this.telemetryManager = telemetryManager;
+        this.integrations = [];
+        this.integrations = [...getAgentIntegrations()];
+    }
+    /**
+     * Start serve sidecars for all integrations that support them.
+     * Called on daemon boot.
+     */
+    async ensureAllServe(cwd) {
+        const endpoint = this.settings.telemetryEndpoint;
+        if (!endpoint) {
+            daemonLog("agent-serve-manager: no telemetry endpoint, skipping serve startup");
+            return;
+        }
+        // Build static OTEL env for serve processes
+        const serveEnv = {
+            OTEL_EXPORTER_OTLP_ENDPOINT: endpoint,
+            OTEL_EXPORTER_OTLP_PROTOCOL: this.settings.telemetryProtocol,
+            OTEL_TRACES_EXPORTER: "otlp",
+            OTEL_METRICS_EXPORTER: "otlp",
+            OTEL_LOGS_EXPORTER: "otlp",
+            OTEL_RESOURCE_ATTRIBUTES: `service.name=${this.settings.telemetryServiceName}`,
+        };
+        if (this.settings.telemetryAutoInstrumentAgents) {
+            serveEnv.OPENCODE_EXPERIMENTAL_OPEN_TELEMETRY = "true";
+            serveEnv.CLAUDE_CODE_ENABLE_TELEMETRY = "1";
+        }
+        for (const integration of this.integrations) {
+            if (!integration.ensureServe)
+                continue;
+            try {
+                daemonLog(`agent-serve-manager: ensuring serve for integration "${integration.id}"`);
+                const info = await integration.ensureServe(cwd, serveEnv);
+                if (info) {
+                    daemonLog(`agent-serve-manager: serve started for "${integration.id}", pid=${info.pid}, port=${info.port}`);
+                }
+                else {
+                    daemonLog(`agent-serve-manager: serve not started for "${integration.id}" (not supported or failed)`);
+                }
+            }
+            catch (err) {
+                daemonLog(`agent-serve-manager: failed to start serve for "${integration.id}": ${String(err)}`);
+            }
+        }
+    }
+    /**
+     * Gracefully shut down all managed serve processes.
+     * Called on daemon shutdown.
+     */
+    async shutdownAll() {
+        for (const integration of this.integrations) {
+            if (!integration.shutdownServe)
+                continue;
+            try {
+                daemonLog(`agent-serve-manager: shutting down serve for "${integration.id}"`);
+                await integration.shutdownServe();
+            }
+            catch (err) {
+                daemonLog(`agent-serve-manager: error shutting down "${integration.id}": ${String(err)}`);
+            }
+        }
+    }
+}

package/dist/daemon/telemetry/noop-telemetry-adapter.js

@@ -39,6 +39,7 @@ export class NoopTelemetryAdapter {
     recordRetry() { }
     recordFailure() { }
     recordAgentUsage() { }
+    logEvent() { }
     prepareChildProcess(_invocation, _context, _integrationOverride) {
         return { env: {} };
     }