@plainconceptsplatform/loop-task 2.6.1 → 2.8.0

package/dist/app/App.js

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

package/dist/app/Splash.js

@@ -0,0 +1,19 @@
+import React, { useState, useEffect } from "react";
+import { Text } from "ink";
+const LOGO = [
+    " _                       _            _    ",
+    "| | ___   ___  _ __     | |_ __ _ ___| | __",
+    "| |/ _ \\ / _ \\| '_ \\____| __/ _` / __| |/ /",
+    "| | (_) | (_) | |_) |____| || (_| \\__ \\   < ",
+    "|_|\\___/ \\___/| .__/      \\__\\__,_|___/_|\\_\\",
+    "               |_|                            ",
+];
+const DOTS = [".  ", ".. ", "...", " ..", "  .", "  . "];
+export function Splash() {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        const timer = setInterval(() => setFrame((f) => (f + 1) % DOTS.length), 200);
+        return () => clearInterval(timer);
+    }, []);
+    return React.createElement(React.Fragment, null, ...LOGO.map((line, i) => React.createElement(Text, { key: i, color: "cyan", bold: true }, line)), React.createElement(Text, { color: "gray" }, `Loading${DOTS[frame]}`));
+}

package/dist/client/ipc.js

@@ -2,8 +2,15 @@ import net from "node:net";
 import { ensureDaemon, getSocket } from "../daemon/spawner/index.js";
 import { t } from "../shared/i18n/index.js";
 import { IPC_TIMEOUT_MS } from "../shared/config/constants.js";
-export async function sendRequest(request) {
+let daemonEnsured = false;
+export async function ensureDaemonReady() {
+    if (daemonEnsured)
+        return;
     ensureDaemon();
+    daemonEnsured = true;
+}
+export async function sendRequest(request) {
+    await ensureDaemonReady();
     const socketPath = getSocket();
     return new Promise((resolve, reject) => {
         let resolved = false;

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

@@ -6,7 +6,7 @@ import { t } from "../../shared/i18n/index.js";
 import { MAX_CONTEXT_STDOUT_BYTES, MAX_SPAN_OUTPUT_BYTES } from "../../shared/config/constants.js";
 import { StdoutCaptureTransform } from "./stdout-capture-transform.js";
 import { killProcessTree } from "./process-tree.js";
-import { getAgentIntegrations } from "../../daemon/telemetry/agent-integrations/index.js";
+import { getAgentIntegrations, detectAgentIntegration } 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) {
@@ -68,12 +68,13 @@ export function killAllActiveProcesses() {
     }
 }
 export async function executeCommand(command, commandArgs, cwd, logStream, signal, runNumber, captureStdout = false, isChain = false, telemetryCtx) {
+    let effectiveCommand = command;
+    let effectiveArgs = commandArgs;
     const startedAt = new Date();
     if (!isChain) {
         const header = t("loop.runHeader", { timestamp: startedAt.toLocaleString(), runNumber: runNumber ?? 0 });
         logStream.write(header);
     }
-    logStream.write(t("loop.commandLine", { command: formatCommandLine(command, commandArgs) }));
     if (cwd) {
         logStream.write(t("loop.cwdLine", { cwd }));
     }
@@ -120,18 +121,24 @@ 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 integration = detectAgentIntegration(command, commandArgs);
+        if (integration) {
+            detectedIntegrationId = integration.id;
+            const prepared = integration.prepare({ command, args: commandArgs, cwd, env: {} }, {
+                runId: telemetryCtx?.runId ?? "",
+                loopId: telemetryCtx?.loopId ?? "",
+                loopName: telemetryCtx?.loopName ?? "",
+            });
+            telemetryEnv = { ...telemetryEnv, ...prepared.env };
+        }
+    }
     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";
@@ -161,13 +168,25 @@ export async function executeCommand(command, commandArgs, cwd, logStream, signa
             }
         }
     }
-    // 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)];
         }
