doer-agent 0.4.2 → 0.4.4

package/dist/agent.js

@@ -1,10 +1,25 @@
-import { spawn, spawnSync } from "node:child_process";
-import { existsSync, statSync, watch } from "node:fs";
-import { chmod, mkdir, open, readFile, readdir, realpath, rename, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
+import { mkdir } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { gunzipSync, gzipSync } from "node:zlib";
-import { AckPolicy, connect, DeliverPolicy, JSONCodec, RetentionPolicy, StorageType, StringCodec } from "nats";
+import { StringCodec } from "nats";
+import { buildAgentSettingsEnvPatch, readAgentModelInstructions, readAgentSettingsConfig, resolveAgentModelInstructionsFilePath, } from "./agent-settings.js";
+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 { 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 { 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 { createRuntimeEnvHelpers } from "./agent-runtime-env.js";
+import { createEventPersistenceHelpers, heartbeatAgentSession, postJson, } from "./agent-runtime-io.js";
+import { handleSettingsRpcMessage } from "./agent-settings-rpc.js";
 const DEFAULT_SERVER_BASE_URL = "https://doer.cranix.net";
 const AGENT_MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 const AGENT_PROJECT_DIR = path.join(AGENT_MODULE_DIR, "..");
@@ -13,308 +28,10 @@ const HEARTBEAT_INTERVAL_MS = 5_000;
 const HEARTBEAT_FAILURE_THRESHOLD = 3;
 let activeTaskLogContext = null;
 let workspaceRootOverride = null;
-const fsRpcCodec = StringCodec();
-const runRpcCodec = StringCodec();
-const sessionRpcCodec = StringCodec();
-const codexAuthRpcCodec = StringCodec();
-const settingsRpcCodec = StringCodec();
-const gitRpcCodec = StringCodec();
-const skillRpcCodec = StringCodec();
-const runEventsCodec = StringCodec();
-const activeSessionWatchers = new Map();
-const sessionLineIndexCache = new Map();
-const ANSI_RE = /\u001b\[[0-9;]*m/g;
-let pendingCodexDeviceAuth = null;
-function sanitizeUserId(userId) {
-    const normalized = userId.trim().replace(/[^a-zA-Z0-9_-]/g, "_");
-    return normalized.length > 0 ? normalized : "anonymous";
-}
-function buildAgentRunRpcSubject(userId, agentId) {
-    return `doer.agent.run.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
-}
-function buildAgentRunEventsSubject(userId, agentId) {
-    return `doer.agent.run.events.${sanitizeUserId(userId)}.${agentId.trim()}`;
-}
-function buildAgentSessionRpcSubject(userId, agentId) {
-    return `doer.agent.session.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
-}
-function buildAgentCodexAuthRpcSubject(userId, agentId) {
-    return `doer.agent.codex.auth.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
-}
-function buildAgentSettingsRpcSubject(userId, agentId) {
-    return `doer.agent.settings.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
-}
-function buildAgentGitRpcSubject(userId, agentId) {
-    return `doer.agent.git.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
-}
-function buildAgentSkillRpcSubject(userId, agentId) {
-    return `doer.agent.skill.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
-}
-function normalizeNatsServers(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.filter((item) => typeof item === "string").map((v) => v.trim()).filter((v) => v.length > 0);
-}
-function parseBootstrapTaskConfig(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return null;
-    }
-    const task = value;
-    const stream = typeof task.stream === "string" ? task.stream.trim() : "";
-    const subject = typeof task.subject === "string" ? task.subject.trim() : "";
-    const durable = typeof task.durable === "string" ? task.durable.trim() : "";
-    if (!stream || !subject || !durable) {
-        return null;
-    }
-    return { stream, subject, durable };
-}
-function normalizeTaskIds(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    const out = [];
-    for (const item of value) {
-        if (typeof item !== "string") {
-            continue;
-        }
-        const id = item.trim();
-        if (!id) {
-            continue;
-        }
-        out.push(id);
-    }
-    return out;
-}
-function normalizeNatsToken(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return null;
-    }
-    const auth = value;
-    const token = typeof auth.token === "string" ? auth.token.trim() : "";
-    return token.length > 0 ? token : null;
-}
-async function ensureJetStreamInfra(args) {
-    const streamInfo = await args.jsm.streams.info(args.stream).catch(() => null);
-    if (!streamInfo) {
-        await args.jsm.streams.add({
-            name: args.stream,
-            subjects: [args.subject],
-            storage: StorageType.File,
-            retention: RetentionPolicy.Limits,
-        });
-    }
-    if (args.durable) {
-        const consumerInfo = await args.jsm.consumers.info(args.stream, args.durable).catch(() => null);
-        if (!consumerInfo) {
-            await args.jsm.consumers.add(args.stream, {
-                durable_name: args.durable,
-                ack_policy: AckPolicy.Explicit,
-                deliver_policy: DeliverPolicy.All,
-                filter_subject: args.subject,
-                ack_wait: 30_000_000_000,
-            });
-        }
-    }
-}
-async function initJetStreamContext(args) {
-    const sanitized = sanitizeUserId(args.userId);
-    const stream = `DOER_AGENT_EVENTS_${sanitized}`;
-    const subject = `doer.agent.events.${sanitized}`;
-    const durable = `doer-agent-uploader-${sanitized}`;
-    const nc = await connect(args.token ? { servers: args.servers, token: args.token } : { servers: args.servers });
-    const jsm = await nc.jetstreamManager();
-    await ensureJetStreamInfra({ jsm, stream, subject, durable });
-    void (async () => {
-        try {
-            for await (const status of nc.status()) {
-                const statusType = typeof status.type === "string" ? status.type : "unknown";
-                if (statusType === "pingTimer") {
-                    continue;
-                }
-                const statusData = formatNatsStatusData(status.data);
-                writeAgentInfraError("nats status type=" + statusType + " data=" + statusData);
-            }
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            writeAgentInfraError(`nats status loop ended: ${message}`);
-        }
-    })();
-    return {
-        nc,
-        js: nc.jetstream(),
-        jsm,
-        codec: JSONCodec(),
-        subject,
-        stream,
-        durable,
-        servers: args.servers,
-    };
-}
-function resolveCodexHomePath() {
-    const workspaceRoot = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
-    return path.join(workspaceRoot, ".codex");
-}
-function parseEnvBoolean(value) {
-    return value?.trim().toLowerCase() === "true";
-}
-function parseEnvInteger(value, fallback) {
-    const normalized = value?.trim();
-    if (!normalized) {
-        return fallback;
-    }
-    const parsed = Number.parseInt(normalized, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
-}
-function resolveContainerReachableServerBaseUrl(serverBaseUrl) {
-    return serverBaseUrl;
-}
-async function resolveAgentVersion() {
-    const raw = await readFile(AGENT_PACKAGE_JSON_PATH, "utf8").catch(() => "");
-    if (!raw) {
-        return "unknown";
-    }
-    try {
-        const parsed = JSON.parse(raw);
-        return typeof parsed.version === "string" && parsed.version.trim() ? parsed.version.trim() : "unknown";
-    }
-    catch {
-        return "unknown";
-    }
-}
-function pickFirstNonEmpty(values) {
-    for (const value of values) {
-        if (typeof value !== "string") {
-            continue;
-        }
-        const normalized = value.trim();
-        if (normalized) {
-            return normalized;
-        }
-    }
-    return "";
-}
-async function ensureGitAskpassScript() {
-    const binDir = path.join(AGENT_PROJECT_DIR, "runtime/bin");
-    const scriptPath = path.join(binDir, "git-askpass.sh");
-    const scriptBody = `#!/bin/sh
-case "$1" in
-  *Username*) printf "%s\\n" "x-access-token" ;;
-  *Password*) printf "%s\\n" "\${GITHUB_TOKEN:-\${GH_TOKEN:-}}" ;;
-  *) printf "\\n" ;;
-esac
-`;
-    await mkdir(binDir, { recursive: true });
-    await writeFile(scriptPath, scriptBody, "utf8");
-    await chmod(scriptPath, 0o700).catch(() => undefined);
-    return scriptPath;
-}
-function applyGitIdentityIfPossible(args) {
-    if (!args.cwd) {
-        return false;
-    }
-    const inRepo = spawnSync("git", ["rev-parse", "--is-inside-work-tree"], {
-        cwd: args.cwd,
-        stdio: "ignore",
-    });
-    if (inRepo.status !== 0) {
-        return false;
-    }
-    const setName = spawnSync("git", ["config", "--local", "user.name", args.userName], {
-        cwd: args.cwd,
-        stdio: "ignore",
-    });
-    if (setName.status !== 0) {
-        return false;
-    }
-    const setEmail = spawnSync("git", ["config", "--local", "user.email", args.userEmail], {
-        cwd: args.cwd,
-        stdio: "ignore",
-    });
-    return setEmail.status === 0;
-}
-async function prepareTaskGitEnv(args) {
-    const envPatch = {
-        GIT_TERMINAL_PROMPT: "0",
-        GCM_INTERACTIVE: "Never",
-    };
-    const githubToken = pickFirstNonEmpty([
-        args.baseEnvPatch.GITHUB_TOKEN,
-        args.baseEnvPatch.GH_TOKEN,
-        process.env.GITHUB_TOKEN,
-        process.env.GH_TOKEN,
-    ]);
-    if (githubToken) {
-        envPatch.GITHUB_TOKEN = githubToken;
-        envPatch.GH_TOKEN = githubToken;
-        envPatch.GIT_ASKPASS_REQUIRE = "force";
-        envPatch.GIT_ASKPASS = await ensureGitAskpassScript();
-    }
-    const userName = pickFirstNonEmpty([
-        args.baseEnvPatch.DOER_GIT_USER_NAME,
-        args.baseEnvPatch.GIT_USER_NAME,
-        args.baseEnvPatch.GIT_AUTHOR_NAME,
-        args.baseEnvPatch.GIT_COMMITTER_NAME,
-    ]);
-    const userEmail = pickFirstNonEmpty([
-        args.baseEnvPatch.DOER_GIT_USER_EMAIL,
-        args.baseEnvPatch.GIT_USER_EMAIL,
-        args.baseEnvPatch.GIT_AUTHOR_EMAIL,
-        args.baseEnvPatch.GIT_COMMITTER_EMAIL,
-    ]);
-    const gitIdentityApplied = userName && userEmail
-        ? applyGitIdentityIfPossible({
-            cwd: args.cwd,
-            userName,
-            userEmail,
-        })
-        : false;
-    return {
-        envPatch,
-        meta: {
-            gitAskpassEnabled: Boolean(envPatch.GIT_ASKPASS),
-            gitIdentityApplied,
-            gitIdentityProvided: Boolean(userName && userEmail),
-        },
-    };
-}
-function normalizeEnvPatch(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return {};
-    }
-    const out = {};
-    for (const [key, raw] of Object.entries(value)) {
-        if (typeof raw !== "string") {
-            continue;
-        }
-        const normalizedKey = key.trim();
-        if (!normalizedKey) {
-            continue;
-        }
-        out[normalizedKey] = raw;
-    }
-    return out;
-}
-function normalizeRunImagePaths(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    const seen = new Set();
-    const out = [];
-    for (const item of value) {
-        if (typeof item !== "string") {
-            continue;
-        }
-        const normalized = item.trim();
-        if (!normalized || seen.has(normalized)) {
-            continue;
-        }
-        seen.add(normalized);
-        out.push(normalized);
-    }
-    return out;
+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,
@@ -339,22 +56,13 @@ async function prepareTaskRuntimeConfig(args) {
         },
     };
 }
-function fatalExit(message, error) {
-    const detail = error instanceof Error ? error.message : typeof error === "string" ? error : error ? String(error) : "";
-    const full = detail ? `${message}: ${detail}` : message;
-    writeAgentError(`fatal: ${full}`);
-    process.exit(1);
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
 function writeAgentInfo(message) {
     process.stdout.write(`[doer-agent] ${message}\n`);
-    emitAgentMetaLog("info", message);
+    eventPersistenceHelpers.emitAgentMetaLog("info", message);
 }
 function writeAgentError(message) {
     process.stderr.write(`[doer-agent] ${message}\n`);
-    emitAgentMetaLog("error", message);
+    eventPersistenceHelpers.emitAgentMetaLog("error", message);
 }
 function writeAgentInfraError(message) {
     try {
@@ -364,3419 +72,294 @@ function writeAgentInfraError(message) {
         // Keep heartbeat/connectivity failures non-fatal.
     }
 }
-function formatNatsStatusData(value) {
-    if (value === null || value === undefined) {
-        return "null";
-    }
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-        return String(value);
-    }
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return String(value);
-    }
-}
-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`);
+async function updateRunSessionMetadata(task, metadata) {
+    let changed = false;
+    const previousSessionId = task.sessionId;
+    if (!task.sessionId && typeof metadata.sessionId === "string" && metadata.sessionId.trim()) {
+        task.sessionId = metadata.sessionId.trim();
+        changed = true;
     }
-}
-function writeTaskUpload(taskId, message) {
-    process.stdout.write(`[doer-agent][task=${taskId}][upload] ${message}\n`);
-}
-function writeRpcStream(requestId, 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][rpc=${requestId}][${stream}] ${line}\n`);
+    if (!task.sessionFilePath && typeof metadata.sessionFilePath === "string" && metadata.sessionFilePath.trim()) {
+        task.sessionFilePath = metadata.sessionFilePath.trim();
+        changed = true;
     }
