doer-agent 0.4.6 → 0.4.8

package/dist/agent-runtime-utils.js

@@ -1,4 +1,5 @@
 import { readFile } from "node:fs/promises";
+import path from "node:path";
 export function sanitizeUserId(userId) {
     const normalized = userId.trim().replace(/[^a-zA-Z0-9_-]/g, "_");
     return normalized.length > 0 ? normalized : "anonymous";
@@ -27,6 +28,9 @@ export function buildAgentSkillRpcSubject(userId, agentId) {
 export function buildAgentFsRpcSubject(userId, agentId) {
     return `doer.agent.fs.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }
+export function buildAgentDaemonRpcSubject(userId, agentId) {
+    return `doer.agent.daemon.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
 export function parseBootstrapTaskConfig(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return null;
@@ -93,6 +97,93 @@ export function normalizeRunImagePaths(value) {
     }
     return out;
 }
+const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+const crc32Table = (() => {
+    const table = new Uint32Array(256);
+    for (let index = 0; index < 256; index += 1) {
+        let crc = index;
+        for (let bit = 0; bit < 8; bit += 1) {
+            crc = (crc & 1) !== 0 ? 0xedb88320 ^ (crc >>> 1) : crc >>> 1;
+        }
+        table[index] = crc >>> 0;
+    }
+    return table;
+})();
+function crc32(parts) {
+    let crc = 0xffffffff;
+    for (const part of parts) {
+        for (let index = 0; index < part.length; index += 1) {
+            crc = crc32Table[(crc ^ part[index]) & 0xff] ^ (crc >>> 8);
+        }
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function validatePngBytes(bytes) {
+    if (bytes.length < PNG_SIGNATURE.length || !bytes.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE)) {
+        return "missing PNG signature";
+    }
+    let offset = PNG_SIGNATURE.length;
+    let sawIend = false;
+    while (offset < bytes.length) {
+        if (offset + 12 > bytes.length) {
+            return "truncated PNG chunk";
+        }
+        const chunkLength = bytes.readUInt32BE(offset);
+        const typeStart = offset + 4;
+        const dataStart = offset + 8;
+        const dataEnd = dataStart + chunkLength;
+        const crcOffset = dataEnd;
+        const nextOffset = crcOffset + 4;
+        if (dataEnd > bytes.length || nextOffset > bytes.length) {
+            return "truncated PNG chunk payload";
+        }
+        const type = bytes.subarray(typeStart, dataStart);
+        const expectedCrc = bytes.readUInt32BE(crcOffset);
+        const actualCrc = crc32([type, bytes.subarray(dataStart, dataEnd)]);
+        if (expectedCrc !== actualCrc) {
+            const chunkName = type.toString("ascii");
+            return `PNG CRC mismatch in ${chunkName} chunk`;
+        }
+        if (type.equals(Buffer.from("IEND"))) {
+            sawIend = true;
+            if (nextOffset !== bytes.length) {
+                return "unexpected trailing bytes after PNG IEND";
+            }
+            break;
+        }
+        offset = nextOffset;
+    }
+    return sawIend ? null : "missing PNG IEND chunk";
+}
+export function validateImageBytes(filePath, bytes) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === ".png") {
+        return validatePngBytes(bytes);
+    }
+    return null;
+}
+export async function filterValidRunImagePaths(args) {
+    const valid = [];
+    for (const imagePath of args.imagePaths) {
+        const absPath = path.isAbsolute(imagePath) ? imagePath : path.resolve(args.workspaceRoot, imagePath);
+        let bytes;
+        try {
+            bytes = await readFile(absPath);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : "failed to read image";
+            args.onInvalidImage?.(imagePath, reason);
+            continue;
+        }
+        const validationError = validateImageBytes(absPath, bytes);
+        if (validationError) {
+            args.onInvalidImage?.(imagePath, validationError);
+            continue;
+        }
+        valid.push(imagePath);
+    }
+    return valid;
+}
 export function fatalExit(message, error, writeAgentError) {
     const detail = error instanceof Error ? error.message : typeof error === "string" ? error : error ? String(error) : "";
     const full = detail ? `${message}: ${detail}` : message;
@@ -102,17 +193,6 @@ export function fatalExit(message, error, writeAgentError) {
 export function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-export function writeTaskStream(taskId, stream, chunk) {
-    const target = stream === "stdout" ? process.stdout : process.stderr;
-    const lines = chunk.replace(/\r/g, "\n").split("\n");
-    for (let i = 0; i < lines.length; i += 1) {
-        const line = lines[i];
-        if (line.length === 0 && i === lines.length - 1) {
-            continue;
-        }
-        target.write(`[doer-agent][task=${taskId}][${stream}] ${line}\n`);
-    }
-}
 export function writeTaskUpload(taskId, message) {
     process.stdout.write(`[doer-agent][task=${taskId}][upload] ${message}\n`);
 }
@@ -127,9 +207,6 @@ export function writeRpcStream(requestId, stream, chunk) {
         target.write(`[doer-agent][rpc=${requestId}][${stream}] ${line}\n`);
     }
 }
-export function writeRpcStatus(requestId, message) {
-    process.stdout.write(`[doer-agent][rpc=${requestId}][status] ${message}\n`);
-}
 export function writeRunStatus(runId, message) {
     process.stdout.write(`[doer-agent][run=${runId}][status] ${message}\n`);
 }

package/dist/agent-runtime-utils.test.js

@@ -0,0 +1,38 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { filterValidRunImagePaths } from "./agent-runtime-utils.js";
+const invalidTinyPngBase64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aK1cAAAAASUVORK5CYII=";
+function buildValidTinyPng() {
+    const bytes = Buffer.from(invalidTinyPngBase64, "base64");
+    bytes.writeUInt32BE(0xefa2a75b, 0x34);
+    return bytes;
+}
+test("filterValidRunImagePaths drops PNGs with CRC mismatches", async () => {
+    const workspaceRoot = await mkdtemp(path.join(os.tmpdir(), "doer-agent-image-filter-"));
+    try {
+        const invalidPngPath = path.join(workspaceRoot, "bad.png");
+        const validPngPath = path.join(workspaceRoot, "good.png");
+        const validJpgPath = path.join(workspaceRoot, "photo.jpg");
+        await writeFile(invalidPngPath, Buffer.from(invalidTinyPngBase64, "base64"));
+        await writeFile(validPngPath, buildValidTinyPng());
+        await writeFile(validJpgPath, Buffer.from([0xff, 0xd8, 0xff, 0xd9]));
+        const invalid = [];
+        const result = await filterValidRunImagePaths({
+            workspaceRoot,
+            imagePaths: ["bad.png", "good.png", "photo.jpg"],
+            onInvalidImage: (imagePath, reason) => {
+                invalid.push({ imagePath, reason });
+            },
+        });
+        assert.deepEqual(result, ["good.png", "photo.jpg"]);
+        assert.equal(invalid.length, 1);
+        assert.equal(invalid[0]?.imagePath, "bad.png");
+        assert.match(invalid[0]?.reason ?? "", /CRC mismatch/i);
+    }
+    finally {
+        await rm(workspaceRoot, { recursive: true, force: true });
+    }
+});

package/dist/agent-task-execution.js

@@ -1,6 +1,3 @@
-import { spawn } from "node:child_process";
-import { mkdir } from "node:fs/promises";
-import path from "node:path";
 export function sendSignalToTaskProcess(child, signal) {
     if (process.platform !== "win32" && typeof child.pid === "number") {
         try {
@@ -30,17 +27,8 @@ export function sendSignalToPid(pid, signal) {
     }
     process.kill(pid, signal);
 }
-async function checkCancelRequested(args) {
-    const query = new URLSearchParams({
-        userId: args.userId,
-        agentToken: args.agentToken,
-    });
-    const response = await args.getJson(`${args.serverBaseUrl}/api/agent/tasks/${encodeURIComponent(args.taskId)}/events?${query.toString()}`);
-    return Boolean(response.task?.cancelRequested);
-}
 async function syncCodexAuthState(args) {
     const envPatch = {};
-    const synced = false;
     if (args.authMode === "api_key" && args.apiKey) {
         envPatch.OPENAI_API_KEY = args.apiKey;
     }
@@ -54,19 +42,10 @@ async function syncCodexAuthState(args) {
             codexAuthHasAuthJson: Boolean(args.authJson),
             codexAuthIssuedAt: args.issuedAt ?? null,
             codexAuthExpiresAt: args.expiresAt ?? null,
-            codexAuthSynced: synced,
+            codexAuthSynced: false,
         },
     };
 }
-async function prepareTaskCodexAuth(args) {
-    void args;
-    return await syncCodexAuthState({
-        source: "agent_local",
-        authJson: null,
-        issuedAt: null,
-        expiresAt: null,
-    });
-}
 export async function prepareCodexAuthBundle(bundle) {
     if (!bundle) {
         return null;
@@ -80,196 +59,3 @@ export async function prepareCodexAuthBundle(bundle) {
         expiresAt: bundle.expiresAt ?? null,
     });
 }
-export async function runTask(args) {
-    args.setActiveTaskLogContext({
-        jetstream: args.jetstream,
-        serverBaseUrl: args.serverBaseUrl,
-        taskId: args.taskId,
-        userId: args.userId,
-    });
-    const shellPath = args.resolveShellPath();
-    const taskWorkspace = args.resolveTaskWorkspace(args.cwd);
-    const codexHome = args.resolveCodexHomePath();
-    await mkdir(codexHome, { recursive: true });
-    const runtimeConfig = await args.prepareTaskRuntimeConfig({
-        serverBaseUrl: args.serverBaseUrl,
-        taskId: args.taskId,
-        userId: args.userId,
-        agentToken: args.agentToken,
-    });
-    const codexAuth = await prepareTaskCodexAuth({
-        serverBaseUrl: args.serverBaseUrl,
-        taskId: args.taskId,
-        userId: args.userId,
-        agentToken: args.agentToken,
-    });
-    const localAgentSettings = await args.readAgentSettingsConfig({ workspaceRoot: args.resolveWorkspaceRoot() });
-    const baseTaskEnvPatch = {
-        CODEX_HOME: codexHome,
-        ...args.buildAgentSettingsEnvPatch(localAgentSettings),
-        ...(runtimeConfig?.envPatch ?? {}),
-        ...(codexAuth?.envPatch ?? {}),
-        WORKSPACE: taskWorkspace,
-    };
-    const taskGitEnv = await args.prepareTaskGitEnv({
-        cwd: taskWorkspace,
-        baseEnvPatch: baseTaskEnvPatch,
-    });
-    await args.recordAgentEvent({
-        jetstream: args.jetstream,
-        serverBaseUrl: args.serverBaseUrl,
-        taskId: args.taskId,
-        userId: args.userId,
-        type: "meta",
-        seq: args.reserveNextEventSeq(args.taskId),
-        payload: {
-            host: process.platform,
-            pid: process.pid,
-            startedAt: args.formatLocalTimestamp(),
-            command: args.command,
-            cwd: taskWorkspace,
-            requestedCwd: args.cwd,
-            shell: shellPath,
-            ...(runtimeConfig?.meta ?? { runtimeConfigSynced: false }),
-            ...(codexAuth?.meta ?? { codexAuthSynced: false }),
-            ...(taskGitEnv.meta ?? {}),
-        },
-    });
-    try {
-        let terminationReason = null;
-        let cancelStage1Timer = null;
-        let cancelStage2Timer = null;
-        let stopCancelPolling = false;
-        let cancelSignalSent = false;
-        const runtimeBinPath = path.join(args.agentProjectDir, "runtime/bin");
-        const taskPath = [runtimeBinPath, process.env.PATH || ""].filter(Boolean).join(path.delimiter);
-        const child = spawn(args.command, {
-            cwd: taskWorkspace,
-            shell: shellPath,
-            detached: process.platform !== "win32",
-            env: {
-                ...process.env,
-                ...baseTaskEnvPatch,
-                ...taskGitEnv.envPatch,
-                PATH: taskPath,
-                DOER_AGENT_TOKEN: args.agentToken,
-            },
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        child.stdout?.setEncoding("utf8");
-        child.stderr?.setEncoding("utf8");
-        const requestCancel = () => {
-            if (cancelSignalSent || terminationReason === "cancel") {
-                return;
-            }
-            cancelSignalSent = true;
-            terminationReason = "cancel";
-            sendSignalToTaskProcess(child, "SIGINT");
-            cancelStage1Timer = setTimeout(() => {
-                sendSignalToTaskProcess(child, "SIGTERM");
-            }, 1200);
-            cancelStage1Timer.unref?.();
-            cancelStage2Timer = setTimeout(() => {
-                sendSignalToTaskProcess(child, "SIGKILL");
-            }, 3500);
-            cancelStage2Timer.unref?.();
-        };
-        child.stdout?.on("data", (chunk) => {
-            args.writeTaskStream(args.taskId, "stdout", chunk);
-            const seq = args.reserveNextEventSeq(args.taskId);
-            args.persistEventOrFatal({
-                jetstream: args.jetstream,
-                serverBaseUrl: args.serverBaseUrl,
-                taskId: args.taskId,
-                userId: args.userId,
-                type: "stdout",
-                seq,
-                payload: { chunk, at: args.formatLocalTimestamp() },
-                context: "stdout persist failed",
-            });
-        });
-        child.stderr?.on("data", (chunk) => {
-            args.writeTaskStream(args.taskId, "stderr", chunk);
-            const seq = args.reserveNextEventSeq(args.taskId);
-            args.persistEventOrFatal({
-                jetstream: args.jetstream,
-                serverBaseUrl: args.serverBaseUrl,
-                taskId: args.taskId,
-                userId: args.userId,
-                type: "stderr",
-                seq,
-                payload: { chunk, at: args.formatLocalTimestamp() },
-                context: "stderr persist failed",
-            });
-        });
-        const cancelPoller = (async () => {
-            while (!stopCancelPolling) {
-                await args.sleep(5000);
-                if (stopCancelPolling || terminationReason === "cancel") {
-                    continue;
-                }
-                const cancelRequested = await checkCancelRequested({
-                    serverBaseUrl: args.serverBaseUrl,
-                    taskId: args.taskId,
-                    userId: args.userId,
-                    agentToken: args.agentToken,
-                    getJson: args.getJson,
-                }).catch(() => false);
-                if (!cancelRequested) {
-                    continue;
-                }
-                requestCancel();
-            }
-        })();
-        const result = await new Promise((resolve, reject) => {
-            child.once("error", reject);
-            child.once("close", (code, signal) => {
-                resolve({ code, signal });
-            });
-        }).finally(() => {
-            stopCancelPolling = true;
-            if (cancelStage1Timer) {
-                clearTimeout(cancelStage1Timer);
-            }
-            if (cancelStage2Timer) {
-                clearTimeout(cancelStage2Timer);
-            }
-        });
-        await cancelPoller.catch(() => undefined);
-        const canceled = await checkCancelRequested({
-            serverBaseUrl: args.serverBaseUrl,
-            taskId: args.taskId,
-            userId: args.userId,
-            agentToken: args.agentToken,
-            getJson: args.getJson,
-        }).catch(() => false);
-        const status = canceled || terminationReason === "cancel"
-            ? "canceled"
-            : (result.code ?? 1) === 0
-                ? "completed"
-                : "failed";
-        const statusPayload = {
-            status,
-            exitCode: typeof result.code === "number" ? result.code : null,
-            signal: result.signal,
-            finishedAt: args.formatLocalTimestamp(),
-            error: status === "failed"
-                ? `Command exited with code ${result.code ?? "null"}`
-                : null,
-        };
-        await args.recordAgentEvent({
-            jetstream: args.jetstream,
-            serverBaseUrl: args.serverBaseUrl,
-            taskId: args.taskId,
-            userId: args.userId,
-            type: "status",
-            seq: args.reserveNextEventSeq(args.taskId),
-            payload: statusPayload,
-        });
-        args.writeAgentInfo(`task=${args.taskId} status=${status} exitCode=${typeof result.code === "number" ? result.code : "null"} signal=${result.signal ?? "null"}`);
-    }
-    finally {
-        args.clearActiveTaskLogContext(args.taskId);
-        await codexAuth?.cleanup().catch(() => undefined);
-    }
-}

package/dist/agent.js

@@ -6,17 +6,18 @@ import { buildAgentSettingsEnvPatch, readAgentModelInstructions, readAgentSettin
 import { handleFsRpcMessage } from "./agent-fs-rpc.js";
 import { handleGitRpcMessage } from "./agent-git-rpc.js";
 import { subscribeToCodexAuthRpc } from "./agent-codex-auth-rpc.js";
-import { buildManagedCodexArgs, createLocalCodexCliTools, normalizeCodexModel, normalizeShellRpcCodexAuthBundle, spawnManagedCodexCommand, } from "./agent-codex-cli.js";
+import { subscribeToDaemonRpc } from "./agent-daemon-rpc.js";
+import { buildDaemonMcpConfigArgs, buildManagedCodexArgs, createLocalCodexCliTools, normalizeCodexModel, normalizeShellRpcCodexAuthBundle, spawnManagedCodexCommand, } from "./agent-codex-cli.js";
 import { connectBootstrapWithRetry } from "./agent-jetstream.js";
 import { prepareCommandExecution } from "./agent-run-execution.js";
 import { attachManagedRunProcessLifecycle, createPendingRunSessionTracker } from "./agent-run-lifecycle.js";
-import { claimRunStartSlot, cloneRunTask, getStoredRun, listPersistedRunTasks, persistRunTask, publishImmediateRunEvent, releaseRunStartSlot, resetRunsDir, removeRunTask, updateRunStartSlotSession, } from "./agent-run-state.js";
+import { claimRunStartSlot, cloneRunTask, getStoredRun, listPersistedRunTasks, persistRunTask, publishImmediateRunEvent, pruneStaleRunsDir, releaseRunStartSlot, removeRunTask, updateRunStartSlotSession, } from "./agent-run-state.js";
 import { runConnectedAgentSession } from "./agent-session-loop.js";
 import { subscribeToSkillRpc } from "./agent-skill-rpc.js";
 import { prepareCodexAuthBundle, sendSignalToPid, sendSignalToTaskProcess, } from "./agent-task-execution.js";
 import { collectSessionJsonlFiles, detectPendingRunSession, findSessionFilePathBySessionId, stopAllSessionWatchers, subscribeToSessionRpc, } from "./agent-session-rpc.js";
 import { handleNonStartRunRpc, normalizeRunRpcRequest, publishRunRpcResponse, } from "./agent-run-rpc.js";
-import { buildAgentCodexAuthRpcSubject, buildAgentFsRpcSubject, buildAgentGitRpcSubject, buildAgentRunEventsSubject, buildAgentRunRpcSubject, buildAgentSessionRpcSubject, buildAgentSettingsRpcSubject, buildAgentSkillRpcSubject, formatLocalTimestamp, normalizeEnvPatch, normalizeRunImagePaths, parseArgs, resolveAgentVersion, resolveArgOrEnv, resolveContainerReachableServerBaseUrl, sanitizeUserId, sleep, writeRunStatus, writeRunStream, } from "./agent-runtime-utils.js";
+import { buildAgentCodexAuthRpcSubject, buildAgentDaemonRpcSubject, buildAgentFsRpcSubject, buildAgentGitRpcSubject, buildAgentRunEventsSubject, buildAgentRunRpcSubject, buildAgentSessionRpcSubject, buildAgentSettingsRpcSubject, buildAgentSkillRpcSubject, formatLocalTimestamp, normalizeEnvPatch, filterValidRunImagePaths, normalizeRunImagePaths, parseArgs, resolveAgentVersion, resolveArgOrEnv, resolveContainerReachableServerBaseUrl, sanitizeUserId, sleep, writeRunStatus, writeRunStream, } from "./agent-runtime-utils.js";
 import { createRuntimeEnvHelpers } from "./agent-runtime-env.js";
 import { createEventPersistenceHelpers, heartbeatAgentSession, postJson, } from "./agent-runtime-io.js";
 import { handleSettingsRpcMessage } from "./agent-settings-rpc.js";
@@ -32,30 +33,6 @@ function resolveWorkspaceRoot() {
     return workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
 }
 const runRpcCodec = StringCodec();
-async function prepareTaskRuntimeConfig(args) {
-    const bundle = await postJson(`${args.serverBaseUrl}/api/agent/tasks/${encodeURIComponent(args.taskId)}/runtime-config`, {
-        userId: args.userId,
-        agentToken: args.agentToken,
-    }).catch((error) => {
-        const message = error instanceof Error ? error.message : String(error);
-        writeAgentError(`task=${args.taskId} runtime config sync skipped: ${message}`);
-        return null;
-    });
-    if (!bundle) {
-        return null;
-    }
-    const envPatch = normalizeEnvPatch(bundle.envPatch);
-    return {
-        envPatch,
-        meta: {
-            runtimeConfigIssuedAt: bundle.issuedAt ?? null,
-            runtimeConfigExpiresAt: bundle.expiresAt ?? null,
-            runtimeConfigVarCount: Object.keys(envPatch).length,
-            runtimeConfigSynced: true,
-            ...(bundle.meta && typeof bundle.meta === "object" && !Array.isArray(bundle.meta) ? bundle.meta : {}),
-        },
-    };
-}
 function writeAgentInfo(message) {
     process.stdout.write(`[doer-agent] ${message}\n`);
     eventPersistenceHelpers.emitAgentMetaLog("info", message);
@@ -275,6 +252,13 @@ async function handleRunRpcMessage(args) {
                 const workspaceRoot = resolveWorkspaceRoot();
                 const localAgentSettings = await readAgentSettingsConfig({ workspaceRoot });
                 const customInstructions = await readAgentModelInstructions(workspaceRoot);
+                const validImagePaths = await filterValidRunImagePaths({
+                    workspaceRoot,
+                    imagePaths: request.imagePaths,
+                    onInvalidImage: (imagePath, reason) => {
+                        writeRunStatus(runId, `skipping invalid image path=${imagePath} reason=${reason}`);
+                    },
+                });
                 const task = await startManagedRun({
                     requestId,
                     runId,
@@ -285,11 +269,15 @@ async function handleRunRpcMessage(args) {
                     sessionId: request.sessionId,
                     codexArgs: buildManagedCodexArgs({
                         prompt: request.prompt ?? "",
-                        imagePaths: request.imagePaths,
+                        imagePaths: validImagePaths,
                         sessionId: request.sessionId,
                         model: request.model,
                         personality: localAgentSettings.general.personality,
                         modelInstructionsFile: customInstructions ? resolveAgentModelInstructionsFilePath(workspaceRoot) : null,
+                        configOverrides: buildDaemonMcpConfigArgs({
+                            agentProjectDir: AGENT_PROJECT_DIR,
+                            workspaceRoot,
+                        }),
                     }),
                     cwd: request.cwd,
                     runtimeEnvPatch: request.runtimeEnvPatch,
@@ -423,7 +411,8 @@ async function main() {
     process.env.WORKSPACE = startupWorkspaceRoot;
     process.env.CODEX_HOME = path.join(startupWorkspaceRoot, ".codex");
     await mkdir(process.env.CODEX_HOME, { recursive: true }).catch(() => undefined);
-    await resetRunsDir(resolveWorkspaceRoot());
+    // Preserve run state for processes that are still alive after an agent restart.
+    await pruneStaleRunsDir(resolveWorkspaceRoot());
     const serverBaseUrlRaw = resolveArgOrEnv(args, ["server", "url"], ["DOER_AGENT_SERVER"], DEFAULT_SERVER_BASE_URL);
     const requestedServerBaseUrl = serverBaseUrlRaw.replace(/\/$/, "");
     const serverBaseUrl = resolveContainerReachableServerBaseUrl(requestedServerBaseUrl);
@@ -489,6 +478,17 @@ async function main() {
                     agentId: initialAgentId,
                     agentToken,
                 });
+                subscribeToDaemonRpc({
+                    nc: jetstream.nc,
+                    subject: buildAgentDaemonRpcSubject(userId, initialAgentId),
+                    workspaceRoot: resolveWorkspaceRoot(),
+                    agentProjectDir: AGENT_PROJECT_DIR,
+                    resolveShellPath: runtimeEnvHelpers.resolveShellPath,
+                    resolveTaskWorkspace: runtimeEnvHelpers.resolveTaskWorkspace,
+                    readAgentSettingsConfig,
+                    onInfo: writeAgentInfo,
+                    onError: writeAgentError,
+                });
                 subscribeToSessionRpc({
                     nc: jetstream.nc,
                     subject: buildAgentSessionRpcSubject(userId, initialAgentId),