+        if (!effectiveArgs.includes("--session") && !effectiveArgs.includes("-s")) {
+            const opencodeCtx = telemetryCtx?.chainContext?.opencode;
+            const sessionId = opencodeCtx?.session?.id;
+            if (sessionId) {
+                effectiveArgs = [...effectiveArgs.slice(0, 1), "--session", sessionId, ...effectiveArgs.slice(1)];
+                if (!effectiveArgs.includes("--model") && !effectiveArgs.includes("-m")) {
+                    const model = opencodeCtx?.model;
+                    if (model) {
+                        effectiveArgs = [...effectiveArgs.slice(0, 1), "--model", model, ...effectiveArgs.slice(1)];
+                    }
+                }
+            }
+        }
     }
-    // Compute shell command after potential --attach injection
+    logStream.write(t("loop.commandLine", { command: formatCommandLine(effectiveCommand, effectiveArgs) }));
     const shellCommand = formatCommandLine(effectiveCommand, effectiveArgs);
     const needShell = /(\$\(|`|&&|\|\||;|>|<|\|)/.test(shellCommand);
     const baseEnv = childEnv();
@@ -191,7 +210,7 @@ export async function executeCommand(command, commandArgs, cwd, logStream, signa
             killSignal: "SIGTERM",
             ...detachedOpt,
         })
-        : execa(command, commandArgs, {
+        : execa(effectiveCommand, effectiveArgs, {
             stdout: "pipe",
             stderr: "pipe",
             stdin: "ignore",
@@ -205,8 +224,9 @@ export async function executeCommand(command, commandArgs, cwd, logStream, signa
     if (child.pid) {
         activePids.add(child.pid);
     }
+    const isOpencodeJson = detectedIntegrationId === "opencode" && effectiveArgs.includes("--format") && effectiveArgs.includes("json");
     const stdoutCapture = (captureStdout || !!detectedIntegrationId)
-        ? new StdoutCaptureTransform(MAX_CONTEXT_STDOUT_BYTES)
+        ? new StdoutCaptureTransform(MAX_CONTEXT_STDOUT_BYTES, isOpencodeJson)
         : null;
     const stderrCapture = (captureStdout || !!detectedIntegrationId)
         ? new StdoutCaptureTransform(MAX_CONTEXT_STDOUT_BYTES)
@@ -239,27 +259,17 @@ export async function executeCommand(command, commandArgs, cwd, logStream, signa
                 commandSpan.setAttribute("loop_task.command.stdout", truncateForSpan(stdoutCapture.getCaptured(), MAX_SPAN_OUTPUT_BYTES));
             }
         }
-        // Attempt to parse agent usage from output
         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;
-            }
+        let opencodeResult = undefined;
+        const opencodeCtx = (detectedIntegrationId === "opencode" && stdoutCapture)
+            ? parseOpencodeJsonOutput(stdoutCapture.getCaptured())
+            : null;
+        if (opencodeCtx) {
+            opencodeCtx.model = extractModelFromArgs(effectiveArgs);
+            opencodeResult = opencodeCtx;
+            writeOpencodeSummary(logStream, opencodeCtx, isOpencodeJson);
         }
         if (commandSpan) {
             commandSpan.ok();
@@ -271,6 +281,7 @@ export async function executeCommand(command, commandArgs, cwd, logStream, signa
             endedAt,
             ...(captureStdout && stdoutCapture ? { stdout: stdoutCapture.getCaptured() } : {}),
             ...(captureStdout && stderrCapture ? { stderr: stderrCapture.getCaptured() } : {}),
+            ...(opencodeResult ? { opencode: opencodeResult } : {}),
         };
     }
     catch (error) {
@@ -365,3 +376,22 @@ function truncateForSpan(text, maxBytes) {
         return text;
     return buf.subarray(0, maxBytes).toString("utf-8") + `\n... [truncated, ${buf.length} bytes total]`;
 }
+function extractModelFromArgs(args) {
+    const flags = ["--model", "-m"];
+    for (const flag of flags) {
+        const idx = args.indexOf(flag);
+        if (idx >= 0 && idx + 1 < args.length) {
+            return args[idx + 1];
+        }
+    }
+    return null;
+}
+function writeOpencodeSummary(logStream, ctx, writeSummary) {
+    if (!writeSummary)
+        return;
+    logStream.write(`session: ${ctx.session.id} | tokens: ${ctx.tokens.input} in / ${ctx.tokens.output} out | cost: $${ctx.cost} | tools: ${ctx.tools.count}\n`);
+    if (ctx.text)
+        logStream.write(`${ctx.text}\n`);
+    if (ctx.error)
+        logStream.write(`error: ${ctx.error.name}: ${ctx.error.message}\n`);
+}

package/dist/core/command/stdout-capture-transform.js

@@ -2,28 +2,64 @@ import { Transform } from "node:stream";
 import { MAX_CONTEXT_STDOUT_BYTES } from "../../shared/config/constants.js";
 const KV_LINE_RE = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
 export class StdoutCaptureTransform extends Transform {
-    constructor(maxBytes = MAX_CONTEXT_STDOUT_BYTES) {
+    constructor(maxBytes = MAX_CONTEXT_STDOUT_BYTES, suppressJsonl = false) {
         super({ decodeStrings: true });
         this.captured = [];
         this.totalBytes = 0;
         this.truncated = false;
         this.partialLine = "";
         this.kvPairs = {};
+        this.suppressJsonl = false;
+        this.jsonBuffer = "";
         this.maxBytes = maxBytes;
+        this.suppressJsonl = suppressJsonl;
     }
     _transform(chunk, _encoding, callback) {
+        if (this.suppressJsonl) {
+            this.handleJsonlSuppression(chunk, callback);
+        }
+        else {
+            this.handleNormal(chunk, callback);
+        }
+    }
+    handleNormal(chunk, callback) {
         this.push(chunk);
-        if (this.truncated) {
-            callback();
-            return;
+        this.captureBytes(chunk);
+        this.extractKvFromChunk(chunk);
+        callback();
+    }
+    handleJsonlSuppression(chunk, callback) {
+        this.captureBytes(chunk);
+        const text = chunk.toString("utf-8");
+        const combined = this.jsonBuffer + text;
+        const lines = combined.split("\n");
+        this.jsonBuffer = lines.pop() ?? "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (typeof parsed === "object" && parsed !== null && "type" in parsed) {
+                    continue;
+                }
+            }
+            catch {
+                // not JSON, pass through
+            }
+            this.push(line + "\n");
         }
-        const chunkBytes = chunk.byteLength;
+        callback();
+    }
+    captureBytes(chunk) {
+        if (this.truncated)
+            return;
         const remaining = this.maxBytes - this.totalBytes;
         if (remaining <= 0) {
             this.truncated = true;
-            callback();
             return;
         }
+        const chunkBytes = chunk.byteLength;
         if (chunkBytes <= remaining) {
             this.captured.push(Buffer.from(chunk));
             this.totalBytes += chunkBytes;
@@ -35,7 +71,6 @@ export class StdoutCaptureTransform extends Transform {
             this.truncated = true;
         }
         this.extractKvFromChunk(chunk);
-        callback();
     }
     extractKvFromChunk(chunk) {
         const text = chunk.toString("utf-8");
@@ -57,6 +92,21 @@ export class StdoutCaptureTransform extends Transform {
             }
             this.partialLine = "";
         }
+        if (this.jsonBuffer) {
+            const trimmed = this.jsonBuffer.trim();
+            if (trimmed) {
+                try {
+                    const parsed = JSON.parse(trimmed);
+                    if (!(typeof parsed === "object" && parsed !== null && "type" in parsed)) {
+                        this.push(this.jsonBuffer + "\n");
+                    }
+                }
+                catch {
+                    this.push(this.jsonBuffer + "\n");
+                }
+            }
+            this.jsonBuffer = "";
+        }
         callback();
     }
     getCaptured() {

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

@@ -54,41 +54,37 @@ export function parseStdout(raw) {
     return { output: trimmed };
 }
 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
+        if (existing && typeof existing === "object" && existing.session && incoming.session && existing.session.id === incoming.session.id) {
             context.opencode = accumulateOpencodeContext(existing, incoming);
         }
         else {
-            // Different session or no existing context — overwrite
             context.opencode = opencode;
         }
+        if (typeof incoming.text === "string" && incoming.text.length > 0) {
+            context.output = incoming.text;
+        }
+        else {
+            const trimmed = stdout.trim();
+            if (trimmed.length > 0)
+                context.output = trimmed;
+        }
+        if (stderr.trim().length > 0) {
+            context.output = (context.output ? context.output + "\n" : "") + stderr.trim();
+        }
+        return;
+    }
+    const parsed = parseStdout(stdout);
+    if (parsed !== null) {
+        Object.assign(context, parsed);
     }
     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 ?? {});
@@ -118,7 +114,6 @@ function accumulateOpencodeContext(existing, incoming) {
             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,

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

@@ -1,3 +1,38 @@
 export function formatContextLog(context) {
-    return `${JSON.stringify(context)}\n`;
+    const lines = [];
+    for (const [key, value] of Object.entries(context)) {
+        if (value === undefined || value === null)
+            continue;
+        if (key === "output" && context.opencode && typeof context.opencode === "object") {
+            const oc = context.opencode;
+            if (typeof oc.text === "string" && oc.text.length > 0)
+                continue;
+        }
+        if (typeof value === "string") {
+            const truncated = value.length > 200 ? value.slice(0, 200) + "..." : value;
+            lines.push(`  ${key}: ${truncateOneline(truncated)}`);
+        }
+        else if (typeof value === "number" || typeof value === "boolean") {
+            lines.push(`  ${key}: ${value}`);
+        }
+        else if (typeof value === "object") {
+            const json = JSON.stringify(value, null, 2);
+            lines.push(`  ${key}:`);
+            lines.push(indent(json, 4));
+        }
+    }
+    if (lines.length === 0)
+        return "";
+    return `=== CONTEXT ===\n{\n${lines.join("\n")}\n}\n=== END CONTEXT ===\n`;
+}
+function truncateOneline(text) {
+    const oneline = text.replace(/\s+/g, " ").trim();
+    if (oneline.length > 300) {
+        return oneline.slice(0, 300) + "...";
+    }
+    return oneline;
+}
+function indent(text, spaces) {
+    const pad = " ".repeat(spaces);
+    return text.split("\n").map((line) => pad + line).join("\n");
 }

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

@@ -11,20 +11,23 @@
  * 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 {
+    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 (typeof firstParsed !== "object" || firstParsed === null || !("type" in firstParsed)) {
+    if (jsonLines.length === 0)
         return null;
-    }
     const result = {
         session: { id: "", messageId: "" },
         tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
@@ -33,17 +36,11 @@ export function parseOpencodeJsonOutput(stdout) {
         gitSnapshot: "",
         error: null,
         text: null,
+        model: null,
     };
     let lastTextBeforeStop = null;
     let sawStepFinishStop = false;
-    for (const line of lines) {
-        let event;
-        try {
-            event = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
+    for (const event of jsonLines) {
         const type = event.type;
         const part = event.part;
         switch (type) {

package/dist/core/context/template.js

@@ -24,12 +24,10 @@ function resolveNestedValue(context, key) {
     return current;
 }
 export function interpolate(input, context) {
-    // 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));
         }

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) {

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;

package/dist/daemon/index.js

@@ -52,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;

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

@@ -138,13 +138,13 @@ export class OpenCodeTelemetryIntegration {
             });
             this.serveProcess.catch((err) => {
                 daemonLog(`opencode-serve: process error: ${String(err)}`);
-                this.serveProcess = null;
-                this.serveInfo = null;
             });
             this.serveProcess.on("exit", (code) => {
                 daemonLog(`opencode-serve: process exited with code ${code}`);
-                this.serveProcess = null;
-                this.serveInfo = null;
+                if (code !== 0 && code !== null) {
+                    this.serveProcess = null;
+                    this.serveInfo = null;
+                }
             });
             // Wait for health check
             const healthy = await this.waitForHealth();
@@ -167,8 +167,7 @@ export class OpenCodeTelemetryIntegration {
         }
     }
     isServeAlive() {
-        // Fast check: if we don't have a process reference, serve is not alive
-        if (!this.serveProcess || !this.serveInfo)
+        if (!this.serveInfo)
             return false;
         return true;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plainconceptsplatform/loop-task",
-  "version": "2.6.1",
+  "version": "2.8.0",
   "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": {