-}
-function writeRpcStatus(requestId, message) {
-    process.stdout.write(`[doer-agent][rpc=${requestId}][status] ${message}\n`);
-}
-function writeRunStatus(runId, message) {
-    process.stdout.write(`[doer-agent][run=${runId}][status] ${message}\n`);
-}
-function writeRunStream(runId, stream, chunk) {
-    const target = stream === "stdout" ? process.stdout : process.stderr;
-    const lines = chunk.split(/\r?\n/);
-    for (let index = 0; index < lines.length; index += 1) {
-        const line = lines[index];
-        if (!line && index === lines.length - 1) {
-            continue;
+    if (!task.sessionFilePath && task.sessionId) {
+        const resolvedSessionFilePath = await findSessionFilePathBySessionId(resolveWorkspaceRoot(), task.sessionId).catch(() => null);
+        if (resolvedSessionFilePath) {
+            task.sessionFilePath = resolvedSessionFilePath;
+            changed = true;
         }
-        target.write(`[doer-agent][run=${runId}][${stream}] ${line}\n`);
-    }
-}
-function normalizeRunRpcRequest(args) {
-    const requestId = typeof args.request.requestId === "string" ? args.request.requestId.trim() : "";
-    if (!requestId) {
-        throw new Error("missing requestId");
-    }
-    const requestAgentId = typeof args.request.agentId === "string" ? args.request.agentId.trim() : "";
-    if (!requestAgentId || requestAgentId !== args.agentId) {
-        throw new Error("agent id mismatch");
     }
-    const actionRaw = typeof args.request.action === "string" ? args.request.action.trim() : "";
-    const action = actionRaw === "cancel" || actionRaw === "get" || actionRaw === "list" ? actionRaw : "start";
-    const responseSubject = typeof args.request.responseSubject === "string" ? args.request.responseSubject.trim() : "";
-    if (!responseSubject) {
-        throw new Error("missing responseSubject");
+    if (!changed) {
+        return;
     }
-    const runId = typeof args.request.runId === "string" && args.request.runId.trim() ? args.request.runId.trim() : null;
-    const prompt = typeof args.request.prompt === "string" && args.request.prompt.trim() ? args.request.prompt.trim() : null;
-    const imagePaths = normalizeRunImagePaths(args.request.imagePaths);
-    const sessionId = typeof args.request.sessionId === "string" && args.request.sessionId.trim() ? args.request.sessionId.trim() : null;
-    const model = normalizeCodexModel(args.request.model);
-    if (action === "start" && !prompt) {
-        throw new Error("missing prompt");
+    task.updatedAt = formatLocalTimestamp();
+    await persistRunTask(resolveWorkspaceRoot(), task).catch(() => undefined);
+    if (metadata.nc) {
+        publishImmediateRunEvent({
+            nc: metadata.nc,
+            userId: task.userId,
+            task,
+            buildRunEventsSubject: buildAgentRunEventsSubject,
+        });
     }
-    if ((action === "get" || action === "cancel") && !runId) {
-        throw new Error("missing runId");
+    if (!previousSessionId && task.sessionId) {
+        await updateRunStartSlotSession({
+            workspaceRoot: resolveWorkspaceRoot(),
+            runId: task.id,
+            previousSessionId,
+            sessionId: task.sessionId,
+            formatTimestamp: formatLocalTimestamp,
+        }).catch(() => undefined);
     }
-    const cwd = typeof args.request.cwd === "string" && args.request.cwd.trim() ? args.request.cwd.trim() : null;
-    const sinceSeqRaw = Number(args.request.sinceSeq);
-    const sinceSeq = Number.isInteger(sinceSeqRaw) && sinceSeqRaw >= 0 ? sinceSeqRaw : null;
-    const limitRaw = Number(args.request.limit);
-    const limit = Number.isFinite(limitRaw) ? Math.max(1, Math.min(Math.floor(limitRaw), 200)) : 50;
-    return {
-        requestId,
-        action,
-        runId,
-        prompt,
-        imagePaths,
-        sessionId,
-        model,
-        cwd,
-        responseSubject,
-        sinceSeq,
-        limit,
-        runtimeEnvPatch: normalizeEnvPatch(args.request.runtimeEnvPatch),
-        codexAuthBundle: normalizeShellRpcCodexAuthBundle(args.request.codexAuth),
-    };
-}
-function publishRunRpcResponse(args) {
-    args.nc.publish(args.responseSubject, runRpcCodec.encode(JSON.stringify(args.payload)));
-}
-async function resolveRunsDir() {
-    const workspaceRoot = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
-    const dir = path.join(workspaceRoot, ".doer-agent", "runs");
-    await mkdir(dir, { recursive: true });
-    return dir;
-}
-async function resetRunsDir() {
-    const dir = await resolveRunsDir();
-    await rm(dir, { recursive: true, force: true }).catch(() => undefined);
-    await mkdir(dir, { recursive: true });
 }
-async function persistRunTask(task) {
-    const dir = await resolveRunsDir();
-    const payload = {
-        runId: task.id,
-        agentId: task.agentId,
-        userId: task.userId,
-        processPid: task.processPid,
-        sessionId: task.sessionId,
-        sessionFilePath: task.sessionFilePath,
-        status: task.status,
-        cancelRequested: task.cancelRequested,
-        resultExitCode: task.resultExitCode,
-        resultSignal: task.resultSignal,
-        createdAt: task.createdAt,
-        updatedAt: task.updatedAt,
-        startedAt: task.startedAt,
-        finishedAt: task.finishedAt,
-        error: task.error,
+async function startManagedRun(args) {
+    const prepared = await prepareCommandExecution({
+        cwd: args.cwd,
+        userId: args.userId,
+        taskId: args.runId,
+        codexAuthBundle: args.codexAuthBundle,
+        runtimeEnvPatch: args.runtimeEnvPatch,
+        agentProjectDir: AGENT_PROJECT_DIR,
+        resolveShellPath: runtimeEnvHelpers.resolveShellPath,
+        resolveTaskWorkspace: runtimeEnvHelpers.resolveTaskWorkspace,
+        resolveCodexHomePath: runtimeEnvHelpers.resolveCodexHomePath,
+        prepareCodexAuthBundle,
+        readAgentSettingsConfig,
+        resolveWorkspaceRoot,
+        buildAgentSettingsEnvPatch,
+        prepareTaskGitEnv: runtimeEnvHelpers.prepareTaskGitEnv,
+    });
+    const child = spawnManagedCodexCommand({
+        codexArgs: args.codexArgs,
+        taskWorkspace: prepared.taskWorkspace,
+        env: prepared.env,
+        agentToken: args.agentToken,
+    });
+    const now = formatLocalTimestamp();
+    const task = {
+        id: args.runId,
+        userId: args.userId,
+        agentId: args.agentId,
+        processPid: typeof child.pid === "number" ? child.pid : null,
+        sessionId: typeof args.sessionId === "string" && args.sessionId.trim() ? args.sessionId.trim() : null,
+        sessionFilePath: null,
+        status: "running",
+        cancelRequested: false,
+        resultExitCode: null,
+        resultSignal: null,
+        error: null,
+        createdAt: now,
+        updatedAt: now,
+        startedAt: now,
+        finishedAt: null,
     };
-    await writeFile(path.join(dir, `${task.id}.json`), `${JSON.stringify(payload, null, 2)}\n`, "utf8");
-}
-async function removeRunTask(runId) {
-    const dir = await resolveRunsDir();
-    await unlink(path.join(dir, `${runId}.json`)).catch(() => undefined);
-}
-function sanitizeRunLockSegment(value) {
-    return value.trim().replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 160) || "lock";
-}
-async function resolveRunLocksDir() {
-    const dir = path.join(await resolveRunsDir(), "locks");
-    await mkdir(dir, { recursive: true });
-    return dir;
-}
-async function resolveRunStartLockPath(args) {
-    const dir = await resolveRunLocksDir();
-    if (typeof args.sessionId === "string" && args.sessionId.trim()) {
-        return path.join(dir, `session__${sanitizeRunLockSegment(args.sessionId)}.lock`);
-    }
-    return path.join(dir, "pending_new_session.lock");
-}
-async function claimRunStartSlot(args) {
-    const lockPath = await resolveRunStartLockPath(args);
-    try {
-        const handle = await open(lockPath, "wx");
-        try {
-            const payload = {
-                runId: args.runId,
-                sessionId: typeof args.sessionId === "string" && args.sessionId.trim() ? args.sessionId.trim() : null,
-                pid: process.pid,
-                createdAt: formatLocalTimestamp(),
-            };
-            await handle.writeFile(`${JSON.stringify(payload, null, 2)}\n`, "utf8");
-        }
-        finally {
-            await handle.close().catch(() => undefined);
-        }
-    }
-    catch (error) {
-        if (error?.code === "EEXIST") {
-            const lockContents = await readFile(lockPath, "utf8").catch(() => "");
-            const existingRunId = (() => {
-                try {
-                    const parsed = JSON.parse(lockContents);
-                    return typeof parsed.runId === "string" && parsed.runId.trim() ? parsed.runId.trim() : null;
-                }
-                catch {
-                    return null;
-                }
-            })();
-            throw new Error(existingRunId ? `Another run is already active: ${existingRunId}` : "Another run is already active");
-        }
-        throw error;
-    }
-}
-async function updateRunStartSlotSession(args) {
-    const nextSessionId = args.sessionId.trim();
-    if (!nextSessionId) {
-        return;
-    }
-    const previousSessionId = typeof args.previousSessionId === "string" && args.previousSessionId.trim() ? args.previousSessionId.trim() : null;
-    if (previousSessionId === nextSessionId) {
-        return;
-    }
-    const currentPath = await resolveRunStartLockPath({ runId: args.runId, sessionId: previousSessionId });
-    const nextPath = await resolveRunStartLockPath({ runId: args.runId, sessionId: nextSessionId });
-    if (currentPath === nextPath) {
-        return;
-    }
-    try {
-        await rename(currentPath, nextPath);
-    }
-    catch (error) {
-        const code = error?.code;
-        if (code === "ENOENT") {
-            // Lock may already be released; nothing to migrate.
+    let pendingSessionPollClosed = false;
+    const knownPendingSessionFiles = new Set();
+    const pendingSessionTracker = createPendingRunSessionTracker({
+        task,
+        detectPendingRunSession: async () => detectPendingRunSession(resolveWorkspaceRoot(), knownPendingSessionFiles),
+        updateRunSessionMetadata: async (metadata) => updateRunSessionMetadata(task, { ...metadata, nc: args.nc }),
+    });
+    const stopPendingSessionPoll = () => {
+        pendingSessionPollClosed = true;
+        pendingSessionTracker.stop();
+    };
+    const pollPendingSession = async () => {
+        if (pendingSessionPollClosed) {
+            stopPendingSessionPoll();
             return;
         }
-        if (code === "EEXIST") {
-            throw new Error(`Another run is already active for session: ${nextSessionId}`);
-        }
-        throw error;
-    }
-    const payload = {
-        runId: args.runId,
-        sessionId: nextSessionId,
-        pid: process.pid,
-        createdAt: formatLocalTimestamp(),
-    };
-    await writeFile(nextPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
-}
-async function releaseRunStartSlot(args) {
-    const paths = new Set();
-    paths.add(await resolveRunStartLockPath({ runId: args.runId, sessionId: args.sessionId ?? null }));
-    paths.add(await resolveRunStartLockPath({ runId: args.runId, sessionId: null }));
-    for (const lockPath of paths) {
-        await unlink(lockPath).catch(() => undefined);
-    }
-}
-function resolveAgentSettingsDir() {
-    const workspaceRoot = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
-    return path.join(workspaceRoot, ".doer-agent");
-}
-function resolveAgentSettingsFilePath() {
-    return path.join(resolveAgentSettingsDir(), "config.json");
-}
-function resolveAgentModelInstructionsFilePath() {
-    return path.join(resolveAgentSettingsDir(), "model-instructions.md");
-}
-function createDefaultAgentSettingsConfig() {
-    return {
-        general: {
-            personality: "pragmatic",
-        },
-        codex: {
-            model: "gpt-5.4",
-            authMode: "api_key",
-        },
-        realtime: {
-            model: process.env.OPENAI_REALTIME_MODEL?.trim() || "gpt-realtime",
-            voice: process.env.OPENAI_REALTIME_VOICE?.trim() || "alloy",
-            wakeName: null,
-            requireWakeName: true,
-            apiKey: null,
-        },
-        git: {
-            enabled: true,
-            name: null,
-            email: null,
-            authMode: "none",
-            oauthToken: null,
-            oauthLogin: null,
-            oauthScope: null,
-        },
-        aws: {
-            enabled: true,
-            accessKeyId: null,
-            defaultRegion: null,
-            secretAccessKey: null,
-            sessionToken: null,
-        },
-        jira: {
-            baseUrl: null,
-            email: null,
-            enabled: false,
-            apiToken: null,
-        },
-        notion: {
-            baseUrl: "https://api.notion.com",
-            version: "2022-06-28",
-            enabled: false,
-            apiToken: null,
-        },
-        slack: {
-            baseUrl: "https://slack.com/api",
-            enabled: false,
-            botToken: null,
-        },
-        figma: {
-            baseUrl: "https://api.figma.com",
-            enabled: false,
-            apiToken: null,
-        },
+        await pendingSessionTracker.poll();
     };
-}
-function normalizeNullableString(value) {
-    if (value === null) {
-        return null;
+    if (!task.sessionId) {
+        const existingFiles = await collectSessionJsonlFiles(resolveWorkspaceRoot()).catch(() => []);
+        for (const file of existingFiles) {
+            knownPendingSessionFiles.add(file.filePath);
+        }
+        pendingSessionTracker.start();
     }
-    if (typeof value !== "string") {
-        return null;
+    child.stdout.on("data", (chunk) => writeRunStream(task.id, "stdout", chunk));
+    child.stderr.on("data", (chunk) => writeRunStream(task.id, "stderr", chunk));
+    attachManagedRunProcessLifecycle({
+        child,
+        task,
+        nc: args.nc,
+        stopPendingSessionPoll,
+        getStoredRun: (runId) => getStoredRun(resolveWorkspaceRoot(), runId),
+        publishImmediateRunEvent: (eventArgs) => publishImmediateRunEvent({
+            ...eventArgs,
+            buildRunEventsSubject: buildAgentRunEventsSubject,
+        }),
+        removeRunTask: (runId) => removeRunTask(resolveWorkspaceRoot(), runId),
+        releaseRunStartSlot: ({ runId, sessionId }) => releaseRunStartSlot({
+            workspaceRoot: resolveWorkspaceRoot(),
+            runId,
+            sessionId,
+        }),
+        codexAuthCleanup: prepared.codexAuthCleanup,
+        writeRunStatus,
+        formatTimestamp: formatLocalTimestamp,
+    });
+    void persistRunTask(resolveWorkspaceRoot(), task).catch(() => undefined);
+    publishImmediateRunEvent({ nc: args.nc, userId: task.userId, task, buildRunEventsSubject: buildAgentRunEventsSubject });
+    writeRunStatus(task.id, `started requestId=${args.requestId} cwd=${prepared.taskWorkspace}`);
+    if (!task.sessionId) {
+        void pollPendingSession();
     }
-    const trimmed = value.trim();
-    return trimmed ? trimmed : null;
-}
-function normalizeCodexPersonality(value, fallback) {
-    return value === "friendly" || value === "pragmatic" ? value : fallback;
+    return cloneRunTask(task);
 }
-function normalizeAgentSettingsConfig(value, fallback) {
-    const base = fallback ?? createDefaultAgentSettingsConfig();
-    const raw = value && typeof value === "object" && !Array.isArray(value) ? value : {};
-    const general = raw.general && typeof raw.general === "object" ? raw.general : {};
-    const codex = raw.codex && typeof raw.codex === "object" ? raw.codex : {};
-    const realtime = raw.realtime && typeof raw.realtime === "object" ? raw.realtime : {};
-    const git = raw.git && typeof raw.git === "object" ? raw.git : {};
-    const aws = raw.aws && typeof raw.aws === "object" ? raw.aws : {};
-    const jira = raw.jira && typeof raw.jira === "object" ? raw.jira : {};
-    const notion = raw.notion && typeof raw.notion === "object" ? raw.notion : {};
-    const slack = raw.slack && typeof raw.slack === "object" ? raw.slack : {};
-    const figma = raw.figma && typeof raw.figma === "object" ? raw.figma : {};
-    return {
-        general: {
-            personality: normalizeCodexPersonality(general.personality, base.general.personality),
-        },
-        codex: {
-            model: typeof codex.model === "string" && codex.model.trim() ? codex.model.trim() : base.codex.model,
-            authMode: codex.authMode === "oauth" ? "oauth" : codex.authMode === "api_key" ? "api_key" : base.codex.authMode,
-        },
-        realtime: {
-            model: typeof realtime.model === "string" && realtime.model.trim() ? realtime.model.trim() : base.realtime.model,
-            voice: typeof realtime.voice === "string" && realtime.voice.trim() ? realtime.voice.trim() : base.realtime.voice,
-            wakeName: realtime.wakeName === null ? null : normalizeNullableString(realtime.wakeName) ?? base.realtime.wakeName,
-            requireWakeName: typeof realtime.requireWakeName === "boolean" ? realtime.requireWakeName : base.realtime.requireWakeName,
-            apiKey: realtime.apiKey === null ? null : normalizeNullableString(realtime.apiKey) ?? base.realtime.apiKey,
-        },
-        git: {
-            enabled: typeof git.enabled === "boolean" ? git.enabled : base.git.enabled,
-            name: git.name === null ? null : normalizeNullableString(git.name) ?? base.git.name,
-            email: git.email === null ? null : normalizeNullableString(git.email) ?? base.git.email,
-            authMode: git.authMode === "oauth_app" ? "oauth_app" : git.authMode === "none" ? "none" : base.git.authMode,
-            oauthToken: git.oauthToken === null ? null : normalizeNullableString(git.oauthToken) ?? base.git.oauthToken,
-            oauthLogin: git.oauthLogin === null ? null : normalizeNullableString(git.oauthLogin) ?? base.git.oauthLogin,
-            oauthScope: git.oauthScope === null ? null : normalizeNullableString(git.oauthScope) ?? base.git.oauthScope,
-        },
-        aws: {
-            enabled: typeof aws.enabled === "boolean" ? aws.enabled : base.aws.enabled,
-            accessKeyId: aws.accessKeyId === null ? null : normalizeNullableString(aws.accessKeyId) ?? base.aws.accessKeyId,
-            defaultRegion: aws.defaultRegion === null ? null : normalizeNullableString(aws.defaultRegion) ?? base.aws.defaultRegion,
-            secretAccessKey: aws.secretAccessKey === null ? null : normalizeNullableString(aws.secretAccessKey) ?? base.aws.secretAccessKey,
-            sessionToken: aws.sessionToken === null ? null : normalizeNullableString(aws.sessionToken) ?? base.aws.sessionToken,
-        },
-        jira: {
-            baseUrl: jira.baseUrl === null ? null : normalizeNullableString(jira.baseUrl) ?? base.jira.baseUrl,
-            email: jira.email === null ? null : normalizeNullableString(jira.email) ?? base.jira.email,
-            enabled: typeof jira.enabled === "boolean" ? jira.enabled : base.jira.enabled,
-            apiToken: jira.apiToken === null ? null : normalizeNullableString(jira.apiToken) ?? base.jira.apiToken,
-        },
-        notion: {
-            baseUrl: notion.baseUrl === null ? null : normalizeNullableString(notion.baseUrl) ?? base.notion.baseUrl,
-            version: notion.version === null ? null : normalizeNullableString(notion.version) ?? base.notion.version,
-            enabled: typeof notion.enabled === "boolean" ? notion.enabled : base.notion.enabled,
-            apiToken: notion.apiToken === null ? null : normalizeNullableString(notion.apiToken) ?? base.notion.apiToken,
-        },
-        slack: {
-            baseUrl: slack.baseUrl === null ? null : normalizeNullableString(slack.baseUrl) ?? base.slack.baseUrl,
-            enabled: typeof slack.enabled === "boolean" ? slack.enabled : base.slack.enabled,
-            botToken: slack.botToken === null ? null : normalizeNullableString(slack.botToken) ?? base.slack.botToken,
-        },
-        figma: {
-            baseUrl: figma.baseUrl === null ? null : normalizeNullableString(figma.baseUrl) ?? base.figma.baseUrl,
-            enabled: typeof figma.enabled === "boolean" ? figma.enabled : base.figma.enabled,
-            apiToken: figma.apiToken === null ? null : normalizeNullableString(figma.apiToken) ?? base.figma.apiToken,
+function subscribeToSettingsRpc(args) {
+    const subject = buildAgentSettingsRpcSubject(args.userId, args.agentId);
+    args.jetstream.nc.subscribe(subject, {
+        callback: (error, msg) => {
+            if (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                writeAgentError(`settings rpc subscription error: ${message}`);
+                return;
+            }
+            void handleSettingsRpcMessage({
+                msg,
+                nc: args.jetstream.nc,
+                agentId: args.agentId,
+                workspaceRoot: resolveWorkspaceRoot(),
+                onError: writeAgentError,
+            });
         },
-    };
+    });
+    writeAgentInfo(`settings rpc subscribed subject=${subject}`);
 }
-async function readAgentSettingsConfig(defaults) {
-    const fallback = normalizeAgentSettingsConfig(defaults ?? null);
-    const filePath = resolveAgentSettingsFilePath();
-    const raw = await readFile(filePath, "utf8").catch(() => "");
-    if (!raw.trim()) {
-        return fallback;
-    }
-    try {
-        return normalizeAgentSettingsConfig(JSON.parse(raw), fallback);
-    }
-    catch {
-        return fallback;
-    }
-}
-async function writeAgentSettingsConfig(config) {
-    const dir = resolveAgentSettingsDir();
-    await mkdir(dir, { recursive: true });
-    await writeFile(resolveAgentSettingsFilePath(), `${JSON.stringify(config, null, 2)}\n`, "utf8");
-}
-async function readAgentModelInstructions() {
-    const raw = await readFile(resolveAgentModelInstructionsFilePath(), "utf8").catch(() => "");
-    return raw.trim() ? raw : null;
-}
-async function writeAgentModelInstructions(value) {
-    const filePath = resolveAgentModelInstructionsFilePath();
-    const nextValue = typeof value === "string" ? value.trim() : "";
-    if (!nextValue) {
-        await unlink(filePath).catch(() => undefined);
-        return;
-    }
-    await mkdir(resolveAgentSettingsDir(), { recursive: true });
-    await writeFile(filePath, value ?? "", "utf8");
-}
-function maskSecretPreview(secret) {
-    if (secret.length <= 6) {
-        return `${secret.slice(0, 1)}***${secret.slice(-1)}`;
-    }
-    return `${secret.slice(0, 4)}...${secret.slice(-4)}`;
-}
-function toMaskedSecret(value) {
-    if (!value) {
-        return { has: false, masked: null, length: null };
-    }
-    return { has: true, masked: maskSecretPreview(value), length: value.length };
-}
-async function toAgentSettingsPublic(config) {
-    const realtimeKey = toMaskedSecret(config.realtime.apiKey);
-    const gitOauth = toMaskedSecret(config.git.oauthToken);
-    const awsSecret = toMaskedSecret(config.aws.secretAccessKey);
-    const awsSession = toMaskedSecret(config.aws.sessionToken);
-    const jiraToken = toMaskedSecret(config.jira.apiToken);
-    const notionToken = toMaskedSecret(config.notion.apiToken);
-    const slackToken = toMaskedSecret(config.slack.botToken);
-    const figmaToken = toMaskedSecret(config.figma.apiToken);
-    const customInstructions = await readAgentModelInstructions();
-    return {
-        general: {
-            personality: config.general.personality,
-            customInstructions,
-        },
-        codex: {
-            model: config.codex.model,
-            authMode: config.codex.authMode,
-            hasApiKey: false,
-            apiKeyMasked: null,
-            apiKeyLength: null,
-        },
-        realtime: {
-            model: config.realtime.model,
-            voice: config.realtime.voice,
-            wakeName: config.realtime.wakeName,
-            requireWakeName: config.realtime.requireWakeName,
-            hasApiKey: realtimeKey.has,
-            apiKeyMasked: realtimeKey.masked,
-            apiKeyLength: realtimeKey.length,
-        },
-        git: {
-            enabled: config.git.enabled,
-            name: config.git.name,
-            email: config.git.email,
-            authMode: config.git.authMode,
-            hasOauthToken: gitOauth.has,
-            oauthTokenMasked: gitOauth.masked,
-            oauthTokenLength: gitOauth.length,
-            oauthLogin: config.git.oauthLogin,
-            oauthScope: config.git.oauthScope,
-        },
-        aws: {
-            enabled: config.aws.enabled,
-            accessKeyId: config.aws.accessKeyId,
-            defaultRegion: config.aws.defaultRegion,
-            hasSecretAccessKey: awsSecret.has,
-            secretAccessKeyMasked: awsSecret.masked,
-            secretAccessKeyLength: awsSecret.length,
-            hasSessionToken: awsSession.has,
-            sessionTokenMasked: awsSession.masked,
-            sessionTokenLength: awsSession.length,
-        },
-        jira: {
-            baseUrl: config.jira.baseUrl,
-            email: config.jira.email,
-            enabled: config.jira.enabled,
-            hasApiToken: jiraToken.has,
-            apiTokenMasked: jiraToken.masked,
-            apiTokenLength: jiraToken.length,
-        },
-        notion: {
-            baseUrl: config.notion.baseUrl,
-            version: config.notion.version,
-            enabled: config.notion.enabled,
-            hasApiToken: notionToken.has,
-            apiTokenMasked: notionToken.masked,
-            apiTokenLength: notionToken.length,
-        },
-        slack: {
-            baseUrl: config.slack.baseUrl,
-            enabled: config.slack.enabled,
-            hasBotToken: slackToken.has,
-            botTokenMasked: slackToken.masked,
-            botTokenLength: slackToken.length,
-        },
-        figma: {
-            baseUrl: config.figma.baseUrl,
-            enabled: config.figma.enabled,
-            hasApiToken: figmaToken.has,
-            apiTokenMasked: figmaToken.masked,
-            apiTokenLength: figmaToken.length,
-        },
-    };
-}
-function normalizeAgentSettingsPatch(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return {};
-    }
-    const raw = value;
-    const patch = { ...raw };
-    const assignNested = (section, key, value) => {
-        const current = patch[section] && typeof patch[section] === "object" && !Array.isArray(patch[section])
-            ? ({ ...patch[section] })
-            : {};
-        current[key] = value;
-        patch[section] = current;
-    };
-    const move = (flatKey, section, key) => {
-        if (!(flatKey in raw)) {
-            return;
-        }
-        assignNested(section, key, raw[flatKey]);
-        delete patch[flatKey];
-    };
-    move("personality", "general", "personality");
-    move("codexModel", "codex", "model");
-    move("codexAuthMode", "codex", "authMode");
-    move("realtimeModel", "realtime", "model");
-    move("realtimeVoice", "realtime", "voice");
-    move("realtimeWakeName", "realtime", "wakeName");
-    move("realtimeRequireWakeName", "realtime", "requireWakeName");
-    move("realtimeApiKey", "realtime", "apiKey");
-    move("gitEnabled", "git", "enabled");
-    move("gitName", "git", "name");
-    move("gitEmail", "git", "email");
-    move("gitAuthMode", "git", "authMode");
-    move("gitOauthToken", "git", "oauthToken");
-    move("gitOauthLogin", "git", "oauthLogin");
-    move("gitOauthScope", "git", "oauthScope");
-    move("awsEnabled", "aws", "enabled");
-    move("awsAccessKeyId", "aws", "accessKeyId");
-    move("awsDefaultRegion", "aws", "defaultRegion");
-    move("awsSecretAccessKey", "aws", "secretAccessKey");
-    move("awsSessionToken", "aws", "sessionToken");
-    move("jiraBaseUrl", "jira", "baseUrl");
-    move("jiraEmail", "jira", "email");
-    move("jiraEnabled", "jira", "enabled");
-    move("jiraApiToken", "jira", "apiToken");
-    move("notionBaseUrl", "notion", "baseUrl");
-    move("notionVersion", "notion", "version");
-    move("notionEnabled", "notion", "enabled");
-    move("notionApiToken", "notion", "apiToken");
-    move("slackBaseUrl", "slack", "baseUrl");
-    move("slackEnabled", "slack", "enabled");
-    move("slackBotToken", "slack", "botToken");
-    move("figmaBaseUrl", "figma", "baseUrl");
-    move("figmaEnabled", "figma", "enabled");
-    move("figmaApiToken", "figma", "apiToken");
-    return patch;
-}
-async function resolveAgentSettingsConfig(args) {
-    const existing = await readAgentSettingsConfig(args.defaults ?? null);
-    const next = normalizeAgentSettingsConfig(args.patch ?? null, existing);
-    return next;
-}
-function buildAgentSettingsEnvPatch(config) {
-    const envPatch = {};
-    if (config.git.enabled) {
-        if (config.git.name)
-            envPatch.GIT_AUTHOR_NAME = config.git.name;
-        if (config.git.name)
-            envPatch.GIT_COMMITTER_NAME = config.git.name;
-        if (config.git.email)
-            envPatch.GIT_AUTHOR_EMAIL = config.git.email;
-        if (config.git.email)
-            envPatch.GIT_COMMITTER_EMAIL = config.git.email;
-        if (config.git.oauthToken)
-            envPatch.GITHUB_TOKEN = config.git.oauthToken;
-        if (config.git.oauthToken)
-            envPatch.GH_TOKEN = config.git.oauthToken;
-        if (config.git.oauthLogin)
-            envPatch.DOER_GIT_OAUTH_LOGIN = config.git.oauthLogin;
-        if (config.git.oauthScope)
-            envPatch.DOER_GIT_OAUTH_SCOPE = config.git.oauthScope;
-    }
-    if (config.aws.enabled) {
-        if (config.aws.accessKeyId)
-            envPatch.AWS_ACCESS_KEY_ID = config.aws.accessKeyId;
-        if (config.aws.defaultRegion)
-            envPatch.AWS_DEFAULT_REGION = config.aws.defaultRegion;
-        if (config.aws.defaultRegion)
-            envPatch.AWS_REGION = config.aws.defaultRegion;
-        if (config.aws.secretAccessKey)
-            envPatch.AWS_SECRET_ACCESS_KEY = config.aws.secretAccessKey;
-        if (config.aws.sessionToken)
-            envPatch.AWS_SESSION_TOKEN = config.aws.sessionToken;
-    }
-    if (config.jira.enabled) {
-        if (config.jira.baseUrl)
-            envPatch.JIRA_BASE_URL = config.jira.baseUrl;
-        if (config.jira.email)
-            envPatch.JIRA_EMAIL = config.jira.email;
-        if (config.jira.apiToken)
-            envPatch.JIRA_API_TOKEN = config.jira.apiToken;
-    }
-    if (config.notion.enabled) {
-        if (config.notion.baseUrl)
-            envPatch.NOTION_BASE_URL = config.notion.baseUrl;
-        if (config.notion.version)
-            envPatch.NOTION_VERSION = config.notion.version;
-        if (config.notion.apiToken)
-            envPatch.NOTION_API_TOKEN = config.notion.apiToken;
-    }
-    if (config.slack.enabled) {
-        if (config.slack.baseUrl)
-            envPatch.SLACK_BASE_URL = config.slack.baseUrl;
-        if (config.slack.botToken)
-            envPatch.SLACK_BOT_TOKEN = config.slack.botToken;
-    }
-    if (config.figma.enabled) {
-        if (config.figma.baseUrl)
-            envPatch.FIGMA_BASE_URL = config.figma.baseUrl;
-        if (config.figma.apiToken)
-            envPatch.FIGMA_API_TOKEN = config.figma.apiToken;
-    }
-    return envPatch;
-}
-function cloneRunTask(task, _sinceSeq) {
-    return {
-        ...task,
-    };
-}
-function buildImmediateRunEvent(task, type) {
-    return {
-        type,
-        agentId: task.agentId,
-        sessionId: task.sessionId,
-        filePath: task.sessionFilePath,
-        runId: task.id,
-        updatedAt: task.updatedAt,
-        status: task.status,
-        cancelRequested: task.cancelRequested,
-        resultExitCode: task.resultExitCode,
-        resultSignal: task.resultSignal,
-        error: task.error,
-        finishedAt: task.finishedAt,
-    };
-}
-function publishImmediateRunEvent(args) {
-    args.nc.publish(buildAgentRunEventsSubject(args.userId, args.task.agentId), runEventsCodec.encode(JSON.stringify(buildImmediateRunEvent(args.task, args.type ?? "run.changed"))));
-}
-async function findSessionFilePathBySessionId(sessionId) {
-    const targetSessionId = sessionId.trim();
-    if (!targetSessionId) {
-        return null;
-    }
-    let sessionsRootStat;
-    try {
-        sessionsRootStat = await stat(getSessionsRootPath());
-    }
-    catch {
-        return null;
-    }
-    if (!sessionsRootStat.isDirectory()) {
-        return null;
-    }
-    const files = await collectSessionJsonlFiles(getSessionsRootPath());
-    files.sort((a, b) => b.mtimeMs - a.mtimeMs || a.filePath.localeCompare(b.filePath));
-    for (const file of files) {
-        let fileHandle = null;
-        try {
-            fileHandle = await open(file.filePath, "r");
-            const entryStat = await fileHandle.stat();
-            const firstLine = await readFirstLine(fileHandle, entryStat.size);
-            if (!firstLine) {
-                continue;
-            }
-            const parsed = JSON.parse(firstLine);
-            const candidateMeta = parsed && parsed.type === "session_meta" && isObjectRecord(parsed.payload)
-                ? parsed.payload
-                : isObjectRecord(parsed.session_meta)
-                    ? parsed.session_meta
-                    : isObjectRecord(parsed.sessionMeta)
-                        ? parsed.sessionMeta
-                        : isObjectRecord(parsed.meta)
-                            ? parsed.meta
-                            : isObjectRecord(parsed.payload)
-                                ? parsed.payload
-                                : parsed;
-            const candidateId = pickSessionString(candidateMeta.sessionId, candidateMeta.session_id, candidateMeta.id);
-            if (candidateId === targetSessionId) {
-                return file.filePath;
-            }
-        }
-        catch {
-            // ignore malformed session files
-        }
-        finally {
-            await fileHandle?.close().catch(() => undefined);
-        }
-    }
-    return null;
-}
-async function readSessionIdFromSessionFile(filePath) {
-    let fileHandle = null;
-    try {
-        fileHandle = await open(filePath, "r");
-        const entryStat = await fileHandle.stat();
-        const firstLine = await readFirstLine(fileHandle, entryStat.size);
-        if (!firstLine) {
-            return null;
-        }
-        const parsed = JSON.parse(firstLine);
-        const candidateMeta = parsed && parsed.type === "session_meta" && isObjectRecord(parsed.payload)
-            ? parsed.payload
-            : isObjectRecord(parsed.session_meta)
-                ? parsed.session_meta
-                : isObjectRecord(parsed.sessionMeta)
-                    ? parsed.sessionMeta
-                    : isObjectRecord(parsed.meta)
-                        ? parsed.meta
-                        : isObjectRecord(parsed.payload)
-                            ? parsed.payload
-                            : parsed;
-        return pickSessionString(candidateMeta.sessionId, candidateMeta.session_id, candidateMeta.id);
-    }
-    catch {
-        return null;
-    }
-    finally {
-        await fileHandle?.close().catch(() => undefined);
-    }
-}
-async function detectPendingRunSession(knownFilePaths) {
-    const sessionsRoot = getSessionsRootPath();
-    let sessionsRootStat;
-    try {
-        sessionsRootStat = await stat(sessionsRoot);
-    }
-    catch {
-        return null;
-    }
-    if (!sessionsRootStat.isDirectory()) {
-        return null;
-    }
-    const files = await collectSessionJsonlFiles(sessionsRoot);
-    files.sort((a, b) => a.mtimeMs - b.mtimeMs || a.filePath.localeCompare(b.filePath));
-    for (const file of files) {
-        if (knownFilePaths.has(file.filePath)) {
-            continue;
-        }
-        const sessionId = await readSessionIdFromSessionFile(file.filePath);
-        if (!sessionId) {
-            continue;
-        }
-        knownFilePaths.add(file.filePath);
-        return {
-            sessionId,
-            sessionFilePath: file.filePath,
-        };
-    }
-    return null;
-}
-async function updateRunSessionMetadata(task, metadata) {
-    let changed = false;
-    const previousSessionId = task.sessionId;
-    if (!task.sessionId && typeof metadata.sessionId === "string" && metadata.sessionId.trim()) {
-        task.sessionId = metadata.sessionId.trim();
-        changed = true;
-    }
-    if (!task.sessionFilePath && typeof metadata.sessionFilePath === "string" && metadata.sessionFilePath.trim()) {
-        task.sessionFilePath = metadata.sessionFilePath.trim();
-        changed = true;
-    }
-    if (!task.sessionFilePath && task.sessionId) {
-        const resolvedSessionFilePath = await findSessionFilePathBySessionId(task.sessionId).catch(() => null);
-        if (resolvedSessionFilePath) {
-            task.sessionFilePath = resolvedSessionFilePath;
-            changed = true;
-        }
-    }
-    if (!changed) {
-        return;
-    }
-    task.updatedAt = formatLocalTimestamp();
-    await persistRunTask(task).catch(() => undefined);
-    if (metadata.nc) {
-        publishImmediateRunEvent({
-            nc: metadata.nc,
-            userId: task.userId,
-            task,
-        });
-    }
-    if (!previousSessionId && task.sessionId) {
-        await updateRunStartSlotSession({
-            runId: task.id,
-            previousSessionId,
-            sessionId: task.sessionId,
-        }).catch(() => undefined);
-    }
-}
-function normalizePersistedRunTask(value) {
-    if (!value || typeof value !== "object") {
-        return null;
-    }
-    const record = value;
-    const id = typeof record.runId === "string" && record.runId.trim()
-        ? record.runId.trim()
-        : typeof record.id === "string" && record.id.trim()
-            ? record.id.trim()
-            : "";
-    const userId = typeof record.userId === "string" ? record.userId : "";
-    const agentId = typeof record.agentId === "string" ? record.agentId : "";
-    const status = record.status;
-    if (!id || !userId || !agentId || !["queued", "running", "completed", "failed", "canceled"].includes(String(status))) {
-        return null;
-    }
-    return {
-        id,
-        userId,
-        agentId,
-        processPid: typeof record.processPid === "number" ? record.processPid : null,
-        sessionId: typeof record.sessionId === "string" && record.sessionId.trim() ? record.sessionId.trim() : null,
-        sessionFilePath: typeof record.sessionFilePath === "string" && record.sessionFilePath.trim() ? record.sessionFilePath.trim() : null,
-        status: status,
-        cancelRequested: Boolean(record.cancelRequested),
-        resultExitCode: typeof record.resultExitCode === "number" ? record.resultExitCode : null,
-        resultSignal: typeof record.resultSignal === "string" && record.resultSignal.trim() ? record.resultSignal.trim() : null,
-        error: typeof record.error === "string" && record.error.trim() ? record.error : null,
-        createdAt: typeof record.createdAt === "string" ? record.createdAt : "",
-        updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : "",
-        startedAt: typeof record.startedAt === "string" && record.startedAt.trim() ? record.startedAt : null,
-        finishedAt: typeof record.finishedAt === "string" && record.finishedAt.trim() ? record.finishedAt : null,
-    };
-}
-async function listPersistedRunTasks() {
-    const dir = await resolveRunsDir();
-    const names = await readdir(dir).catch(() => []);
-    const tasks = await Promise.all(names
-        .filter((name) => name.endsWith(".json"))
-        .map(async (name) => {
-        const raw = await readFile(path.join(dir, name), "utf8").catch(() => null);
-        if (!raw) {
-            return null;
-        }
-        try {
-            return normalizePersistedRunTask(JSON.parse(raw));
-        }
-        catch {
-            return null;
-        }
-    }));
-    return tasks.filter((task) => task !== null);
-}
-async function getStoredRun(runId) {
-    const persisted = await readFile(path.join(await resolveRunsDir(), `${runId}.json`), "utf8").catch(() => null);
-    if (persisted) {
-        try {
-            const parsed = normalizePersistedRunTask(JSON.parse(persisted));
-            if (parsed) {
-                return parsed;
-            }
-        }
-        catch {
-            // Ignore malformed persisted state.
-        }
-    }
-    return null;
-}
-async function startManagedRun(args) {
-    const prepared = await prepareCommandExecution({
-        cwd: args.cwd,
-        userId: args.userId,
-        taskId: args.runId,
-        codexAuthBundle: args.codexAuthBundle,
-        runtimeEnvPatch: args.runtimeEnvPatch,
-    });
-    const child = spawnManagedCodexCommand({
-        codexArgs: args.codexArgs,
-        taskWorkspace: prepared.taskWorkspace,
-        env: prepared.env,
-        agentToken: args.agentToken,
-    });
-    const now = formatLocalTimestamp();
-    const task = {
-        id: args.runId,
-        userId: args.userId,
-        agentId: args.agentId,
-        processPid: typeof child.pid === "number" ? child.pid : null,
-        sessionId: typeof args.sessionId === "string" && args.sessionId.trim() ? args.sessionId.trim() : null,
-        sessionFilePath: null,
-        status: "running",
-        cancelRequested: false,
-        resultExitCode: null,
-        resultSignal: null,
-        error: null,
-        createdAt: now,
-        updatedAt: now,
-        startedAt: now,
-        finishedAt: null,
-    };
-    let pendingSessionPollClosed = false;
-    let pendingSessionPollTimer = null;
-    const knownPendingSessionFiles = new Set();
-    const stopPendingSessionPoll = () => {
-        pendingSessionPollClosed = true;
-        if (pendingSessionPollTimer) {
-            clearInterval(pendingSessionPollTimer);
-            pendingSessionPollTimer = null;
-        }
-    };
-    const pollPendingSession = async () => {
-        if (pendingSessionPollClosed || task.sessionId) {
-            stopPendingSessionPoll();
-            return;
-        }
-        const detected = await detectPendingRunSession(knownPendingSessionFiles).catch(() => null);
-        if (!detected) {
-            return;
-        }
-        await updateRunSessionMetadata(task, {
-            sessionId: detected.sessionId,
-            sessionFilePath: detected.sessionFilePath,
-            nc: args.nc,
-        }).catch(() => undefined);
-        if (task.sessionId) {
-            stopPendingSessionPoll();
-        }
-    };
-    if (!task.sessionId) {
-        const existingFiles = await collectSessionJsonlFiles(getSessionsRootPath()).catch(() => []);
-        for (const file of existingFiles) {
-            knownPendingSessionFiles.add(file.filePath);
-        }
-        pendingSessionPollTimer = setInterval(() => {
-            void pollPendingSession();
-        }, 1000);
-    }
-    child.stdout.on("data", (chunk) => writeRunStream(task.id, "stdout", chunk));
-    child.stderr.on("data", (chunk) => writeRunStream(task.id, "stderr", chunk));
-    child.once("error", (error) => {
-        stopPendingSessionPoll();
-        const message = error instanceof Error ? error.message : String(error);
-        task.status = "failed";
-        task.error = message;
-        task.finishedAt = formatLocalTimestamp();
-        publishImmediateRunEvent({ nc: args.nc, userId: task.userId, task });
-        publishImmediateRunEvent({ nc: args.nc, userId: task.userId, task, type: "run.finished" });
-        void removeRunTask(task.id).catch(() => undefined);
-        void releaseRunStartSlot({ runId: task.id, sessionId: task.sessionId }).catch(() => undefined);
-        void prepared.codexAuthCleanup().catch(() => undefined);
-        writeRunStatus(task.id, `failed error=${message}`);
-    });
-    child.once("close", async (code, signal) => {
-        stopPendingSessionPoll();
-        const latest = await getStoredRun(task.id).catch(() => null);
-        if (latest?.cancelRequested) {
-            task.cancelRequested = true;
-        }
-        task.resultExitCode = typeof code === "number" ? code : null;
-        task.resultSignal = signal;
-        task.finishedAt = formatLocalTimestamp();
-        task.status = task.cancelRequested ? "canceled" : (task.resultExitCode ?? 1) === 0 ? "completed" : "failed";
-        task.error = task.status === "failed" ? `Command exited with code ${task.resultExitCode ?? "null"}` : null;
-        publishImmediateRunEvent({ nc: args.nc, userId: task.userId, task });
-        publishImmediateRunEvent({ nc: args.nc, userId: task.userId, task, type: "run.finished" });
-        void removeRunTask(task.id).catch(() => undefined);
-        void releaseRunStartSlot({ runId: task.id, sessionId: task.sessionId }).catch(() => undefined);
-        void prepared.codexAuthCleanup().catch(() => undefined);
-        writeRunStatus(task.id, `completed status=${task.status} exitCode=${task.resultExitCode ?? "null"} signal=${task.resultSignal ?? "null"}`);
-    });
-    void persistRunTask(task).catch(() => undefined);
-    publishImmediateRunEvent({ nc: args.nc, userId: task.userId, task });
-    writeRunStatus(task.id, `started requestId=${args.requestId} cwd=${prepared.taskWorkspace}`);
-    if (!task.sessionId) {
-        void pollPendingSession();
-    }
-    return cloneRunTask(task);
-}
-function shellSingleQuote(value) {
-    return `'${value.replace(/'/g, `'"'"'`)}'`;
-}
-function stripAnsi(value) {
-    return value.replace(ANSI_RE, "");
-}
-function normalizeCodexModel(value) {
-    const normalized = typeof value === "string" ? value.trim() : "";
-    return normalized || "gpt-5.4";
-}
-function toTomlStringLiteral(value) {
-    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-}
-function buildManagedCodexArgs(args) {
-    const promptArgs = ["--", args.prompt];
-    const fixedArgs = ["--dangerously-bypass-approvals-and-sandbox"];
-    const configArgs = [
-        ...(args.personality ? ["--config", `personality=${toTomlStringLiteral(args.personality)}`] : []),
-        ...(args.modelInstructionsFile
-            ? ["--config", `model_instructions_file=${toTomlStringLiteral(args.modelInstructionsFile)}`]
-            : []),
-    ];
-    const imageArgs = args.imagePaths.flatMap((imagePath) => ["--image", imagePath]);
-    return [
-        ...fixedArgs,
-        ...configArgs,
-        "--model",
-        args.model,
-        ...(args.sessionId
-            ? ["exec", "resume", ...imageArgs, args.sessionId, ...promptArgs]
-            : ["exec", ...imageArgs, ...promptArgs]),
-    ];
-}
-function buildLocalCodexCliCommand(args) {
-    const quotedArgs = args.map(shellSingleQuote).join(" ");
-    const direct = `exec codex ${quotedArgs}`;
-    const fallback = `exec npm exec --yes --package doer-agent -- codex ${quotedArgs}`;
-    const script = [
-        "if command -v codex >/dev/null 2>&1; then",
-        `  ${direct}`,
-        "fi",
-        fallback,
-    ].join("\n");
-    return `bash -lc ${shellSingleQuote(script)}`;
-}
-function hasDirectCodexBinary() {
-    const result = spawnSync("bash", ["-lc", "command -v codex >/dev/null 2>&1"], {
-        stdio: "ignore",
-    });
-    return result.status === 0;
-}
-function spawnManagedCodexCommand(args) {
-    const env = {
-        ...args.env,
-        DOER_AGENT_TOKEN: args.agentToken,
-    };
-    const child = hasDirectCodexBinary()
-        ? spawn("codex", args.codexArgs, {
-            cwd: args.taskWorkspace,
-            detached: process.platform !== "win32",
-            env,
-            stdio: ["ignore", "pipe", "pipe"],
-        })
-        : spawn("npm", ["exec", "--yes", "--package", "doer-agent", "--", "codex", ...args.codexArgs], {
-            cwd: args.taskWorkspace,
-            detached: process.platform !== "win32",
-            env,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-    child.stdout?.setEncoding("utf8");
-    child.stderr?.setEncoding("utf8");
-    return child;
-}
-async function runLocalCodexCli(args, timeoutMs, envPatch) {
-    const command = buildLocalCodexCliCommand(args);
-    const workspaceRoot = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
-    const env = {
-        ...process.env,
-        ...(envPatch ?? {}),
-        WORKSPACE: workspaceRoot,
-        CODEX_HOME: resolveCodexHomePath(),
-    };
-    return await new Promise((resolve, reject) => {
-        const child = spawn(command, {
-            cwd: workspaceRoot,
-            shell: resolveShellPath(),
-            env,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        let stdout = "";
-        let stderr = "";
-        let done = false;
-        let timedOut = false;
-        child.stdout.setEncoding("utf8");
-        child.stderr.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => {
-            stdout += chunk;
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr += chunk;
-        });
-        const timer = setTimeout(() => {
-            timedOut = true;
-            sendSignalToTaskProcess(child, "SIGTERM");
-            setTimeout(() => sendSignalToTaskProcess(child, "SIGKILL"), 1000);
-        }, Math.max(500, timeoutMs));
-        child.once("error", (error) => {
-            if (done) {
-                return;
-            }
-            done = true;
-            clearTimeout(timer);
-            reject(error);
-        });
-        child.once("exit", (code) => {
-            if (done) {
-                return;
-            }
-            done = true;
-            clearTimeout(timer);
-            resolve({ code, stdout, stderr, timedOut });
-        });
-    });
-}
-async function runLocalCodexCliWithInput(args, input, timeoutMs, envPatch) {
-    const command = buildLocalCodexCliCommand(args);
-    const workspaceRoot = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
-    const env = {
-        ...process.env,
-        ...(envPatch ?? {}),
-        WORKSPACE: workspaceRoot,
-        CODEX_HOME: resolveCodexHomePath(),
-    };
-    return await new Promise((resolve, reject) => {
-        const child = spawn(command, {
-            cwd: workspaceRoot,
-            shell: resolveShellPath(),
-            env,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        let stdout = "";
-        let stderr = "";
-        let done = false;
-        let timedOut = false;
-        child.stdout.setEncoding("utf8");
-        child.stderr.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => {
-            stdout += chunk;
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr += chunk;
-        });
-        child.stdin?.write(input);
-        if (!input.endsWith("\n")) {
-            child.stdin?.write("\n");
-        }
-        child.stdin?.end();
-        const timer = setTimeout(() => {
-            timedOut = true;
-            sendSignalToTaskProcess(child, "SIGTERM");
-            setTimeout(() => sendSignalToTaskProcess(child, "SIGKILL"), 1000);
-        }, Math.max(500, timeoutMs));
-        child.once("error", (error) => {
-            if (done) {
-                return;
-            }
-            done = true;
-            clearTimeout(timer);
-            reject(error);
-        });
-        child.once("exit", (code) => {
-            if (done) {
-                return;
-            }
-            done = true;
-            clearTimeout(timer);
-            resolve({ code, stdout, stderr, timedOut });
-        });
-    });
-}
-function buildSkillGeneratorPrompt(userPrompt) {
-    return [
-        "Create a Codex skill from the user's description.",
-        "",
-        "Return JSON only with this shape:",
-        '{ "skillName": "kebab-or-dot-or-underscore-name", "skillMd": "full SKILL.md content" }',
-        "",
-        "Requirements:",
-        "- skillName must be lowercase ASCII and use only letters, numbers, dot, underscore, or dash.",
-        "- skillName must not start with a dot and must not be .system.",
-        "- skillMd must be a complete SKILL.md file.",
-        "- skillMd must start with YAML frontmatter containing name and description.",
-        "- Keep the skill concise and action-oriented.",
-        "- Include when to use the skill, the core workflow, and any important constraints.",
-        "- Do not add README, changelog, or any extra files.",
-        "",
-        "User request:",
-        userPrompt.trim(),
-    ].join("\n");
-}
-function extractJsonObject(value) {
-    const trimmed = value.trim();
-    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
-        return trimmed;
-    }
-    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
-    if (fenced?.[1]) {
-        return fenced[1].trim();
-    }
-    const start = trimmed.indexOf("{");
-    const end = trimmed.lastIndexOf("}");
-    if (start >= 0 && end > start) {
-        return trimmed.slice(start, end + 1);
-    }
-    throw new Error("Codex did not return JSON");
-}
-function slugifySkillName(value) {
-    return value
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9._-]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .replace(/-{2,}/g, "-");
-}
-function normalizeGeneratedSkill(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        throw new Error("Invalid generated skill payload");
-    }
-    const row = value;
-    const skillName = slugifySkillName(typeof row.skillName === "string" ? row.skillName : "");
-    const skillMd = typeof row.skillMd === "string" ? row.skillMd.trim() : "";
-    if (!skillName || skillName.startsWith(".") || skillName === ".system") {
-        throw new Error("Codex returned an invalid skill name");
-    }
-    if (!skillMd) {
-        throw new Error("Codex returned an empty SKILL.md");
-    }
-    if (!/^---\s*\n[\s\S]*?\n---\s*\n/m.test(skillMd)) {
-        throw new Error("Generated SKILL.md is missing YAML frontmatter");
-    }
-    if (!/\nname:\s*[^\n]+/i.test(skillMd) || !/\ndescription:\s*[^\n]+/i.test(skillMd)) {
-        throw new Error("Generated SKILL.md frontmatter is incomplete");
-    }
-    return { skillName, skillMd };
-}
-function buildSkillGeneratorCodexArgs(prompt, model) {
-    return ["--dangerously-bypass-approvals-and-sandbox", "--model", model, "exec", "--", prompt];
-}
-async function generateSkillViaCodex(userPrompt) {
-    const localAgentSettings = await readAgentSettingsConfig(null);
-    const envPatch = buildAgentSettingsEnvPatch(localAgentSettings);
-    const prompt = buildSkillGeneratorPrompt(userPrompt);
-    const result = await runLocalCodexCli(buildSkillGeneratorCodexArgs(prompt, localAgentSettings.codex.model || "gpt-5.4"), 120_000, envPatch);
-    if (result.timedOut) {
-        throw new Error("Codex timed out while generating the skill");
-    }
-    if ((result.code ?? 1) !== 0) {
-        const details = stripAnsi(result.stderr || result.stdout).trim();
-        throw new Error(details || `Codex exited with code ${result.code ?? "null"}`);
-    }
-    const payload = JSON.parse(extractJsonObject(stripAnsi(result.stdout)));
-    const generated = normalizeGeneratedSkill(payload);
-    const skillPath = path.join(resolveCodexHomePath(), "skills", generated.skillName);
-    const skillFilePath = path.join(skillPath, "SKILL.md");
-    try {
-        await stat(skillPath);
-        throw new Error("A skill with that name already exists");
-    }
-    catch (error) {
-        if (!(error instanceof Error) || !/ENOENT/i.test(error.message)) {
-            throw error;
-        }
-    }
-    await mkdir(skillPath, { recursive: true });
-    await writeFile(skillFilePath, `${generated.skillMd}\n`, "utf8");
-    return {
-        skillName: generated.skillName,
-        skillPath: `.codex/skills/${generated.skillName}`,
-        skillFilePath: `.codex/skills/${generated.skillName}/SKILL.md`,
-    };
-}
-async function handleSkillRpcMessage(args) {
-    let payload = {};
-    try {
-        payload = JSON.parse(skillRpcCodec.decode(args.msg.data));
-        if (typeof payload.agentId === "string" && payload.agentId.trim() && payload.agentId !== args.agentId) {
-            throw new Error("agent id mismatch");
-        }
-        const prompt = typeof payload.prompt === "string" ? payload.prompt.trim() : "";
-        if (!prompt) {
-            throw new Error("prompt is required");
-        }
-        const result = await generateSkillViaCodex(prompt);
-        args.msg.respond(skillRpcCodec.encode(JSON.stringify({
-            ok: true,
-            skillName: result.skillName,
-            skillPath: result.skillPath,
-            skillFilePath: result.skillFilePath,
-        })));
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "unknown error";
-        args.msg.respond(skillRpcCodec.encode(JSON.stringify({
-            ok: false,
-            error: message,
-        })));
-        writeAgentError(`skill rpc failed error=${message}`);
-    }
-}
-function subscribeToSkillRpc(args) {
-    const subject = buildAgentSkillRpcSubject(args.userId, args.agentId);
-    args.jetstream.nc.subscribe(subject, {
-        callback: (error, msg) => {
-            if (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                writeAgentError(`skill rpc subscription error: ${message}`);
-                return;
-            }
-            void handleSkillRpcMessage({
-                msg,
-                agentId: args.agentId,
-            });
-        },
-    });
-    writeAgentInfo(`skill rpc subscribed subject=${subject}`);
-}
-function parseCodexDeviceAuthOutput(raw) {
-    const text = stripAnsi(raw);
-    const urlMatch = text.match(/https?:\/\/[^\s]+/i);
-    const codeMatch = text.match(/\b[A-Z0-9]{4,}(?:-[A-Z0-9]{4,})+\b/);
-    return {
-        verificationUri: urlMatch?.[0] ?? null,
-        userCode: codeMatch?.[0] ?? null,
-    };
-}
-function pendingCodexDeviceAuthMessage(state) {
-    const parsed = parseCodexDeviceAuthOutput(state.output);
-    if (parsed.verificationUri && parsed.userCode) {
-        return `Waiting for approval. Enter code ${parsed.userCode} at ${parsed.verificationUri}`;
-    }
-    return stripAnsi(state.output).trim() || "Waiting for approval";
-}
-async function getLocalCodexLoginStatus() {
-    const result = await runLocalCodexCli(["login", "status"], 5000);
-    const merged = stripAnsi([result.stdout, result.stderr].filter(Boolean).join("\n")).trim();
-    return {
-        loggedIn: (result.code ?? 1) === 0,
-        output: merged || ((result.code ?? 1) === 0 ? "Logged in" : "Not logged in"),
-    };
-}
-async function waitForCodexDeviceCode(state, timeoutMs) {
-    const startedAt = Date.now();
-    while (Date.now() - startedAt < timeoutMs) {
-        const parsed = parseCodexDeviceAuthOutput(state.output);
-        if (parsed.verificationUri && parsed.userCode) {
-            return;
-        }
-        if (state.child.exitCode !== null) {
-            return;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-}
-function normalizeSettingsRpcRequest(args) {
-    const requestId = typeof args.request.requestId === "string" ? args.request.requestId.trim() : "";
-    const responseSubject = typeof args.request.responseSubject === "string" ? args.request.responseSubject.trim() : "";
-    const requestAgentId = typeof args.request.agentId === "string" ? args.request.agentId.trim() : "";
-    const action = args.request.action === "update" ? "update" : "get";
-    if (!requestId || !responseSubject || !requestAgentId || requestAgentId !== args.agentId) {
-        throw new Error("invalid settings rpc request");
-    }
-    return {
-        requestId,
-        responseSubject,
-        action,
-        patch: normalizeAgentSettingsPatch(args.request.patch),
-        defaults: args.request.defaults && typeof args.request.defaults === "object" && !Array.isArray(args.request.defaults)
-            ? normalizeAgentSettingsConfig(args.request.defaults)
-            : null,
-    };
-}
-function publishSettingsRpcResponse(args) {
-    args.nc.publish(args.responseSubject, settingsRpcCodec.encode(JSON.stringify(args.payload)));
-}
-async function handleSettingsRpcMessage(args) {
-    let requestId = "unknown";
-    let responseSubject = "";
-    try {
-        const payload = JSON.parse(settingsRpcCodec.decode(args.msg.data));
-        const request = normalizeSettingsRpcRequest({ request: payload, agentId: args.agentId });
-        requestId = request.requestId;
-        responseSubject = request.responseSubject;
-        const existing = await readAgentSettingsConfig(request.defaults);
-        const next = request.action === "update" ? normalizeAgentSettingsConfig(request.patch, existing) : existing;
-        if (request.action === "update") {
-            await writeAgentSettingsConfig(next);
-            const customInstructions = typeof request.patch.customInstructions === "string"
-                ? request.patch.customInstructions
-                : request.patch.customInstructions === null
-                    ? null
-                    : undefined;
-            if (customInstructions !== undefined) {
-                await writeAgentModelInstructions(customInstructions);
-            }
-        }
-        else if (request.defaults) {
-            const filePath = resolveAgentSettingsFilePath();
-            const raw = await readFile(filePath, "utf8").catch(() => "");
-            if (!raw.trim()) {
-                await writeAgentSettingsConfig(next);
-            }
-        }
-        publishSettingsRpcResponse({
-            nc: args.jetstream.nc,
-            responseSubject,
-            payload: {
-                requestId,
-                ok: true,
-                settings: await toAgentSettingsPublic(next),
-            },
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (responseSubject) {
-            publishSettingsRpcResponse({
-                nc: args.jetstream.nc,
-                responseSubject,
-                payload: { requestId, ok: false, error: message },
-            });
-        }
-        writeAgentError(`settings rpc failed requestId=${requestId} error=${message}`);
-    }
-}
-function subscribeToSettingsRpc(args) {
-    const subject = buildAgentSettingsRpcSubject(args.userId, args.agentId);
-    args.jetstream.nc.subscribe(subject, {
-        callback: (error, msg) => {
-            if (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                writeAgentError(`settings rpc subscription error: ${message}`);
-                return;
-            }
-            void handleSettingsRpcMessage({
-                msg,
-                jetstream: args.jetstream,
-                agentId: args.agentId,
-            });
-        },
-    });
-    writeAgentInfo(`settings rpc subscribed subject=${subject}`);
-}
-async function startLocalCodexDeviceAuth() {
-    if (pendingCodexDeviceAuth && pendingCodexDeviceAuth.child.exitCode === null) {
-        const parsed = parseCodexDeviceAuthOutput(pendingCodexDeviceAuth.output);
-        return {
-            loggedIn: false,
-            output: pendingCodexDeviceAuthMessage(pendingCodexDeviceAuth),
-            verificationUri: parsed.verificationUri,
-            userCode: parsed.userCode,
-        };
-    }
-    const workspaceRoot = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
-    const child = spawn(buildLocalCodexCliCommand(["login", "--device-auth"]), {
-        cwd: workspaceRoot,
-        shell: resolveShellPath(),
-        detached: process.platform !== "win32",
-        env: {
-            ...process.env,
-            WORKSPACE: workspaceRoot,
-            CODEX_HOME: resolveCodexHomePath(),
-        },
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    child.stdout.setEncoding("utf8");
-    child.stderr.setEncoding("utf8");
-    const state = { child, output: "" };
-    pendingCodexDeviceAuth = state;
-    const appendOutput = (chunk) => {
-        state.output += chunk;
-    };
-    child.stdout.on("data", appendOutput);
-    child.stderr.on("data", appendOutput);
-    child.once("exit", () => {
-        if (pendingCodexDeviceAuth === state) {
-            pendingCodexDeviceAuth = null;
-        }
-    });
-    await waitForCodexDeviceCode(state, 8000);
-    const parsed = parseCodexDeviceAuthOutput(state.output);
-    if ((!parsed.verificationUri || !parsed.userCode) && state.child.exitCode !== null) {
-        throw new Error("Failed to read device code from Codex CLI");
-    }
-    return {
-        loggedIn: false,
-        output: pendingCodexDeviceAuthMessage(state),
-        verificationUri: parsed.verificationUri,
-        userCode: parsed.userCode,
-    };
-}
-async function startLocalCodexLogin() {
-    const workspaceRoot = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
-    const child = spawn(buildLocalCodexCliCommand(["login"]), {
-        cwd: workspaceRoot,
-        shell: resolveShellPath(),
-        detached: process.platform !== "win32",
-        env: {
-            ...process.env,
-            WORKSPACE: workspaceRoot,
-            CODEX_HOME: resolveCodexHomePath(),
-        },
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    let output = "";
-    child.stdout.setEncoding("utf8");
-    child.stderr.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-        output += chunk;
-    });
-    child.stderr.on("data", (chunk) => {
-        output += chunk;
-    });
-    const result = await new Promise((resolve, reject) => {
-        child.once("error", reject);
-        child.once("exit", (code) => resolve({ code, output }));
-    });
-    const normalized = stripAnsi(result.output).trim();
-    const parsed = parseCodexDeviceAuthOutput(result.output);
-    if ((result.code ?? 1) === 0) {
-        const status = await getLocalCodexLoginStatus().catch(() => null);
-        return {
-            loggedIn: status?.loggedIn === true,
-            output: status?.output || normalized || "Login started",
-            verificationUri: parsed.verificationUri,
-            userCode: parsed.userCode,
-        };
-    }
-    throw new Error(normalized || `Codex login failed with code ${result.code ?? "null"}`);
-}
-async function loginLocalCodexWithApiKey(apiKey) {
-    const result = await runLocalCodexCliWithInput(["login", "--with-api-key"], apiKey, 15000);
-    const normalized = stripAnsi([result.stdout, result.stderr].filter(Boolean).join("\n")).trim();
-    if ((result.code ?? 1) !== 0) {
-        throw new Error(normalized || `Codex API key login failed with code ${result.code ?? "null"}`);
-    }
-    const status = await getLocalCodexLoginStatus().catch(() => null);
-    return {
-        loggedIn: status?.loggedIn === true,
-        output: status?.output || normalized || "Logged in",
-        verificationUri: null,
-        userCode: null,
-    };
-}
-async function logoutLocalCodexAuth() {
-    if (pendingCodexDeviceAuth && pendingCodexDeviceAuth.child.exitCode === null) {
-        sendSignalToTaskProcess(pendingCodexDeviceAuth.child, "SIGTERM");
-        setTimeout(() => {
-            if (pendingCodexDeviceAuth?.child.exitCode === null) {
-                sendSignalToTaskProcess(pendingCodexDeviceAuth.child, "SIGKILL");
-            }
-        }, 1000);
-        pendingCodexDeviceAuth = null;
-    }
-    const result = await runLocalCodexCli(["logout"], 5000);
-    let merged = stripAnsi([result.stdout, result.stderr].filter(Boolean).join("\n")).trim();
-    const statusAfterLogout = await getLocalCodexLoginStatus().catch(() => null);
-    if (statusAfterLogout?.loggedIn) {
-        const authFile = path.join(resolveCodexHomePath(), "auth.json");
-        await unlink(authFile).catch(() => undefined);
-        const statusAfterDelete = await getLocalCodexLoginStatus().catch(() => null);
-        if (statusAfterDelete?.output) {
-            merged = [merged, statusAfterDelete.output].filter(Boolean).join("\n");
-        }
-    }
-    return {
-        loggedIn: false,
-        output: merged || "Logged out",
-    };
-}
-function normalizeCodexAuthRpcRequest(args) {
-    const requestId = typeof args.request.requestId === "string" ? args.request.requestId.trim() : "";
-    const responseSubject = typeof args.request.responseSubject === "string" ? args.request.responseSubject.trim() : "";
-    const requestAgentId = typeof args.request.agentId === "string" ? args.request.agentId.trim() : "";
-    const actionRaw = typeof args.request.action === "string" ? args.request.action.trim() : "";
-    const action = actionRaw === "start" || actionRaw === "logout" || actionRaw === "login_api_key" ? actionRaw : "status";
-    const apiKey = typeof args.request.apiKey === "string" && args.request.apiKey.trim() ? args.request.apiKey.trim() : null;
-    if (!requestId || !responseSubject || !requestAgentId || requestAgentId !== args.agentId) {
-        throw new Error("invalid codex auth rpc request");
-    }
-    if (action === "login_api_key" && !apiKey) {
-        throw new Error("api key is required");
-    }
-    return { requestId, responseSubject, action, apiKey };
-}
-function publishCodexAuthRpcResponse(args) {
-    args.nc.publish(args.responseSubject, codexAuthRpcCodec.encode(JSON.stringify(args.payload)));
-}
-async function handleCodexAuthRpcMessage(args) {
-    let requestId = "unknown";
-    let responseSubject = "";
-    try {
-        const payload = JSON.parse(codexAuthRpcCodec.decode(args.msg.data));
-        const request = normalizeCodexAuthRpcRequest({ request: payload, agentId: args.agentId });
-        requestId = request.requestId;
-        responseSubject = request.responseSubject;
-        let result = null;
-        if (request.action === "login_api_key") {
-            result = await loginLocalCodexWithApiKey(request.apiKey ?? "");
-        }
-        else if (request.action === "start") {
-            const status = await getLocalCodexLoginStatus();
-            if (status.loggedIn) {
-                result = { loggedIn: true, output: status.output };
-            }
-            else {
-                try {
-                    result = await startLocalCodexDeviceAuth();
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    const normalized = message.toLowerCase();
-                    if (normalized.includes("operation not permitted") ||
-                        normalized.includes("failed to read device code") ||
-                        normalized.includes("panic") ||
-                        normalized.includes("null object")) {
-                        result = await startLocalCodexLogin();
-                    }
-                    else {
-                        throw error;
-                    }
-                }
-            }
-        }
-        else if (request.action === "logout") {
-            result = await logoutLocalCodexAuth();
-        }
-        else {
-            const status = await getLocalCodexLoginStatus();
-            if (status.loggedIn) {
-                result = { loggedIn: true, output: status.output };
-            }
-            else if (pendingCodexDeviceAuth && pendingCodexDeviceAuth.child.exitCode === null) {
-                const parsed = parseCodexDeviceAuthOutput(pendingCodexDeviceAuth.output);
-                result = {
-                    loggedIn: false,
-                    output: pendingCodexDeviceAuthMessage(pendingCodexDeviceAuth),
-                    verificationUri: parsed.verificationUri,
-                    userCode: parsed.userCode,
-                };
-            }
-            else {
-                result = { loggedIn: false, output: status.output || "Not logged in" };
-            }
-        }
-        publishCodexAuthRpcResponse({
-            nc: args.jetstream.nc,
-            responseSubject,
-            payload: {
-                requestId,
-                ok: true,
-                loggedIn: result.loggedIn,
-                output: result.output,
-                verificationUri: result.verificationUri ?? null,
-                userCode: result.userCode ?? null,
-            },
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (responseSubject) {
-            publishCodexAuthRpcResponse({
-                nc: args.jetstream.nc,
-                responseSubject,
-                payload: { requestId, ok: false, error: message },
-            });
-        }
-        writeAgentError(`codex auth rpc failed requestId=${requestId} error=${message}`);
-    }
-}
-function subscribeToCodexAuthRpc(args) {
-    const subject = buildAgentCodexAuthRpcSubject(args.userId, args.agentId);
-    args.jetstream.nc.subscribe(subject, {
-        callback: (error, msg) => {
-            if (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                writeAgentError(`codex auth rpc subscription error: ${message}`);
-                return;
-            }
-            void handleCodexAuthRpcMessage({
-                msg,
-                jetstream: args.jetstream,
-                agentId: args.agentId,
-            });
-        },
-    });
-    writeAgentInfo(`codex auth rpc subscribed subject=${subject}`);
-}
-function runLocalCommand(command, args, cwd) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(command, args, {
-            cwd,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        let stdout = "";
-        let stderr = "";
-        child.stdout.setEncoding("utf8");
-        child.stderr.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => {
-            stdout += chunk;
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr += chunk;
-        });
-        child.once("error", reject);
-        child.once("close", (code) => {
-            resolve({ code: code ?? 1, stdout, stderr });
-        });
-    });
-}
-function sanitizeGitRef(value) {
-    if (typeof value !== "string" || !value.trim()) {
-        return null;
-    }
-    const trimmed = value.trim();
-    if (trimmed.startsWith("-") || /\s/.test(trimmed) || trimmed.includes("..") || trimmed.includes(":")) {
-        throw new Error(`Invalid git ref: ${trimmed}`);
-    }
-    return trimmed;
-}
-function sanitizeGitPathspec(value) {
-    if (typeof value !== "string") {
-        throw new Error("Invalid pathspec");
-    }
-    const trimmed = value.trim().replace(/\\/g, "/");
-    if (!trimmed || trimmed.startsWith("-") || trimmed.includes("\0")) {
-        throw new Error(`Invalid pathspec: ${trimmed}`);
-    }
-    return trimmed;
-}
-function normalizeGitRpcRequest(args) {
-    const requestId = typeof args.request.requestId === "string" ? args.request.requestId.trim() : "";
-    const responseSubject = typeof args.request.responseSubject === "string" ? args.request.responseSubject.trim() : "";
-    const requestAgentId = typeof args.request.agentId === "string" ? args.request.agentId.trim() : "";
-    const targetPath = typeof args.request.targetPath === "string" ? args.request.targetPath.trim() : "";
-    if (!requestId || !responseSubject || !requestAgentId || requestAgentId !== args.agentId || !targetPath) {
-        throw new Error("invalid git rpc request");
-    }
-    const format = args.request.format === "name-only" ||
-        args.request.format === "name-status" ||
-        args.request.format === "stat" ||
-        args.request.format === "numstat" ||
-        args.request.format === "raw"
-        ? args.request.format
-        : "patch";
-    const ignoreWhitespace = args.request.ignoreWhitespace === "at-eol" ||
-        args.request.ignoreWhitespace === "change" ||
-        args.request.ignoreWhitespace === "all"
-        ? args.request.ignoreWhitespace
-        : "none";
-    const diffAlgorithm = args.request.diffAlgorithm === "minimal" ||
-        args.request.diffAlgorithm === "patience" ||
-        args.request.diffAlgorithm === "histogram"
-        ? args.request.diffAlgorithm
-        : "default";
-    const contextRaw = Number(args.request.contextLines);
-    const contextLines = Number.isFinite(contextRaw) ? Math.max(0, Math.min(200, Math.trunc(contextRaw))) : null;
-    const pathspecs = Array.isArray(args.request.pathspecs) ? args.request.pathspecs.map((item) => sanitizeGitPathspec(item)) : [];
-    return {
-        requestId,
-        responseSubject,
-        targetPath,
-        base: sanitizeGitRef(args.request.base),
-        target: sanitizeGitRef(args.request.target),
-        mergeBase: args.request.mergeBase === true,
-        staged: args.request.staged === true,
-        format,
-        contextLines,
-        ignoreWhitespace,
-        diffAlgorithm,
-        findRenames: args.request.findRenames === true,
-        pathspecs,
-    };
-}
-function buildAgentGitDiffArgs(repoRootAbs, request) {
-    const args = ["-C", repoRootAbs, "diff", "--no-color"];
-    const displayParts = ["git", "diff", "--no-color"];
-    if (request.staged) {
-        args.push("--cached");
-        displayParts.push("--cached");
-    }
-    if (typeof request.contextLines === "number") {
-        args.push(`-U${request.contextLines}`);
-        displayParts.push(`-U${request.contextLines}`);
-    }
-    if (request.ignoreWhitespace === "at-eol") {
-        args.push("--ignore-space-at-eol");
-        displayParts.push("--ignore-space-at-eol");
-    }
-    else if (request.ignoreWhitespace === "change") {
-        args.push("--ignore-space-change");
-        displayParts.push("--ignore-space-change");
-    }
-    else if (request.ignoreWhitespace === "all") {
-        args.push("--ignore-all-space");
-        displayParts.push("--ignore-all-space");
-    }
-    if (request.diffAlgorithm !== "default") {
-        args.push(`--diff-algorithm=${request.diffAlgorithm}`);
-        displayParts.push(`--diff-algorithm=${request.diffAlgorithm}`);
-    }
-    if (request.findRenames) {
-        args.push("--find-renames");
-        displayParts.push("--find-renames");
-    }
-    if (request.format === "name-only") {
-        args.push("--name-only");
-        displayParts.push("--name-only");
-    }
-    else if (request.format === "name-status") {
-        args.push("--name-status");
-        displayParts.push("--name-status");
-    }
-    else if (request.format === "stat") {
-        args.push("--stat");
-        displayParts.push("--stat");
-    }
-    else if (request.format === "numstat") {
-        args.push("--numstat");
-        displayParts.push("--numstat");
-    }
-    else if (request.format === "raw") {
-        args.push("--raw");
-        displayParts.push("--raw");
-    }
-    if (request.mergeBase) {
-        if (!request.base || !request.target) {
-            throw new Error("mergeBase mode requires both base and target");
-        }
-        const merged = `${request.base}...${request.target}`;
-        args.push(merged);
-        displayParts.push(merged);
-    }
-    else {
-        if (request.base) {
-            args.push(request.base);
-            displayParts.push(request.base);
-        }
-        if (request.target) {
-            args.push(request.target);
-            displayParts.push(request.target);
-        }
-    }
-    if (request.pathspecs.length > 0) {
-        args.push("--", ...request.pathspecs);
-        displayParts.push("--", ...request.pathspecs);
-    }
-    return { args, display: displayParts.join(" ") };
-}
-function buildUntrackedText(format, untrackedPaths) {
-    if (untrackedPaths.length === 0) {
-        return "";
-    }
-    if (format === "name-status" || format === "raw") {
-        return `${untrackedPaths.map((item) => `??\t${item}`).join("\n")}\n`;
-    }
-    if (format === "name-only") {
-        return `${untrackedPaths.join("\n")}\n`;
-    }
-    return `\n# Untracked files\n${untrackedPaths.join("\n")}\n`;
-}
-async function appendAgentLocalUntrackedDiff(repoRootAbs, request, baseOutput) {
-    const listArgs = ["-C", repoRootAbs, "ls-files", "--others", "--exclude-standard"];
-    if (request.pathspecs.length > 0) {
-        listArgs.push("--", ...request.pathspecs);
-    }
-    const listResult = await runLocalCommand("git", listArgs, repoRootAbs);
-    if (listResult.code !== 0) {
-        return { output: baseOutput, hasUntracked: false };
-    }
-    const untrackedPaths = listResult.stdout.split(/\r?\n/).map((item) => item.trim()).filter(Boolean);
-    if (untrackedPaths.length === 0) {
-        return { output: baseOutput, hasUntracked: false };
-    }
-    if (request.format !== "patch") {
-        return { output: `${baseOutput}${buildUntrackedText(request.format, untrackedPaths)}`, hasUntracked: true };
-    }
-    let output = baseOutput;
-    for (const relPath of untrackedPaths) {
-        const diffResult = await runLocalCommand("git", ["-C", repoRootAbs, "diff", "--no-color", "--no-index", "--", "/dev/null", relPath], repoRootAbs);
-        if (diffResult.code !== 0 && diffResult.code !== 1) {
-            throw new Error(diffResult.stderr.trim() || `Failed to render agent untracked diff: ${relPath}`);
-        }
-        if (diffResult.stdout) {
-            output += diffResult.stdout;
-            if (!output.endsWith("\n")) {
-                output += "\n";
-            }
-        }
-    }
-    return { output, hasUntracked: true };
-}
-function publishGitRpcResponse(args) {
-    args.nc.publish(args.responseSubject, gitRpcCodec.encode(JSON.stringify(args.payload)));
-}
-async function handleGitRpcMessage(args) {
-    let requestId = "unknown";
-    let responseSubject = "";
-    try {
-        const payload = JSON.parse(gitRpcCodec.decode(args.msg.data));
-        const request = normalizeGitRpcRequest({ request: payload, agentId: args.agentId });
-        requestId = request.requestId;
-        responseSubject = request.responseSubject;
-        if (!request.targetPath.startsWith("/")) {
-            throw new Error("agent source requires an absolute directory path");
-        }
-        const topLevelResult = await runLocalCommand("git", ["-C", request.targetPath, "rev-parse", "--show-toplevel"], request.targetPath);
-        if (topLevelResult.code !== 0) {
-            publishGitRpcResponse({
-                nc: args.jetstream.nc,
-                responseSubject,
-                payload: {
-                    requestId,
-                    ok: true,
-                    payload: {
-                        isGitRepo: false,
-                        mode: "git_diff",
-                        source: "agent",
-                        agent: { id: args.agentId, name: null },
-                        currentPath: request.targetPath,
-                        repoRoot: null,
-                        repoRelativePath: null,
-                        branch: null,
-                        gitDiff: {
-                            command: "git diff --no-color",
-                            format: "patch",
-                            output: "",
-                            outputTruncated: false,
-                        },
-                        message: "현재 경로가 Git 저장소가 아닙니다.",
-                    },
-                },
-            });
-            return;
-        }
-        const repoRootAbs = topLevelResult.stdout.trim();
-        const prefixResult = await runLocalCommand("git", ["-C", request.targetPath, "rev-parse", "--show-prefix"], request.targetPath);
-        const repoRelativePath = prefixResult.code === 0 ? (prefixResult.stdout.trim().replace(/\/$/, "") || ".") : ".";
-        const branchResult = await runLocalCommand("git", ["-C", repoRootAbs, "symbolic-ref", "--quiet", "--short", "HEAD"], repoRootAbs);
-        const detachedResult = branchResult.code === 0 ? null : await runLocalCommand("git", ["-C", repoRootAbs, "rev-parse", "--short", "HEAD"], repoRootAbs);
-        const branch = branchResult.code === 0 ? branchResult.stdout.trim() || null : detachedResult && detachedResult.code === 0 ? detachedResult.stdout.trim() || null : null;
-        const gitDiffArgs = buildAgentGitDiffArgs(repoRootAbs, request);
-        const gitDiffResult = await runLocalCommand("git", gitDiffArgs.args, repoRootAbs);
-        if (gitDiffResult.code !== 0) {
-            throw new Error(gitDiffResult.stderr.trim() || "Failed to run agent git diff");
-        }
-        const withUntracked = await appendAgentLocalUntrackedDiff(repoRootAbs, request, gitDiffResult.stdout);
-        publishGitRpcResponse({
-            nc: args.jetstream.nc,
-            responseSubject,
-            payload: {
-                requestId,
-                ok: true,
-                payload: {
-                    isGitRepo: true,
-                    mode: "git_diff",
-                    source: "agent",
-                    agent: { id: args.agentId, name: null },
-                    currentPath: request.targetPath,
-                    repoRoot: repoRootAbs,
-                    repoRelativePath,
-                    branch,
-                    gitDiff: {
-                        command: withUntracked.hasUntracked ? `${gitDiffArgs.display} (+ untracked)` : gitDiffArgs.display,
-                        format: request.format,
-                        output: withUntracked.output,
-                        outputTruncated: false,
-                    },
-                },
-            },
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (responseSubject) {
-            publishGitRpcResponse({
-                nc: args.jetstream.nc,
-                responseSubject,
-                payload: { requestId, ok: false, error: message },
-            });
-        }
-        writeAgentError(`git rpc failed requestId=${requestId} error=${message}`);
-    }
-}
-function subscribeToGitRpc(args) {
-    const subject = buildAgentGitRpcSubject(args.userId, args.agentId);
-    args.jetstream.nc.subscribe(subject, {
-        callback: (error, msg) => {
-            if (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                writeAgentError(`git rpc subscription error: ${message}`);
-                return;
-            }
-            void handleGitRpcMessage({
-                msg,
-                jetstream: args.jetstream,
-                userId: args.userId,
-                agentId: args.agentId,
-            });
-        },
-    });
-    writeAgentInfo(`git rpc subscribed subject=${subject}`);
-}
-async function handleRunRpcMessage(args) {
-    let requestId = "unknown";
-    let responseSubject = "";
-    try {
-        const payload = JSON.parse(runRpcCodec.decode(args.msg.data));
-        const request = normalizeRunRpcRequest({ request: payload, agentId: args.agentId });
-        requestId = request.requestId;
-        responseSubject = request.responseSubject;
-        if (request.action === "start") {
-            const runId = request.runId ?? requestId;
-            await claimRunStartSlot({ runId, sessionId: request.sessionId });
-            try {
-                const localAgentSettings = await readAgentSettingsConfig(null);
-                const customInstructions = await readAgentModelInstructions();
-                const task = await startManagedRun({
-                    requestId,
-                    runId,
-                    serverBaseUrl: args.serverBaseUrl,
-                    userId: args.userId,
-                    agentId: args.agentId,
-                    nc: args.jetstream.nc,
-                    sessionId: request.sessionId,
-                    codexArgs: buildManagedCodexArgs({
-                        prompt: request.prompt ?? "",
-                        imagePaths: request.imagePaths,
-                        sessionId: request.sessionId,
-                        model: request.model,
-                        personality: localAgentSettings.general.personality,
-                        modelInstructionsFile: customInstructions ? resolveAgentModelInstructionsFilePath() : null,
-                    }),
-                    cwd: request.cwd,
-                    runtimeEnvPatch: request.runtimeEnvPatch,
-                    codexAuthBundle: request.codexAuthBundle,
-                    agentToken: args.agentToken,
-                });
-                publishRunRpcResponse({ nc: args.jetstream.nc, responseSubject, payload: { requestId, ok: true, task } });
-            }
-            catch (error) {
-                await releaseRunStartSlot({ runId, sessionId: request.sessionId }).catch(() => undefined);
-                throw error;
-            }
-            return;
-        }
-        if (request.action === "list") {
-            const merged = (await listPersistedRunTasks())
-                .map((task) => cloneRunTask(task))
-                .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))
-                .slice(0, request.limit);
-            publishRunRpcResponse({ nc: args.jetstream.nc, responseSubject, payload: { requestId, ok: true, tasks: merged } });
-            return;
-        }
-        const stored = request.runId ? await getStoredRun(request.runId) : null;
-        if (!stored || stored.agentId !== args.agentId || stored.userId !== args.userId) {
-            throw new Error("Run not found");
-        }
-        if (request.action === "cancel") {
-            const target = stored;
-            if (target.processPid === null) {
-                throw new Error("Run pid not found");
-            }
-            target.cancelRequested = true;
-            target.updatedAt = formatLocalTimestamp();
-            await persistRunTask(target);
-            publishImmediateRunEvent({ nc: args.jetstream.nc, userId: target.userId, task: target });
-            writeRunStatus(target.id, `cancel requested pid=${target.processPid}`);
-            sendSignalToPid(target.processPid, "SIGINT");
-            const task = cloneRunTask(target);
-            publishRunRpcResponse({ nc: args.jetstream.nc, responseSubject, payload: { requestId, ok: true, task } });
-            return;
-        }
-        const task = cloneRunTask(stored, request.sinceSeq);
-        publishRunRpcResponse({ nc: args.jetstream.nc, responseSubject, payload: { requestId, ok: true, task } });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (responseSubject) {
-            publishRunRpcResponse({
-                nc: args.jetstream.nc,
-                responseSubject,
-                payload: { requestId, ok: false, error: message },
-            });
-        }
-        writeAgentError(`run rpc failed requestId=${requestId} error=${message}`);
-    }
-}
-function subscribeToRunRpc(args) {
-    const subject = buildAgentRunRpcSubject(args.userId, args.agentId);
-    args.jetstream.nc.subscribe(subject, {
-        callback: (error, msg) => {
-            if (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                writeAgentError(`run rpc subscription error: ${message}`);
-                return;
-            }
-            void handleRunRpcMessage({
-                msg,
-                jetstream: args.jetstream,
-                serverBaseUrl: args.serverBaseUrl,
-                userId: args.userId,
-                agentId: args.agentId,
-                agentToken: args.agentToken,
-            });
-        },
-    });
-    writeAgentInfo(`run rpc subscribed subject=${subject}`);
-}
-function isLikelyNatsAuthError(error) {
-    const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
-    return (message.includes("auth")
-        || message.includes("authorization")
-        || message.includes("authentication")
-        || message.includes("permission")
-        || message.includes("jwt")
-        || message.includes("token"));
-}
-function isLikelyNatsReconnectError(error) {
-    const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
-    return (message.includes("connection_closed")
-        || message.includes("connection closed")
-        || message.includes("closed connection")
-        || message.includes("disconnected")
-        || message.includes("timeout")
-        || message.includes("no responders"));
-}
-function sendSignalToTaskProcess(child, signal) {
-    if (process.platform !== "win32" && typeof child.pid === "number") {
-        try {
-            // Detached child owns a process group; signal the whole group first.
-            process.kill(-child.pid, signal);
-            return;
-        }
-        catch {
-            // Fall back to direct child signaling.
-        }
-    }
-    try {
-        child.kill(signal);
-    }
-    catch {
-        // noop
-    }
-}
-function sendSignalToPid(pid, signal) {
-    if (process.platform !== "win32") {
-        try {
-            process.kill(-pid, signal);
-            return;
-        }
-        catch {
-            // Fall back to direct pid signaling.
-        }
-    }
-    process.kill(pid, signal);
-}
-function resolveLogTimeZone() {
-    const configured = process.env.DOER_AGENT_LOG_TIMEZONE?.trim() || process.env.TZ?.trim();
-    return configured && configured.length > 0 ? configured : "Asia/Seoul";
-}
-function resolveTimeZoneOffsetString(date, timeZone) {
-    try {
-        const parts = new Intl.DateTimeFormat("en-US", {
-            timeZone,
-            timeZoneName: "shortOffset",
-            hour: "2-digit",
-            minute: "2-digit",
-            hour12: false,
-        }).formatToParts(date);
-        const token = parts.find((part) => part.type === "timeZoneName")?.value || "GMT+0";
-        const matched = token.match(/GMT([+-]\d{1,2})(?::?(\d{2}))?/i);
-        if (!matched) {
-            return "+00:00";
-        }
-        const hourRaw = matched[1] || "+0";
-        const minuteRaw = matched[2] || "00";
-        const sign = hourRaw.startsWith("-") ? "-" : "+";
-        const absHour = String(Math.abs(Number.parseInt(hourRaw, 10))).padStart(2, "0");
-        const absMinute = String(Math.abs(Number.parseInt(minuteRaw, 10))).padStart(2, "0");
-        return `${sign}${absHour}:${absMinute}`;
-    }
-    catch {
-        return "+00:00";
-    }
-}
-function formatLocalTimestamp(date = new Date()) {
-    const timeZone = resolveLogTimeZone();
-    try {
-        const parts = new Intl.DateTimeFormat("en-CA", {
-            timeZone,
-            year: "numeric",
-            month: "2-digit",
-            day: "2-digit",
-            hour: "2-digit",
-            minute: "2-digit",
-            second: "2-digit",
-            hour12: false,
-        }).formatToParts(date);
-        const pick = (type) => {
-            return parts.find((part) => part.type === type)?.value || "00";
-        };
-        const year = pick("year");
-        const month = pick("month");
-        const day = pick("day");
-        const hours = pick("hour");
-        const minutes = pick("minute");
-        const seconds = pick("second");
-        const ms = String(date.getMilliseconds()).padStart(3, "0");
-        const offset = resolveTimeZoneOffsetString(date, timeZone);
-        return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${ms}${offset}`;
-    }
-    catch {
-        return date.toISOString();
-    }
-}
-function parseArgs(argv) {
-    const out = {};
-    for (let i = 0; i < argv.length; i += 1) {
-        const key = argv[i];
-        if (!key.startsWith("--")) {
-            continue;
-        }
-        const value = argv[i + 1];
-        if (typeof value === "string" && !value.startsWith("--")) {
-            out[key.slice(2)] = value;
-            i += 1;
-            continue;
-        }
-        out[key.slice(2)] = "true";
-    }
-    return out;
-}
-function resolveArgOrEnv(args, argKeys, envKeys, fallback = "") {
-    for (const key of argKeys) {
-        const value = args[key]?.trim();
-        if (value) {
-            return value;
-        }
-    }
-    for (const key of envKeys) {
-        const value = process.env[key]?.trim();
-        if (value) {
-            return value;
-        }
-    }
-    return fallback;
-}
-function resolveShellPath() {
-    if (process.platform === "win32") {
-        return process.env.ComSpec || "cmd.exe";
-    }
-    const candidates = [process.env.SHELL, "/bin/bash", "/usr/bin/bash", "/bin/sh", "/usr/bin/sh"].filter((value) => typeof value === "string" && value.trim().length > 0);
-    for (const candidate of candidates) {
-        if (existsSync(candidate)) {
-            return candidate;
-        }
-    }
-    throw new Error("No shell executable found. Set SHELL env or install /bin/sh (or bash).");
-}
-function resolveTaskWorkspace(rawCwd) {
-    const workspaceRoot = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
-    const requestedCwd = rawCwd?.trim() || "";
-    const resolvedCwd = requestedCwd
-        ? path.isAbsolute(requestedCwd)
-            ? path.resolve(requestedCwd)
-            : path.resolve(workspaceRoot, requestedCwd)
-        : workspaceRoot;
-    if (!existsSync(resolvedCwd)) {
-        throw new Error(`Invalid cwd: ${requestedCwd || "(empty)"} resolved to ${resolvedCwd} (path does not exist)`);
-    }
-    let stats;
-    try {
-        stats = statSync(resolvedCwd);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Invalid cwd: ${requestedCwd || "(empty)"} resolved to ${resolvedCwd} (${message})`);
-    }
-    if (!stats.isDirectory()) {
-        throw new Error(`Invalid cwd: ${requestedCwd || "(empty)"} resolved to ${resolvedCwd} (not a directory)`);
-    }
-    return resolvedCwd;
-}
-function buildAgentFsRpcSubject(userId, agentId) {
-    return `doer.agent.fs.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
-}
-function normalizeFsRpcPath(rawPath) {
-    const root = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
-    const raw = typeof rawPath === "string" && rawPath.trim() ? rawPath.trim() : ".";
-    const normalizedRaw = raw.replace(/\\/g, "/");
-    const useAbsolute = path.isAbsolute(normalizedRaw);
-    const rel = normalizedRaw.replace(/^\/+/, "") || ".";
-    const abs = useAbsolute ? path.resolve(normalizedRaw) : path.resolve(root, rel);
-    if (!useAbsolute && abs !== root && !abs.startsWith(root + path.sep)) {
-        throw new Error("path escapes workspace root");
-    }
-    const formatPath = (target) => {
-        if (useAbsolute) {
-            return target.split(path.sep).join("/") || "/";
-        }
-        return path.relative(root, target).split(path.sep).join("/") || ".";
-    };
-    return { abs, formatPath };
-}
-function parseFsRpcAction(value) {
-    if (value === "list" ||
-        value === "stat" ||
-        value === "fetch_file" ||
-        value === "read_text" ||
-        value === "read_file" ||
-        value === "write_file" ||
-        value === "download_file" ||
-        value === "delete_path" ||
-        value === "archive_dir" ||
-        value === "extract_archive") {
-        return value;
-    }
-    throw new Error("unsupported action");
-}
-function normalizeFsRpcNumber(value, fallback) {
-    const n = Number(value);
-    if (!Number.isFinite(n)) {
-        return fallback;
-    }
-    return Math.floor(n);
-}
-function inferMimeType(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
-    if (ext === ".txt" || ext === ".md" || ext === ".log") {
-        return "text/plain";
-    }
-    if (ext === ".json") {
-        return "application/json";
-    }
-    if (ext === ".js" || ext === ".mjs" || ext === ".cjs") {
-        return "text/javascript";
-    }
-    if (ext === ".ts" || ext === ".tsx") {
-        return "text/typescript";
-    }
-    if (ext === ".jsx") {
-        return "text/jsx";
-    }
-    if (ext === ".css") {
-        return "text/css";
-    }
-    if (ext === ".html" || ext === ".htm") {
-        return "text/html";
-    }
-    if (ext === ".xml") {
-        return "application/xml";
-    }
-    if (ext === ".svg") {
-        return "image/svg+xml";
-    }
-    if (ext === ".png") {
-        return "image/png";
-    }
-    if (ext === ".jpg" || ext === ".jpeg") {
-        return "image/jpeg";
-    }
-    if (ext === ".gif") {
-        return "image/gif";
-    }
-    if (ext === ".webp") {
-        return "image/webp";
-    }
-    if (ext === ".pdf") {
-        return "application/pdf";
-    }
-    return "application/octet-stream";
-}
-function normalizeArchiveRelativePath(value) {
-    const normalized = value.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
-    if (!normalized || normalized.includes("..")) {
-        throw new Error("invalid archive entry path");
-    }
-    return normalized;
-}
-async function collectDirectoryFiles(absDir, rootDir = absDir) {
-    const rows = await readdir(absDir, { withFileTypes: true });
-    const files = [];
-    for (const row of rows.sort((a, b) => a.name.localeCompare(b.name))) {
-        const child = path.join(absDir, row.name);
-        if (row.isDirectory()) {
-            files.push(...await collectDirectoryFiles(child, rootDir));
-            continue;
-        }
-        if (!row.isFile()) {
-            continue;
-        }
-        const bytes = await readFile(child);
-        files.push({
-            relPath: normalizeArchiveRelativePath(path.relative(rootDir, child)),
-            contentBase64: Buffer.from(bytes).toString("base64"),
-            sizeBytes: bytes.byteLength,
-        });
-    }
-    return files;
-}
-async function executeFsRpc(args) {
-    const action = parseFsRpcAction(args.request.action);
-    const { abs, formatPath } = normalizeFsRpcPath(args.request.path);
-    if (action === "stat") {
-        const entry = await stat(abs);
-        return {
-            ok: true,
-            action,
-            path: formatPath(abs),
-            kind: entry.isDirectory() ? "dir" : "file",
-            size: entry.size,
-            mtimeMs: entry.mtimeMs,
-        };
-    }
-    if (action === "list") {
-        const entry = await stat(abs);
-        if (!entry.isDirectory()) {
-            throw new Error("path is not a directory");
-        }
-        const limit = Math.max(1, Math.min(normalizeFsRpcNumber(args.request.limit, 200), 1000));
-        const rows = await readdir(abs, { withFileTypes: true });
-        const items = await Promise.all(rows.map(async (row) => {
-            const child = path.join(abs, row.name);
-            const childStat = await stat(child);
-            return {
-                name: row.name,
-                path: formatPath(child),
-                kind: row.isDirectory() ? "dir" : "file",
-                size: childStat.size,
-                mtimeMs: childStat.mtimeMs,
-            };
-        }));
-        items.sort((a, b) => (a.kind === b.kind ? a.name.localeCompare(b.name) : a.kind === "dir" ? -1 : 1));
-        return {
-            ok: true,
-            action,
-            path: formatPath(abs),
-            items: items.slice(0, limit),
-            truncated: items.length > limit,
-            total: items.length,
-        };
-    }
-    if (action === "archive_dir") {
-        const entry = await stat(abs);
-        if (!entry.isDirectory()) {
-            throw new Error("path is not a directory");
-        }
-        const rawArchivePath = typeof args.request.archivePath === "string" ? args.request.archivePath : "";
-        if (!rawArchivePath) {
-            throw new Error("archivePath is required");
-        }
-        const archiveTarget = normalizeFsRpcPath(rawArchivePath);
-        const files = await collectDirectoryFiles(abs);
-        if (!files.some((file) => file.relPath === "SKILL.md")) {
-            throw new Error("Selected skill directory must contain SKILL.md");
-        }
-        const payload = gzipSync(Buffer.from(JSON.stringify({
-            files,
-        }), "utf8"));
-        await mkdir(path.dirname(archiveTarget.abs), { recursive: true });
-        await writeFile(archiveTarget.abs, payload);
-        const archiveStat = await stat(archiveTarget.abs);
-        return {
-            ok: true,
-            action,
-            path: formatPath(abs),
-            archivePath: archiveTarget.formatPath(archiveTarget.abs),
-            size: archiveStat.size,
-        };
-    }
-    if (action === "fetch_file") {
-        const entry = await stat(abs);
-        if (!entry.isFile()) {
-            throw new Error("path is not a file");
-        }
-        const uploadUrl = typeof args.request.uploadUrl === "string" ? args.request.uploadUrl : "";
-        const agentId = typeof args.request.agentId === "string" ? args.request.agentId : "";
-        if (!uploadUrl || !agentId) {
-            throw new Error("missing upload parameters");
-        }
-        const resolvedUploadUrl = new URL(uploadUrl, `${args.serverBaseUrl}/`).toString();
-        const data = await readFile(abs);
-        const fileName = path.basename(abs) || "file";
-        const form = new FormData();
-        form.append("file", new File([data], fileName));
-        form.append("agentId", agentId);
-        const response = await fetch(resolvedUploadUrl, {
-            method: "POST",
-            headers: { Authorization: `Bearer ${args.agentToken}` },
-            body: form,
-        });
-        const text = await response.text();
-        let upload = {};
-        try {
-            upload = JSON.parse(text || "{}");
-        }
-        catch {
-            upload = {};
-        }
-        if (!response.ok) {
-            const message = typeof upload.error === "string" ? upload.error : `upload failed: ${response.status}`;
-            throw new Error(message);
-        }
-        return {
-            ok: true,
-            action,
-            path: formatPath(abs),
-            size: entry.size,
-            upload,
-        };
-    }
-    if (action === "write_file") {
-        const contentBase64 = typeof args.request.contentBase64 === "string" ? args.request.contentBase64 : "";
-        if (!contentBase64) {
-            throw new Error("contentBase64 is required");
-        }
-        const parentDir = path.dirname(abs);
-        await mkdir(parentDir, { recursive: true });
-        const bytes = Buffer.from(contentBase64, "base64");
-        await writeFile(abs, bytes);
-        const entry = await stat(abs);
-        return {
-            ok: true,
-            action,
-            path: formatPath(abs),
-            absolutePath: abs.split(path.sep).join("/"),
-            size: entry.size,
-            mimeType: inferMimeType(abs),
-            mtimeMs: entry.mtimeMs,
-        };
-    }
-    if (action === "delete_path") {
-        await rm(abs, { recursive: true, force: true });
-        return {
-            ok: true,
-            action,
-            path: formatPath(abs),
-            absolutePath: abs.split(path.sep).join("/"),
-        };
-    }
-    if (action === "download_file") {
-        const downloadPath = typeof args.request.downloadPath === "string" ? args.request.downloadPath.trim() : "";
-        if (!downloadPath) {
-            throw new Error("downloadPath is required");
-        }
-        const downloadUrl = new URL(downloadPath, `${args.serverBaseUrl}/`).toString();
-        const response = await fetch(downloadUrl, {
-            method: "GET",
-            headers: {
-                Authorization: `Bearer ${args.agentToken}`,
-            },
-        });
-        if (!response.ok) {
-            const text = await response.text().catch(() => "");
-            throw new Error(text || `download failed: ${response.status}`);
-        }
-        const bytes = Buffer.from(await response.arrayBuffer());
-        const parentDir = path.dirname(abs);
-        await mkdir(parentDir, { recursive: true });
-        await writeFile(abs, bytes);
-        const entry = await stat(abs);
-        return {
-            ok: true,
-            action,
-            path: formatPath(abs),
-            absolutePath: abs.split(path.sep).join("/"),
-            size: entry.size,
-            mimeType: inferMimeType(abs),
-            mtimeMs: entry.mtimeMs,
-        };
-    }
-    if (action === "extract_archive") {
-        const archiveEntry = await stat(abs);
-        if (!archiveEntry.isFile()) {
-            throw new Error("path is not a file");
-        }
-        const rawDestinationPath = typeof args.request.destinationPath === "string" ? args.request.destinationPath : "";
-        if (!rawDestinationPath) {
-            throw new Error("destinationPath is required");
-        }
-        const destinationTarget = normalizeFsRpcPath(rawDestinationPath);
-        const archiveBytes = await readFile(abs);
-        const decoded = JSON.parse(gunzipSync(archiveBytes).toString("utf8"));
-        const files = Array.isArray(decoded.files) ? decoded.files : [];
-        await mkdir(destinationTarget.abs, { recursive: true });
-        for (const file of files) {
-            const relPath = typeof file.relPath === "string" ? normalizeArchiveRelativePath(file.relPath) : "";
-            const contentBase64 = typeof file.contentBase64 === "string" ? file.contentBase64 : "";
-            if (!relPath || !contentBase64) {
-                throw new Error("archive contains an invalid file entry");
-            }
-            const targetPath = path.join(destinationTarget.abs, relPath);
-            await mkdir(path.dirname(targetPath), { recursive: true });
-            await writeFile(targetPath, Buffer.from(contentBase64, "base64"));
-        }
-        return {
-            ok: true,
-            action,
-            path: formatPath(abs),
-            absolutePath: destinationTarget.formatPath(destinationTarget.abs),
-        };
-    }
-    const entry = await stat(abs);
-    if (!entry.isFile()) {
-        throw new Error("path is not a file");
-    }
-    if (action === "read_file") {
-        const maxBytes = Math.max(1, Math.min(normalizeFsRpcNumber(args.request.maxBytes, 2_000_000), 5_000_000));
-        const data = await readFile(abs);
-        const truncated = data.byteLength > maxBytes;
-        const bytes = truncated ? data.subarray(0, maxBytes) : data;
-        return {
-            ok: true,
-            action,
-            path: formatPath(abs),
-            mimeType: inferMimeType(abs),
-            size: entry.size,
-            truncated,
-            contentBase64: bytes.toString("base64"),
-        };
-    }
-    const offset = Math.max(0, normalizeFsRpcNumber(args.request.offset, 0));
-    const length = Math.max(1, Math.min(normalizeFsRpcNumber(args.request.length, 65536), 262144));
-    const encoding = typeof args.request.encoding === "string" && args.request.encoding ? args.request.encoding : "utf8";
-    const fd = await open(abs, "r");
-    try {
-        const buffer = Buffer.alloc(length);
-        const readResult = await fd.read(buffer, 0, length, offset);
-        const slice = buffer.subarray(0, readResult.bytesRead);
-        try {
-            const text = slice.toString(encoding);
-            return {
-                ok: true,
-                action,
-                path: formatPath(abs),
-                offset,
-                length: readResult.bytesRead,
-                totalSize: entry.size,
-                eof: offset + readResult.bytesRead >= entry.size,
-                encoding,
-                text,
-                bytesRead: readResult.bytesRead,
-            };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : "failed to decode text";
-            return {
-                ok: false,
-                action,
-                path: formatPath(abs),
-                error: message,
-            };
-        }
-    }
-    finally {
-        await fd.close();
-    }
-}
-function normalizeSessionRpcRequest(args) {
-    const requestId = typeof args.request.requestId === "string" ? args.request.requestId.trim() : "";
-    if (!requestId) {
-        throw new Error("missing requestId");
-    }
-    const requestAgentId = typeof args.request.agentId === "string" ? args.request.agentId.trim() : "";
-    if (!requestAgentId || requestAgentId !== args.agentId) {
-        throw new Error("agent id mismatch");
-    }
-    const actionRaw = typeof args.request.action === "string" ? args.request.action.trim() : "";
-    const action = actionRaw === "messages" || actionRaw === "delete" || actionRaw === "watch" || actionRaw === "stop_watch"
-        ? actionRaw
-        : "list";
-    const responseSubject = typeof args.request.responseSubject === "string" ? args.request.responseSubject.trim() : "";
-    if (!responseSubject) {
-        throw new Error("missing responseSubject");
-    }
-    const filePath = typeof args.request.filePath === "string" && args.request.filePath.trim() ? args.request.filePath.trim() : null;
-    if ((action === "messages" || action === "delete" || action === "watch") && !filePath) {
-        throw new Error("missing filePath");
-    }
-    const sinceLineRaw = Number(args.request.sinceLine);
-    const sinceLine = Number.isInteger(sinceLineRaw) && sinceLineRaw > 0 ? sinceLineRaw : 0;
-    const beforeRowIdRaw = Number(args.request.beforeRowId);
-    const beforeRowId = Number.isInteger(beforeRowIdRaw) && beforeRowIdRaw > 0 ? beforeRowIdRaw : null;
-    const pageSizeRaw = Number(args.request.pageSize);
-    const pageSize = Number.isFinite(pageSizeRaw) ? Math.max(1, Math.min(Math.floor(pageSizeRaw), 100)) : 100;
-    const watchId = typeof args.request.watchId === "string" && args.request.watchId.trim() ? args.request.watchId.trim() : null;
-    if (action === "stop_watch" && !watchId) {
-        throw new Error("missing watchId");
-    }
-    return {
-        requestId,
-        action,
-        agentId: requestAgentId,
-        filePath,
-        sessionId: typeof args.request.sessionId === "string" && args.request.sessionId.trim() ? args.request.sessionId.trim() : null,
-        sinceLine,
-        beforeRowId,
-        pageSize,
-        responseSubject,
-        watchId,
-    };
-}
-function getSessionsRootPath() {
-    const workspaceRoot = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
-    return path.join(workspaceRoot, ".codex", "sessions");
-}
-function resolveSessionFilePath(filePath) {
-    const root = path.resolve(getSessionsRootPath());
-    const resolved = path.resolve(filePath);
-    if (!(resolved === root || resolved.startsWith(root + path.sep))) {
-        throw new Error("filePath is outside sessions root");
-    }
-    return resolved;
-}
-function isObjectRecord(value) {
-    return !!value && typeof value === "object" && !Array.isArray(value);
-}
-const SESSION_RPC_BLOB_KEYS = new Set([
-    "image_url",
-    "image_base64",
-    "content_base64",
-    "file_data",
-    "bytes",
-    "data",
-]);
-function isInlineBlobString(value) {
-    const trimmed = value.trim();
-    if (!trimmed) {
-        return false;
-    }
-    return trimmed.startsWith("data:") || trimmed.includes(";base64,");
-}
-function buildInlineBlobMarker(value) {
-    const trimmed = value.trim();
-    if (trimmed.startsWith("data:")) {
-        const mimeEnd = trimmed.indexOf(";");
-        const mimeType = mimeEnd > 5 ? trimmed.slice(5, mimeEnd) : "";
-        if (mimeType) {
-            return `[inline blob omitted: ${mimeType}]`;
-        }
-    }
-    return "[inline blob omitted]";
-}
-function sanitizeSessionRpcPayload(value) {
-    if (typeof value === "string") {
-        return value;
-    }
-    if (Array.isArray(value)) {
-        return value.map((entry) => sanitizeSessionRpcPayload(entry));
-    }
-    if (!isObjectRecord(value)) {
-        return value;
-    }
-    const sanitized = {};
-    for (const [key, entry] of Object.entries(value)) {
-        if (SESSION_RPC_BLOB_KEYS.has(key) && typeof entry === "string" && isInlineBlobString(entry)) {
-            sanitized[key] = buildInlineBlobMarker(entry);
-            continue;
-        }
-        sanitized[key] = sanitizeSessionRpcPayload(entry);
-    }
-    return sanitized;
-}
-function sanitizeSessionRpcRawLine(line) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith("{")) {
-        return line;
-    }
-    try {
-        const parsed = JSON.parse(line);
-        if (!isObjectRecord(parsed)) {
-            return line;
-        }
-        if (parsed.type === "compacted" || parsed.type === "turn_context" || parsed.type === "session_meta") {
-            return null;
-        }
-        if (!isObjectRecord(parsed.payload) || parsed.type !== "response_item") {
-            return line;
-        }
-        const payloadType = typeof parsed.payload.type === "string" ? parsed.payload.type : "";
-        if (payloadType === "message" || payloadType === "reasoning") {
-            return null;
-        }
-        return JSON.stringify({
-            ...parsed,
-            payload: sanitizeSessionRpcPayload(parsed.payload),
-        });
-    }
-    catch {
-        return line;
-    }
-}
-function toTrimmedStringOrNull(value) {
-    if (typeof value !== "string") {
-        return null;
-    }
-    const trimmed = value.trim();
-    return trimmed || null;
-}
-function pickSessionString(...values) {
-    for (const value of values) {
-        const picked = toTrimmedStringOrNull(value);
-        if (picked) {
-            return picked;
-        }
-    }
-    return null;
-}
-async function collectSessionJsonlFiles(rootDir) {
-    const out = [];
-    const stack = [rootDir];
-    while (stack.length > 0) {
-        const current = stack.pop();
-        if (!current) {
-            continue;
-        }
-        let entries = [];
-        try {
-            entries = await readdir(current, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries) {
-            const fullPath = path.join(current, entry.name);
-            if (entry.isDirectory()) {
-                stack.push(fullPath);
-                continue;
-            }
-            if (!entry.isFile() || !entry.name.toLowerCase().endsWith(".jsonl")) {
-                continue;
-            }
-            try {
-                const entryStat = await stat(fullPath);
-                out.push({ filePath: fullPath, mtimeMs: entryStat.mtimeMs });
-            }
-            catch {
-                // ignore removed files
-            }
-        }
-    }
-    return out;
-}
-async function readFirstLine(fileHandle, fileSize) {
-    const chunkBytes = 16_384;
-    const maxScanBytes = 262_144;
-    let position = 0;
-    let scanned = 0;
-    let raw = "";
-    while (position < fileSize && scanned < maxScanBytes) {
-        const readSize = Math.min(chunkBytes, fileSize - position, maxScanBytes - scanned);
-        const buffer = Buffer.alloc(readSize);
-        const { bytesRead } = await fileHandle.read(buffer, 0, readSize, position);
-        if (bytesRead <= 0) {
-            break;
-        }
-        raw += buffer.toString("utf8", 0, bytesRead);
-        scanned += bytesRead;
-        position += bytesRead;
-        const newlineIndex = raw.search(/\r?\n/);
-        if (newlineIndex >= 0) {
-            return raw.slice(0, newlineIndex).trim();
-        }
-    }
-    return raw.trim();
-}
-function extractLastAgentMessage(candidateLines) {
-    let fallback = null;
-    for (const line of candidateLines) {
-        const trimmed = line.trim();
-        if (!trimmed) {
-            continue;
-        }
-        try {
-            const parsed = JSON.parse(trimmed);
-            if (parsed.type !== "event_msg" || !isObjectRecord(parsed.payload)) {
-                continue;
-            }
-            if (parsed.payload.type === "agent_message" && typeof parsed.payload.message === "string" && parsed.payload.message.trim()) {
-                return {
-                    message: parsed.payload.message.trim(),
-                    updatedAt: toTrimmedStringOrNull(parsed.timestamp),
-                };
-            }
-            if (!fallback &&
-                parsed.payload.type === "task_complete" &&
-                typeof parsed.payload.last_agent_message === "string" &&
-                parsed.payload.last_agent_message.trim()) {
-                fallback = {
-                    message: parsed.payload.last_agent_message.trim(),
-                    updatedAt: toTrimmedStringOrNull(parsed.timestamp),
-                };
-            }
-        }
-        catch {
-            // ignore malformed lines
-        }
-    }
-    return fallback;
-}
-async function readLastAgentMessage(fileHandle, fileSize) {
-    const chunkBytes = 16_384;
-    const maxScanBytes = 131_072;
-    if (fileSize <= 0) {
-        return null;
-    }
-    let position = fileSize;
-    let scanned = 0;
-    let carry = "";
-    while (position > 0 && scanned < maxScanBytes) {
-        const readSize = Math.min(chunkBytes, position, maxScanBytes - scanned);
-        position -= readSize;
-        scanned += readSize;
-        const buffer = Buffer.alloc(readSize);
-        const { bytesRead } = await fileHandle.read(buffer, 0, readSize, position);
-        if (bytesRead <= 0) {
-            break;
-        }
-        const merged = buffer.toString("utf8", 0, bytesRead) + carry;
-        const lines = merged.split(/\r?\n/);
-        carry = lines.shift() || "";
-        const found = extractLastAgentMessage(lines.reverse());
-        if (found) {
-            return found;
-        }
-    }
-    return extractLastAgentMessage([carry]);
-}
-function normalizeSessionMeta(rawMeta, filePath, mtimeMs) {
-    const baseName = path.basename(filePath, path.extname(filePath));
-    const meta = isObjectRecord(rawMeta) ? rawMeta : {};
-    const updatedAtCandidate = pickSessionString(meta.updatedAt, meta.updated_at, meta.timestamp);
-    return {
-        id: pickSessionString(meta.sessionId, meta.session_id, meta.id) || baseName,
-        label: pickSessionString(meta.label, meta.title, meta.name, meta.sessionLabel, meta.session_label) || baseName,
-        updatedAt: updatedAtCandidate || new Date(mtimeMs).toISOString(),
-        cwd: pickSessionString(meta.cwd, meta.workingDirectory, meta.working_directory),
-        source: pickSessionString(meta.source, meta.sessionSource, meta.session_source) || "codex",
-        originator: pickSessionString(meta.originator, meta.author, meta.user, meta.username) || "unknown",
-        filePath,
-    };
-}
-async function readSessionSummary(filePath, mtimeMs) {
-    let fileHandle = null;
-    try {
-        fileHandle = await open(filePath, "r");
-        const entryStat = await fileHandle.stat();
-        const firstLine = await readFirstLine(fileHandle, entryStat.size);
-        const tailSummary = await readLastAgentMessage(fileHandle, entryStat.size);
-        let normalized = normalizeSessionMeta({}, filePath, mtimeMs);
-        if (firstLine) {
-            try {
-                const parsed = JSON.parse(firstLine);
-                const candidateMeta = parsed && parsed.type === "session_meta" && isObjectRecord(parsed.payload)
-                    ? parsed.payload
-                    : isObjectRecord(parsed.session_meta)
-                        ? parsed.session_meta
-                        : isObjectRecord(parsed.sessionMeta)
-                            ? parsed.sessionMeta
-                            : isObjectRecord(parsed.meta)
-                                ? parsed.meta
-                                : isObjectRecord(parsed.payload)
-                                    ? parsed.payload
-                                    : parsed;
-                normalized = normalizeSessionMeta(candidateMeta, filePath, mtimeMs);
-            }
-            catch {
-                normalized = normalizeSessionMeta({}, filePath, mtimeMs);
-            }
-        }
-        return {
-            ...normalized,
-            label: tailSummary?.message || "(no agent message)",
-            updatedAt: tailSummary?.updatedAt || normalized.updatedAt,
-        };
-    }
-    catch {
-        return normalizeSessionMeta({}, filePath, mtimeMs);
-    }
-    finally {
-        await fileHandle?.close().catch(() => undefined);
-    }
-}
-async function listAgentSessions() {
-    const sessionsRoot = getSessionsRootPath();
-    let sessionsRootStat;
-    try {
-        sessionsRootStat = await stat(sessionsRoot);
-    }
-    catch {
-        return [];
-    }
-    if (!sessionsRootStat.isDirectory()) {
-        return [];
-    }
-    const files = await collectSessionJsonlFiles(sessionsRoot);
-    files.sort((a, b) => b.mtimeMs - a.mtimeMs || a.filePath.localeCompare(b.filePath));
-    const sessions = await Promise.all(files.slice(0, 10).map((file) => readSessionSummary(file.filePath, file.mtimeMs)));
-    return sessions.sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt) || b.filePath.localeCompare(a.filePath));
-}
-async function readSessionLineIndex(filePath) {
-    const resolvedFile = resolveSessionFilePath(filePath);
-    const entryStat = await stat(resolvedFile);
-    const nextSize = entryStat.size;
-    const cached = sessionLineIndexCache.get(resolvedFile) ?? null;
-    if (cached && cached.size === nextSize) {
-        return cached;
-    }
-    const fileHandle = await open(resolvedFile, "r");
-    try {
-        let lineStartOffsets = cached?.lineStartOffsets.slice() ?? [];
-        let scanStart = cached?.size ?? 0;
-        let endsWithNewline = cached?.endsWithNewline ?? false;
-        if (!cached || nextSize < cached.size) {
-            lineStartOffsets = nextSize > 0 ? [0] : [];
-            scanStart = 0;
-            endsWithNewline = false;
-        }
-        else if (cached.endsWithNewline && nextSize > cached.size) {
-            lineStartOffsets.push(cached.size);
-        }
-        let position = scanStart;
-        const chunkBytes = 65_536;
-        while (position < nextSize) {
-            const readSize = Math.min(chunkBytes, nextSize - position);
-            const buffer = Buffer.alloc(readSize);
-            const { bytesRead } = await fileHandle.read(buffer, 0, readSize, position);
-            if (bytesRead <= 0) {
-                break;
-            }
-            for (let index = 0; index < bytesRead; index += 1) {
-                if (buffer[index] !== 0x0a) {
-                    continue;
-                }
-                const nextLineStart = position + index + 1;
-                if (nextLineStart < nextSize) {
-                    lineStartOffsets.push(nextLineStart);
-                }
-            }
-            position += bytesRead;
-        }
-        if (nextSize > 0) {
-            const tail = Buffer.alloc(1);
-            const { bytesRead } = await fileHandle.read(tail, 0, 1, nextSize - 1);
-            endsWithNewline = bytesRead > 0 && tail[0] === 0x0a;
-        }
-        else {
-            endsWithNewline = false;
-        }
-        const nextEntry = {
-            size: nextSize,
-            lineStartOffsets,
-            endsWithNewline,
-        };
-        sessionLineIndexCache.set(resolvedFile, nextEntry);
-        return nextEntry;
-    }
-    finally {
-        await fileHandle.close().catch(() => undefined);
-    }
-}
-async function getAgentSessionRawRows(args) {
-    const resolvedFile = resolveSessionFilePath(args.filePath);
-    const index = await readSessionLineIndex(resolvedFile);
-    const totalLines = index.lineStartOffsets.length;
-    const sinceLine = Math.max(0, Math.floor(args.sinceLine));
-    const beforeRowId = args.beforeRowId && args.beforeRowId > 0 ? Math.floor(args.beforeRowId) : null;
-    const maxRawRows = 200;
-    const maxSelectionBytes = 120_000;
-    const maxLineSelectionBytes = 4_096;
-    const maxReadBytes = 2_000_000;
-    if (totalLines === 0) {
-        return {
-            rawRows: [],
-            nextCursor: 0,
-        };
-    }
-    let startLineIndex = 0;
-    let endLineIndex = totalLines;
-    const getLineSpanBytes = (lineIndex) => {
-        const start = index.lineStartOffsets[lineIndex] ?? index.size;
-        const end = lineIndex + 1 < totalLines ? (index.lineStartOffsets[lineIndex + 1] ?? index.size) : index.size;
-        return Math.max(0, end - start);
-    };
-    if (beforeRowId !== null) {
-        endLineIndex = Math.max(0, Math.min(totalLines, beforeRowId - 1));
-        startLineIndex = endLineIndex;
-        let collectedRows = 0;
-        let collectedSelectionBytes = 0;
-        let collectedReadBytes = 0;
-        while (startLineIndex > 0 && collectedRows < maxRawRows) {
-            const nextIndex = startLineIndex - 1;
-            const nextReadBytes = getLineSpanBytes(nextIndex);
-            const nextSelectionBytes = Math.min(nextReadBytes, maxLineSelectionBytes);
-            if (collectedRows > 0 && collectedSelectionBytes + nextSelectionBytes > maxSelectionBytes) {
-                break;
-            }
-            if (collectedRows > 0 && collectedReadBytes + nextReadBytes > maxReadBytes) {
-                break;
-            }
-            startLineIndex = nextIndex;
-            collectedRows += 1;
-            collectedSelectionBytes += nextSelectionBytes;
-            collectedReadBytes += nextReadBytes;
-        }
-    }
-    else if (sinceLine > 0) {
-        startLineIndex = Math.min(totalLines, sinceLine);
-        endLineIndex = startLineIndex;
-        let collectedRows = 0;
-        let collectedSelectionBytes = 0;
-        let collectedReadBytes = 0;
-        while (endLineIndex < totalLines && collectedRows < maxRawRows) {
-            const nextReadBytes = getLineSpanBytes(endLineIndex);
-            const nextSelectionBytes = Math.min(nextReadBytes, maxLineSelectionBytes);
-            if (collectedRows > 0 && collectedSelectionBytes + nextSelectionBytes > maxSelectionBytes) {
-                break;
-            }
-            if (collectedRows > 0 && collectedReadBytes + nextReadBytes > maxReadBytes) {
-                break;
-            }
-            endLineIndex += 1;
-            collectedRows += 1;
-            collectedSelectionBytes += nextSelectionBytes;
-            collectedReadBytes += nextReadBytes;
-        }
-    }
-    else {
-        startLineIndex = totalLines;
-        let collectedRows = 0;
-        let collectedSelectionBytes = 0;
-        let collectedReadBytes = 0;
-        while (startLineIndex > 0 && collectedRows < maxRawRows) {
-            const nextIndex = startLineIndex - 1;
-            const nextReadBytes = getLineSpanBytes(nextIndex);
-            const nextSelectionBytes = Math.min(nextReadBytes, maxLineSelectionBytes);
-            if (collectedRows > 0 && collectedSelectionBytes + nextSelectionBytes > maxSelectionBytes) {
-                break;
-            }
-            if (collectedRows > 0 && collectedReadBytes + nextReadBytes > maxReadBytes) {
-                break;
-            }
-            startLineIndex = nextIndex;
-            collectedRows += 1;
-            collectedSelectionBytes += nextSelectionBytes;
-            collectedReadBytes += nextReadBytes;
-        }
-    }
-    if (startLineIndex >= endLineIndex) {
-        return {
-            rawRows: [],
-            nextCursor: endLineIndex,
-        };
-    }
-    const startOffset = index.lineStartOffsets[startLineIndex] ?? index.size;
-    const endOffset = endLineIndex < totalLines ? (index.lineStartOffsets[endLineIndex] ?? index.size) : index.size;
-    if (startOffset >= endOffset) {
-        return {
-            rawRows: [],
-            nextCursor: endLineIndex,
-        };
-    }
-    const fileHandle = await open(resolvedFile, "r");
-    try {
-        const readSize = endOffset - startOffset;
-        const buffer = Buffer.alloc(readSize);
-        const { bytesRead } = await fileHandle.read(buffer, 0, readSize, startOffset);
-        const raw = buffer.toString("utf8", 0, bytesRead);
-        const lines = raw.split(/\r?\n/);
-        if (lines.length > 0 && lines[lines.length - 1] === "") {
-            lines.pop();
-        }
-        const rawRows = [];
-        let lineNumber = startLineIndex + 1;
-        for (const line of lines) {
-            if (line.trim()) {
-                const sanitized = sanitizeSessionRpcRawLine(line);
-                if (!sanitized) {
-                    lineNumber += 1;
-                    continue;
-                }
-                rawRows.push({
-                    id: lineNumber,
-                    raw: sanitized,
-                });
-            }
-            lineNumber += 1;
-        }
-        return {
-            rawRows,
-            nextCursor: endLineIndex,
-        };
-    }
-    finally {
-        await fileHandle.close().catch(() => undefined);
-    }
-}
-function resolveSessionUploadsDir(sessionId) {
-    const workspaceRoot = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
-    const safeSessionId = sessionId.trim().replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 160) || "session";
-    return path.join(workspaceRoot, ".doer-agent", "sessions", safeSessionId);
-}
-async function deleteAgentSession(filePath, sessionId) {
-    const resolvedFile = resolveSessionFilePath(filePath);
-    sessionLineIndexCache.delete(resolvedFile);
-    await unlink(resolvedFile);
-    if (sessionId) {
-        await rm(resolveSessionUploadsDir(sessionId), { recursive: true, force: true }).catch(() => undefined);
-    }
-    const sessionsRoot = path.resolve(getSessionsRootPath());
-    let currentDir = path.dirname(resolvedFile);
-    while (currentDir.startsWith(sessionsRoot + path.sep)) {
-        try {
-            const entries = await readdir(currentDir);
-            if (entries.length > 0) {
-                break;
-            }
-            await rmdir(currentDir);
-        }
-        catch {
-            break;
-        }
-        currentDir = path.dirname(currentDir);
-    }
-}
-function publishSessionRpcResponse(args) {
-    try {
-        args.nc.publish(args.responseSubject, sessionRpcCodec.encode(JSON.stringify(args.payload)));
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        writeAgentError(`session rpc publish failed responseSubject=${args.responseSubject}: ${message}`);
-    }
-}
-function stopAllSessionWatchers() {
-    const stops = [...activeSessionWatchers.values()];
-    for (const stop of stops) {
-        try {
-            stop();
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            writeAgentError(`session watcher cleanup failed: ${message}`);
-        }
-    }
-}
-async function startSessionWatch(args) {
-    const resolvedFile = resolveSessionFilePath(args.filePath);
-    const canonicalFile = await realpath(resolvedFile).catch(() => resolvedFile);
-    const watchId = `watch_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
-    let watcher = null;
-    let active = true;
-    const emitEvent = (event) => {
-        if (!active) {
-            return;
-        }
-        publishSessionRpcResponse({
-            nc: args.nc,
-            responseSubject: args.responseSubject,
-            payload: {
-                requestId: args.requestId,
-                ok: true,
-                action: "watch",
-                watchId,
-                event,
-            },
-        });
-    };
-    const cleanup = () => {
-        if (!active) {
-            return;
-        }
-        active = false;
-        activeSessionWatchers.delete(watchId);
-        watcher?.close();
-        watcher = null;
-    };
-    const notifyFromContent = () => {
-        emitEvent({
-            type: "messages.changed",
-            at: formatLocalTimestamp(),
-        });
-    };
-    watcher = watch(canonicalFile, { persistent: false }, (eventType) => {
-        if (!active) {
-            return;
-        }
-        if (eventType === "change" || eventType === "rename") {
-            notifyFromContent();
-        }
-    });
-    activeSessionWatchers.set(watchId, cleanup);
-    emitEvent({ type: "stream.started", watchId, at: formatLocalTimestamp() });
-    return watchId;
-}
-async function handleSessionRpcMessage(args) {
-    let requestId = "unknown";
-    let responseSubject = "";
-    try {
-        const payload = JSON.parse(sessionRpcCodec.decode(args.msg.data));
-        const request = normalizeSessionRpcRequest({ request: payload, agentId: args.agentId });
-        requestId = request.requestId;
-        responseSubject = request.responseSubject;
-        if (request.action === "list") {
-            const sessions = await listAgentSessions();
-            publishSessionRpcResponse({
-                nc: args.jetstream.nc,
-                responseSubject,
-                payload: { requestId, ok: true, action: "list", sessions },
-            });
-            return;
-        }
-        if (request.action === "messages") {
-            const result = await getAgentSessionRawRows({
-                filePath: request.filePath ?? "",
-                sinceLine: request.sinceLine,
-                beforeRowId: request.beforeRowId,
-                pageSize: request.pageSize,
-            });
-            publishSessionRpcResponse({
-                nc: args.jetstream.nc,
-                responseSubject,
-                payload: { requestId, ok: true, action: "messages", rawRows: result.rawRows, nextCursor: result.nextCursor },
-            });
-            return;
-        }
-        if (request.action === "delete") {
-            await deleteAgentSession(request.filePath ?? "", request.sessionId);
-            publishSessionRpcResponse({
-                nc: args.jetstream.nc,
-                responseSubject,
-                payload: { requestId, ok: true, action: "delete" },
-            });
-            return;
-        }
-        if (request.action === "watch") {
-            const watchId = await startSessionWatch({
+function subscribeToGitRpc(args) {
+    const subject = buildAgentGitRpcSubject(args.userId, args.agentId);
+    args.jetstream.nc.subscribe(subject, {
+        callback: (error, msg) => {
+            if (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                writeAgentError(`git rpc subscription error: ${message}`);
+                return;
+            }
+            void handleGitRpcMessage({
+                msg,
                 nc: args.jetstream.nc,
-                requestId,
-                responseSubject,
-                filePath: request.filePath ?? "",
+                agentId: args.agentId,
+                onError: writeAgentError,
             });
-            publishSessionRpcResponse({
-                nc: args.jetstream.nc,
-                responseSubject,
-                payload: { requestId, ok: true, action: "watch", watchId },
+        },
+    });
+    writeAgentInfo(`git rpc subscribed subject=${subject}`);
+}
+async function handleRunRpcMessage(args) {
+    let requestId = "unknown";
+    let responseSubject = "";
+    try {
+        const payload = JSON.parse(runRpcCodec.decode(args.msg.data));
+        const request = normalizeRunRpcRequest({
+            request: payload,
+            agentId: args.agentId,
+            normalizeModel: normalizeCodexModel,
+            normalizeImagePaths: normalizeRunImagePaths,
+            normalizeEnvPatch,
+            normalizeCodexAuthBundle: normalizeShellRpcCodexAuthBundle,
+        });
+        requestId = request.requestId;
+        responseSubject = request.responseSubject;
+        if (request.action === "start") {
+            const runId = request.runId ?? requestId;
+            await claimRunStartSlot({
+                workspaceRoot: resolveWorkspaceRoot(),
+                runId,
+                sessionId: request.sessionId,
+                formatTimestamp: formatLocalTimestamp,
             });
+            try {
+                const workspaceRoot = resolveWorkspaceRoot();
+                const localAgentSettings = await readAgentSettingsConfig({ workspaceRoot });
+                const customInstructions = await readAgentModelInstructions(workspaceRoot);
+                const task = await startManagedRun({
+                    requestId,
+                    runId,
+                    serverBaseUrl: args.serverBaseUrl,
+                    userId: args.userId,
+                    agentId: args.agentId,
+                    nc: args.jetstream.nc,
+                    sessionId: request.sessionId,
+                    codexArgs: buildManagedCodexArgs({
+                        prompt: request.prompt ?? "",
+                        imagePaths: request.imagePaths,
+                        sessionId: request.sessionId,
+                        model: request.model,
+                        personality: localAgentSettings.general.personality,
+                        modelInstructionsFile: customInstructions ? resolveAgentModelInstructionsFilePath(workspaceRoot) : null,
+                    }),
+                    cwd: request.cwd,
+                    runtimeEnvPatch: request.runtimeEnvPatch,
+                    codexAuthBundle: request.codexAuthBundle,
+                    agentToken: args.agentToken,
+                });
+                publishRunRpcResponse({ nc: args.jetstream.nc, responseSubject, payload: { requestId, ok: true, task } });
+            }
+            catch (error) {
+                await releaseRunStartSlot({
+                    workspaceRoot: resolveWorkspaceRoot(),
+                    runId,
+                    sessionId: request.sessionId,
+                }).catch(() => undefined);
+                throw error;
+            }
             return;
         }
-        const stop = request.watchId ? activeSessionWatchers.get(request.watchId) : null;
-        stop?.();
-        publishSessionRpcResponse({
+        await handleNonStartRunRpc({
+            request,
             nc: args.jetstream.nc,
-            responseSubject,
-            payload: { requestId, ok: true, action: "stop_watch", watchId: request.watchId },
+            userId: args.userId,
+            agentId: args.agentId,
+            listPersistedRunTasks: async () => listPersistedRunTasks(resolveWorkspaceRoot()),
+            cloneRunTask,
+            getStoredRun: async (runId) => getStoredRun(resolveWorkspaceRoot(), runId),
+            persistRunTask: async (task) => persistRunTask(resolveWorkspaceRoot(), task),
+            publishImmediateRunEvent: (task) => publishImmediateRunEvent({
+                nc: args.jetstream.nc,
+                userId: task.userId,
+                task,
+                buildRunEventsSubject: buildAgentRunEventsSubject,
+            }),
+            writeRunStatus,
+            sendSignalToPid,
+            formatTimestamp: formatLocalTimestamp,
         });
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         if (responseSubject) {
-            publishSessionRpcResponse({
+            publishRunRpcResponse({
                 nc: args.jetstream.nc,
                 responseSubject,
-                payload: {
-                    requestId,
-                    ok: false,
-                    error: message,
-                },
+                payload: { requestId, ok: false, error: message },
             });
         }
-        writeAgentError(`session rpc failed requestId=${requestId} error=${message}`);
+        writeAgentError(`run rpc failed requestId=${requestId} error=${message}`);
     }
 }
-function subscribeToSessionRpc(args) {
-    const subject = buildAgentSessionRpcSubject(args.userId, args.agentId);
+function subscribeToRunRpc(args) {
+    const subject = buildAgentRunRpcSubject(args.userId, args.agentId);
     args.jetstream.nc.subscribe(subject, {
         callback: (error, msg) => {
             if (error) {
                 const message = error instanceof Error ? error.message : String(error);
-                writeAgentError(`session rpc subscription error: ${message}`);
+                writeAgentError(`run rpc subscription error: ${message}`);
                 return;
             }
-            void handleSessionRpcMessage({
+            void handleRunRpcMessage({
                 msg,
                 jetstream: args.jetstream,
+                serverBaseUrl: args.serverBaseUrl,
+                userId: args.userId,
                 agentId: args.agentId,
+                agentToken: args.agentToken,
             });
         },
     });
-    writeAgentInfo(`session rpc subscribed subject=${subject}`);
-}
-async function handleFsRpcMessage(args) {
-    let payload = {};
-    try {
-        payload = JSON.parse(fsRpcCodec.decode(args.msg.data));
-        if (typeof payload.agentId === "string" && payload.agentId.trim() && payload.agentId !== args.agentId) {
-            throw new Error("agent id mismatch");
-        }
-        const result = await executeFsRpc({
-            request: payload,
-            serverBaseUrl: args.serverBaseUrl,
-            agentToken: args.agentToken,
-        });
-        args.msg.respond(fsRpcCodec.encode(JSON.stringify(result)));
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "unknown error";
-        const action = typeof payload.action === "string" ? payload.action : "";
-        const response = {
-            ok: false,
-            action,
-            path: typeof payload.path === "string" ? payload.path : ".",
-            error: message,
-        };
-        args.msg.respond(fsRpcCodec.encode(JSON.stringify(response)));
-        writeAgentError(`fs rpc failed action=${action || "unknown"} error=${message}`);
-    }
+    writeAgentInfo(`run rpc subscribed subject=${subject}`);
 }
 function subscribeToFsRpc(args) {
     const subject = buildAgentFsRpcSubject(args.userId, args.agentId);
@@ -3789,527 +372,48 @@ function subscribeToFsRpc(args) {
             }
             void handleFsRpcMessage({
                 msg,
+                workspaceRoot: resolveWorkspaceRoot(),
                 serverBaseUrl: args.serverBaseUrl,
-                userId: args.userId,
                 agentId: args.agentId,
                 agentToken: args.agentToken,
+                onError: writeAgentError,
             });
         },
     });
     writeAgentInfo(`fs rpc subscribed subject=${subject}`);
 }
-function normalizeShellRpcCodexAuthBundle(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return null;
-    }
-    const row = value;
-    const authJson = typeof row.authJson === "string" ? row.authJson : null;
-    const authMode = row.authMode === "oauth" ? "oauth" : row.authMode === "api_key" ? "api_key" : undefined;
-    const apiKey = typeof row.apiKey === "string" || row.apiKey === null ? row.apiKey : undefined;
-    if (!authJson && authMode !== "api_key" && apiKey === undefined) {
-        return null;
-    }
-    return {
-        taskId: typeof row.taskId === "string" ? row.taskId : undefined,
-        authMode,
-        issuedAt: typeof row.issuedAt === "string" ? row.issuedAt : undefined,
-        expiresAt: typeof row.expiresAt === "string" ? row.expiresAt : undefined,
-        authJson: authJson ?? undefined,
-        apiKey,
-    };
-}
-async function postJson(url, body) {
-    const res = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body),
-    });
-    const text = await res.text();
-    let data = {};
-    if (text) {
-        try {
-            data = JSON.parse(text);
-        }
-        catch {
-            data = {};
-        }
-    }
-    if (!res.ok) {
-        const errObj = (data && typeof data === "object" ? data : {});
-        const message = typeof errObj.error === "string" ? errObj.error : `HTTP ${res.status}`;
-        throw new Error(message);
-    }
-    return data;
-}
-async function getJson(url) {
-    const res = await fetch(url);
-    const text = await res.text();
-    let data = {};
-    if (text) {
-        try {
-            data = JSON.parse(text);
-        }
-        catch {
-            data = {};
-        }
-    }
-    if (!res.ok) {
-        const errObj = (data && typeof data === "object" ? data : {});
-        const message = typeof errObj.error === "string" ? errObj.error : `HTTP ${res.status}`;
-        throw new Error(message);
-    }
-    return data;
-}
-const nextEventSeqByTask = new Map();
-function reserveNextEventSeq(taskId) {
-    const current = nextEventSeqByTask.get(taskId) ?? 1;
-    nextEventSeqByTask.set(taskId, current + 1);
-    return current;
-}
-function emitAgentMetaLog(level, message) {
-    const ctx = activeTaskLogContext;
-    if (!ctx) {
-        return;
-    }
-    const seq = reserveNextEventSeq(ctx.taskId);
-    void recordAgentEvent({
-        jetstream: ctx.jetstream,
-        serverBaseUrl: ctx.serverBaseUrl,
-        taskId: ctx.taskId,
-        userId: ctx.userId,
-        type: "meta",
-        seq,
-        payload: {
-            channel: "agent",
-            level,
-            message,
-            at: formatLocalTimestamp(),
-        },
-    }).catch((error) => {
-        const detail = error instanceof Error ? error.message : String(error);
-        process.stderr.write(`[doer-agent] meta log persist failed task=${ctx.taskId}: ${detail}\n`);
-    });
-}
-async function recordAgentEvent(args) {
-    await args.jetstream.js.publish(args.jetstream.subject, args.jetstream.codec.encode({
-        serverBaseUrl: args.serverBaseUrl,
-        userId: args.userId,
-        taskId: args.taskId,
-        type: args.type,
-        seq: args.seq,
-        payload: args.payload,
-    }));
-}
-function persistEventOrFatal(args) {
-    void (async () => {
-        let attempt = 0;
-        let delayMs = 150;
-        while (attempt < 3) {
-            attempt += 1;
-            try {
-                await recordAgentEvent(args);
-                return;
-            }
-            catch (error) {
-                if (attempt >= 3) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    writeAgentError(`task=${args.taskId} ${args.context}: ${message} (dropped after ${attempt} attempts)`);
-                    return;
-                }
-                await sleep(delayMs);
-                delayMs *= 2;
-            }
-        }
-    })();
-}
-async function heartbeatAgentSession(args) {
-    await args.nc.flush();
-    await postJson(`${args.serverBaseUrl}/api/agent/heartbeat`, {
-        userId: args.userId,
-        agentToken: args.agentToken,
-    });
-}
-async function claimTaskById(args) {
-    const response = await postJson(`${args.serverBaseUrl}/api/agent/tasks/claim`, {
-        userId: args.userId,
-        agentToken: args.agentToken,
-        taskId: args.taskId,
-    });
-    return response.task ?? null;
-}
-async function runClaimedTask(args) {
-    try {
-        writeAgentInfo(`run task=${args.task.id} command=${args.task.command}`);
-        await runTask({
-            serverBaseUrl: args.serverBaseUrl,
-            taskId: args.task.id,
-            command: args.task.command,
-            cwd: args.task.cwd,
-            userId: args.userId,
-            agentToken: args.agentToken,
-            jetstream: args.jetstream,
-        }).catch(async (error) => {
-            const message = error instanceof Error ? error.message : String(error);
-            writeAgentError(`task=${args.task.id} run failed: ${message}`);
-            const failPayload = {
-                status: "failed",
-                error: message,
-                finishedAt: formatLocalTimestamp(),
-            };
-            await recordAgentEvent({
-                jetstream: args.jetstream,
-                serverBaseUrl: args.serverBaseUrl,
-                taskId: args.task.id,
-                userId: args.userId,
-                type: "status",
-                seq: reserveNextEventSeq(args.task.id),
-                payload: failPayload,
-            });
-        });
-    }
-    finally {
-        if (activeTaskLogContext?.taskId === args.task.id) {
-            activeTaskLogContext = null;
-        }
-    }
-}
-async function checkCancelRequested(args) {
-    const query = new URLSearchParams({
-        userId: args.userId,
-        agentToken: args.agentToken,
-    });
-    const response = await 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") {
-        if (args.apiKey) {
-            envPatch.OPENAI_API_KEY = args.apiKey;
-        }
-    }
-    return {
-        envPatch,
-        cleanup: async () => { },
-        meta: {
-            codexAuthSource: args.source,
-            codexAuthMode: args.authMode ?? null,
-            codexAuthHasApiKey: Boolean(args.apiKey),
-            codexAuthHasAuthJson: Boolean(args.authJson),
-            codexAuthIssuedAt: args.issuedAt ?? null,
-            codexAuthExpiresAt: args.expiresAt ?? null,
-            codexAuthSynced: synced,
-        },
-    };
-}
-async function prepareTaskCodexAuth(args) {
-    void args;
-    return await syncCodexAuthState({
-        source: "agent_local",
-        authJson: null,
-        issuedAt: null,
-        expiresAt: null,
-    });
-}
-async function prepareCodexAuthBundle(bundle) {
-    if (!bundle) {
-        return null;
-    }
-    return await syncCodexAuthState({
-        source: "server_bundle",
-        authMode: bundle.authMode,
-        apiKey: bundle.apiKey,
-        authJson: bundle.authJson ?? null,
-        issuedAt: bundle.issuedAt ?? null,
-        expiresAt: bundle.expiresAt ?? null,
-    });
-}
-async function prepareCommandExecution(args) {
-    const shellPath = resolveShellPath();
-    const taskWorkspace = resolveTaskWorkspace(args.cwd);
-    const codexHome = resolveCodexHomePath();
-    await mkdir(codexHome, { recursive: true });
-    const codexAuth = await prepareCodexAuthBundle(args.codexAuthBundle);
-    const localAgentSettings = await readAgentSettingsConfig(null);
-    const baseTaskEnvPatch = {
-        CODEX_HOME: codexHome,
-        DOER_USER_ID: args.userId,
-        DOER_AGENT_TASK_ID: args.taskId,
-        ...buildAgentSettingsEnvPatch(localAgentSettings),
-        ...args.runtimeEnvPatch,
-        ...(codexAuth?.envPatch ?? {}),
-        WORKSPACE: taskWorkspace,
-    };
-    const taskGitEnv = await prepareTaskGitEnv({
-        cwd: taskWorkspace,
-        baseEnvPatch: baseTaskEnvPatch,
-    });
-    const runtimeBinPath = path.join(AGENT_PROJECT_DIR, "runtime/bin");
-    const taskPath = [runtimeBinPath, process.env.PATH || ""].filter(Boolean).join(path.delimiter);
-    return {
-        shellPath,
-        taskWorkspace,
-        taskPath,
-        env: {
-            ...process.env,
-            ...baseTaskEnvPatch,
-            ...taskGitEnv.envPatch,
-            PATH: taskPath,
-        },
-        taskGitMeta: taskGitEnv.meta ?? {},
-        codexAuthMeta: codexAuth?.meta ?? { codexAuthSynced: false },
-        codexAuthCleanup: codexAuth?.cleanup ?? (async () => { }),
-    };
-}
-function spawnPreparedCommand(args) {
-    const env = {
-        ...args.env,
-        DOER_AGENT_TOKEN: args.agentToken,
-    };
-    const child = args.kind === "apply_patch"
-        ? spawn("apply_patch", {
-            cwd: args.taskWorkspace,
-            detached: process.platform !== "win32",
-            env,
-            stdio: ["pipe", "pipe", "pipe"],
-        })
-        : spawn(args.command ?? "", {
-            cwd: args.taskWorkspace,
-            shell: args.shellPath,
-            detached: process.platform !== "win32",
-            env,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-    if (args.kind === "apply_patch") {
-        child.stdin?.write(args.patch ?? "");
-        child.stdin?.end();
-    }
-    child.stdout.setEncoding("utf8");
-    child.stderr.setEncoding("utf8");
-    return child;
-}
-async function runTask(args) {
-    activeTaskLogContext = {
-        jetstream: args.jetstream,
-        serverBaseUrl: args.serverBaseUrl,
-        taskId: args.taskId,
-        userId: args.userId,
-    };
-    const shellPath = resolveShellPath();
-    const taskWorkspace = resolveTaskWorkspace(args.cwd);
-    const codexHome = resolveCodexHomePath();
-    await mkdir(codexHome, { recursive: true });
-    const runtimeConfig = await 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 readAgentSettingsConfig(null);
-    const baseTaskEnvPatch = {
-        CODEX_HOME: codexHome,
-        ...buildAgentSettingsEnvPatch(localAgentSettings),
-        ...(runtimeConfig?.envPatch ?? {}),
-        ...(codexAuth?.envPatch ?? {}),
-        WORKSPACE: taskWorkspace,
-    };
-    const taskGitEnv = await prepareTaskGitEnv({
-        cwd: taskWorkspace,
-        baseEnvPatch: baseTaskEnvPatch,
-    });
-    await recordAgentEvent({ jetstream: args.jetstream,
-        serverBaseUrl: args.serverBaseUrl,
-        taskId: args.taskId,
-        userId: args.userId,
-        type: "meta",
-        seq: reserveNextEventSeq(args.taskId),
-        payload: {
-            host: process.platform,
-            pid: process.pid,
-            startedAt: 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(AGENT_PROJECT_DIR, "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) => {
-            writeTaskStream(args.taskId, "stdout", chunk);
-            const seq = reserveNextEventSeq(args.taskId);
-            persistEventOrFatal({
-                jetstream: args.jetstream,
-                serverBaseUrl: args.serverBaseUrl,
-                taskId: args.taskId,
-                userId: args.userId,
-                type: "stdout",
-                seq,
-                payload: { chunk, at: formatLocalTimestamp() },
-                context: "stdout persist failed",
-            });
-        });
-        child.stderr.on("data", (chunk) => {
-            writeTaskStream(args.taskId, "stderr", chunk);
-            const seq = reserveNextEventSeq(args.taskId);
-            persistEventOrFatal({
-                jetstream: args.jetstream,
-                serverBaseUrl: args.serverBaseUrl,
-                taskId: args.taskId,
-                userId: args.userId,
-                type: "stderr",
-                seq,
-                payload: { chunk, at: formatLocalTimestamp() },
-                context: "stderr persist failed",
-            });
-        });
-        const cancelPoller = (async () => {
-            while (!stopCancelPolling) {
-                await sleep(5000);
-                if (stopCancelPolling || terminationReason === "cancel") {
-                    continue;
-                }
-                const cancelRequested = await checkCancelRequested({
-                    serverBaseUrl: args.serverBaseUrl,
-                    taskId: args.taskId,
-                    userId: args.userId,
-                    agentToken: args.agentToken,
-                }).catch(() => false);
-                if (!cancelRequested) {
-                    continue;
-                }
-                requestCancel();
-            }
-        })();
-        const result = await new Promise((resolve, reject) => {
-            child.once("error", (error) => {
-                reject(error);
-            });
-            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({
+const runtimeEnvHelpers = createRuntimeEnvHelpers({
+    resolveWorkspaceRoot,
+    agentProjectDir: AGENT_PROJECT_DIR,
+});
+const localCodexCliTools = createLocalCodexCliTools({
+    resolveWorkspaceRoot,
+    resolveCodexHomePath: runtimeEnvHelpers.resolveCodexHomePath,
+    resolveShellPath: runtimeEnvHelpers.resolveShellPath,
+    sendSignalToTaskProcess,
+});
+const eventPersistenceHelpers = createEventPersistenceHelpers({
+    getActiveTaskLogContext: () => activeTaskLogContext,
+    publishEvent: async (args) => {
+        await args.jetstream.js.publish(args.jetstream.subject, args.jetstream.codec.encode({
             serverBaseUrl: args.serverBaseUrl,
-            taskId: args.taskId,
             userId: args.userId,
-            agentToken: args.agentToken,
-        }).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: formatLocalTimestamp(),
-            error: status === "failed"
-                ? `Command exited with code ${result.code ?? "null"}`
-                : null,
-        };
-        await recordAgentEvent({ jetstream: args.jetstream,
-            serverBaseUrl: args.serverBaseUrl,
             taskId: args.taskId,
-            userId: args.userId,
-            type: "status",
-            seq: reserveNextEventSeq(args.taskId),
-            payload: statusPayload,
-        });
-        writeAgentInfo(`task=${args.taskId} status=${status} exitCode=${typeof result.code === "number" ? result.code : "null"} signal=${result.signal ?? "null"}`);
-    }
-    finally {
-        activeTaskLogContext = null;
-        await codexAuth?.cleanup().catch(() => undefined);
-    }
-}
-async function connectBootstrapWithRetry(args) {
-    let attempt = 0;
-    while (true) {
-        attempt += 1;
-        try {
-            const natsBootstrap = await postJson(`${args.serverBaseUrl}/api/agent/nats`, {
-                userId: args.userId,
-                agentToken: args.agentToken,
-            });
-            const natsServers = normalizeNatsServers(natsBootstrap.servers);
-            if (natsServers.length === 0) {
-                throw new Error("No NATS servers configured by server");
-            }
-            const natsToken = normalizeNatsToken(natsBootstrap.auth);
-            const jetstream = await initJetStreamContext({
-                userId: args.userId,
-                servers: natsServers,
-                token: natsToken,
-            });
-            writeAgentInfraError(`bootstrap ok servers=${natsServers.length} eventStream=${jetstream.stream} eventSubject=${jetstream.subject}`);
-            return { natsBootstrap, jetstream };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            const retryMs = Math.min(30_000, 1000 * Math.max(1, attempt));
-            writeAgentError(`bootstrap failed: ${message} (retry in ${Math.floor(retryMs / 1000)}s, attempt=${attempt})`);
-            await sleep(retryMs);
-        }
-    }
-}
+            type: args.type,
+            seq: args.seq,
+            payload: args.payload,
+        }));
+    },
+    formatTimestamp: formatLocalTimestamp,
+    onError: writeAgentError,
+    sleep,
+});
+const heartbeatSession = async (args) => {
+    await heartbeatAgentSession({
+        ...args,
+        postJson,
+    });
+};
 async function main() {
     const args = parseArgs(process.argv.slice(2));
     const workspaceDir = resolveArgOrEnv(args, ["workspace-dir", "workspaceDir"], ["WORKSPACE"]);
@@ -4319,7 +423,7 @@ 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();
+    await resetRunsDir(resolveWorkspaceRoot());
     const serverBaseUrlRaw = resolveArgOrEnv(args, ["server", "url"], ["DOER_AGENT_SERVER"], DEFAULT_SERVER_BASE_URL);
     const requestedServerBaseUrl = serverBaseUrlRaw.replace(/\/$/, "");
     const serverBaseUrl = resolveContainerReachableServerBaseUrl(requestedServerBaseUrl);
@@ -4330,13 +434,18 @@ async function main() {
         throw new Error("user-id and agent-secret are required");
     }
     const agentToken = agentSecret;
-    const agentVersion = await resolveAgentVersion();
+    const agentVersion = await resolveAgentVersion(AGENT_PACKAGE_JSON_PATH);
     let bannerShown = false;
     while (true) {
         const { natsBootstrap, jetstream } = await connectBootstrapWithRetry({
             serverBaseUrl,
             userId,
             agentToken,
+            postJson,
+            sanitizeUserId,
+            onInfraError: writeAgentInfraError,
+            onError: writeAgentError,
+            sleep,
         });
         const initialAgentId = typeof natsBootstrap.agentId === "string" ? natsBootstrap.agentId : "";
         if (!initialAgentId) {
@@ -4363,90 +472,82 @@ async function main() {
         else {
             writeAgentInfraError(`nats session restored agentId=${initialAgentId} servers=${jetstream.servers.join(",")} at=${formatLocalTimestamp()}`);
         }
-        let heartbeatFailures = 0;
-        let heartbeatInFlight = false;
-        let sessionInvalidated = false;
-        const invalidateAgentSession = (reason) => {
-            if (sessionInvalidated) {
-                return;
-            }
-            sessionInvalidated = true;
-            writeAgentInfraError(`closing nats session: ${reason}`);
-            void jetstream.nc.close().catch((error) => {
-                const message = error instanceof Error ? error.message : String(error);
-                writeAgentInfraError(`failed to close nats session: ${message}`);
-            });
-        };
-        const heartbeatTimer = setInterval(() => {
-            if (heartbeatInFlight || sessionInvalidated) {
-                return;
-            }
-            heartbeatInFlight = true;
-            void heartbeatAgentSession({ nc: jetstream.nc, serverBaseUrl, userId, agentToken })
-                .then(() => {
-                heartbeatInFlight = false;
-                if (heartbeatFailures > 0) {
-                    writeAgentInfraError(`heartbeat reconnected at=${formatLocalTimestamp()}`);
-                }
-                heartbeatFailures = 0;
-            })
-                .catch((error) => {
-                heartbeatInFlight = false;
-                const message = error instanceof Error ? error.message : String(error);
-                heartbeatFailures += 1;
-                if (heartbeatFailures > 1) {
-                    writeAgentInfraError(`heartbeat failed: ${message} (count=${heartbeatFailures}/${HEARTBEAT_FAILURE_THRESHOLD})`);
-                }
-                if (heartbeatFailures >= HEARTBEAT_FAILURE_THRESHOLD) {
-                    invalidateAgentSession(`heartbeat failure threshold reached at=${formatLocalTimestamp()}`);
-                }
-            });
-        }, HEARTBEAT_INTERVAL_MS);
-        subscribeToFsRpc({
-            jetstream,
-            serverBaseUrl,
-            userId,
-            agentId: initialAgentId,
-            agentToken,
-        });
-        subscribeToSessionRpc({
-            jetstream,
-            userId,
-            agentId: initialAgentId,
-        });
-        subscribeToCodexAuthRpc({
-            jetstream,
-            userId,
-            agentId: initialAgentId,
-        });
-        subscribeToSettingsRpc({
-            jetstream,
-            userId,
-            agentId: initialAgentId,
-        });
-        subscribeToGitRpc({
-            jetstream,
-            userId,
-            agentId: initialAgentId,
-        });
-        subscribeToSkillRpc({
-            jetstream,
-            userId,
-            agentId: initialAgentId,
-        });
-        subscribeToRunRpc({
+        await runConnectedAgentSession({
             jetstream,
             serverBaseUrl,
             userId,
-            agentId: initialAgentId,
             agentToken,
+            heartbeatIntervalMs: HEARTBEAT_INTERVAL_MS,
+            heartbeatFailureThreshold: HEARTBEAT_FAILURE_THRESHOLD,
+            formatTimestamp: formatLocalTimestamp,
+            heartbeatAgentSession: heartbeatSession,
+            subscribeAll: () => {
+                subscribeToFsRpc({
+                    jetstream,
+                    serverBaseUrl,
+                    userId,
+                    agentId: initialAgentId,
+                    agentToken,
+                });
+                subscribeToSessionRpc({
+                    nc: jetstream.nc,
+                    subject: buildAgentSessionRpcSubject(userId, initialAgentId),
+                    agentId: initialAgentId,
+                    workspaceRoot: resolveWorkspaceRoot(),
+                    onInfo: writeAgentInfo,
+                    onError: writeAgentError,
+                    formatTimestamp: formatLocalTimestamp,
+                });
+                subscribeToCodexAuthRpc({
+                    nc: jetstream.nc,
+                    subject: buildAgentCodexAuthRpcSubject(userId, initialAgentId),
+                    agentId: initialAgentId,
+                    workspaceRoot: resolveWorkspaceRoot(),
+                    buildLocalCodexCliCommand: localCodexCliTools.buildLocalCodexCliCommand,
+                    resolveShellPath: runtimeEnvHelpers.resolveShellPath,
+                    resolveCodexHomePath: runtimeEnvHelpers.resolveCodexHomePath,
+                    runLocalCodexCli: localCodexCliTools.runLocalCodexCli,
+                    runLocalCodexCliWithInput: localCodexCliTools.runLocalCodexCliWithInput,
+                    sendSignalToTaskProcess,
+                    stripAnsi: localCodexCliTools.stripAnsi,
+                    onInfo: writeAgentInfo,
+                    onError: writeAgentError,
+                });
+                subscribeToSettingsRpc({
+                    jetstream,
+                    userId,
+                    agentId: initialAgentId,
+                });
+                subscribeToGitRpc({
+                    jetstream,
+                    userId,
+                    agentId: initialAgentId,
+                });
+                subscribeToSkillRpc({
+                    nc: jetstream.nc,
+                    subject: buildAgentSkillRpcSubject(userId, initialAgentId),
+                    agentId: initialAgentId,
+                    workspaceRoot: resolveWorkspaceRoot(),
+                    resolveCodexHomePath: runtimeEnvHelpers.resolveCodexHomePath,
+                    readAgentSettingsConfig,
+                    buildAgentSettingsEnvPatch,
+                    runLocalCodexCli: localCodexCliTools.runLocalCodexCli,
+                    stripAnsi: localCodexCliTools.stripAnsi,
+                    onInfo: writeAgentInfo,
+                    onError: writeAgentError,
+                });
+                subscribeToRunRpc({
+                    jetstream,
+                    serverBaseUrl,
+                    userId,
+                    agentId: initialAgentId,
+                    agentToken,
+                });
+            },
+            stopAllSessionWatchers: () => stopAllSessionWatchers({ onError: writeAgentError }),
+            onInfraError: writeAgentInfraError,
+            sleep,
         });
-        const closeError = await jetstream.nc.closed();
-        clearInterval(heartbeatTimer);
-        stopAllSessionWatchers();
-        const detail = closeError instanceof Error ? closeError.message : "clean close";
-        writeAgentInfraError(`nats session ended: ${detail}; reconnecting`);
-        await sleep(1000);
     }
 }
 main().catch((error) => {