doer-agent 0.9.6 → 0.9.8

package/dist/agent-runtime-utils.js

@@ -28,9 +28,6 @@ export function buildAgentNotesRpcSubject(userId, agentId) {
 export function buildAgentNotesAiRpcSubject(userId, agentId) {
     return `doer.agent.notes.ai.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }
-export function buildAgentThreadTagsRpcSubject(userId, agentId) {
-    return `doer.agent.thread.tags.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
-}
 export function buildAgentDaemonRpcSubject(userId, agentId) {
     return `doer.agent.daemon.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }

package/dist/agent-thread-tags-rpc.js

@@ -1,5 +1,5 @@
 import crypto from "node:crypto";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, rename, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { StringCodec } from "nats";
 import { runCodexTextTask } from "./codex-text-task.js";
@@ -9,6 +9,8 @@ const MAX_THREADS_PER_REBUILD = 2_000;
 const MAX_TAGS = 12;
 const MIN_TAGS = 2;
 const OTHER_TAG_ID = "other";
+const MAX_REPOSITORIES = 200;
+const MAX_RELATED_REPOS = 3;
 const DEFAULT_TAGS = [
     { id: "deployment", label: "Deployment", description: "Deploy, release, publish, production rollout, or app-store delivery.", color: "#8b5cf6" },
     { id: "bug", label: "Bug · diagnosis", description: "Debugging, errors, failures, regressions, diagnosis, or fixes.", color: "#ef4444" },
@@ -55,6 +57,70 @@ function tagsFilePath(workspaceRoot, threadId) {
 function configFilePath(workspaceRoot) {
     return path.join(workspaceRoot, ".doer-agent", "thread-tags", "config.json");
 }
+async function isGitRepository(directoryPath) {
+    try {
+        const gitEntry = await stat(path.join(directoryPath, ".git"));
+        return gitEntry.isDirectory() || gitEntry.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function repositoryCandidate(workspaceRoot, absolutePath) {
+    const relativePath = path.relative(workspaceRoot, absolutePath).split(path.sep).join("/") || ".";
+    return {
+        id: relativePath,
+        label: path.basename(absolutePath),
+        relativePath,
+        absolutePath,
+    };
+}
+export async function discoverWorkspaceRepositories(workspaceRoot) {
+    const resolvedRoot = path.resolve(workspaceRoot);
+    const candidates = [];
+    if (await isGitRepository(resolvedRoot)) {
+        candidates.push(repositoryCandidate(resolvedRoot, resolvedRoot));
+    }
+    const entries = await readdir(resolvedRoot, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        if (candidates.length >= MAX_REPOSITORIES ||
+            !entry.isDirectory() ||
+            entry.name.startsWith(".")) {
+            continue;
+        }
+        const absolutePath = path.join(resolvedRoot, entry.name);
+        if (await isGitRepository(absolutePath)) {
+            candidates.push(repositoryCandidate(resolvedRoot, absolutePath));
+        }
+    }
+    return candidates.sort((left, right) => (left.label.localeCompare(right.label) || left.id.localeCompare(right.id)));
+}
+function repositoryFingerprint(repositories) {
+    return crypto.createHash("sha256").update(JSON.stringify(repositories.map((repository) => ({
+        id: repository.id,
+        label: repository.label,
+        relativePath: repository.relativePath,
+    })))).digest("hex");
+}
+function pathIsWithin(candidatePath, targetPath) {
+    const relative = path.relative(candidatePath, targetPath);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+export function relatedReposFromCwd(cwd, repositories) {
+    if (!cwd) {
+        return [];
+    }
+    const resolvedCwd = path.resolve(cwd);
+    const repository = repositories
+        .filter((candidate) => pathIsWithin(candidate.absolutePath, resolvedCwd))
+        .sort((left, right) => right.absolutePath.length - left.absolutePath.length)[0];
+    return repository ? [{
+            id: repository.id,
+            label: repository.label,
+            confidence: 1,
+            source: "cwd",
+        }] : [];
+}
 function normalizeInputs(value, limit) {
     const rows = Array.isArray(value) ? value.slice(0, limit) : [];
     const seen = new Set();
@@ -191,9 +257,10 @@ function jsonObjectFromText(text) {
     }
     return payload;
 }
-export function parseThreadTagClassificationResponse(text, requestedThreadIds, allowedTagIds = new Set(DEFAULT_TAGS.map((tag) => tag.id))) {
+export function parseThreadTagClassificationResponse(text, requestedThreadIds, allowedTagIds = new Set(DEFAULT_TAGS.map((tag) => tag.id)), repositories = []) {
     const payload = jsonObjectFromText(text);
     const assignments = Array.isArray(payload.assignments) ? payload.assignments : [];
+    const repositoriesById = new Map(repositories.map((repository) => [repository.id, repository]));
     const seen = new Set();
     const results = [];
     for (const assignmentValue of assignments) {
@@ -207,11 +274,30 @@ export function parseThreadTagClassificationResponse(text, requestedThreadIds, a
             continue;
         }
         seen.add(threadId);
+        const seenRepositoryIds = new Set();
+        const relatedRepos = (Array.isArray(assignment?.relatedRepos) ? assignment.relatedRepos : [])
+            .flatMap((value) => {
+            const row = recordValue(value);
+            const id = stringValue(row?.id) || stringValue(value);
+            const repository = repositoriesById.get(id);
+            if (!repository || seenRepositoryIds.has(id)) {
+                return [];
+            }
+            seenRepositoryIds.add(id);
+            return [{
+                    id: repository.id,
+                    label: repository.label,
+                    confidence: boundedConfidence(row?.confidence),
+                    source: "ai",
+                }];
+        })
+            .slice(0, MAX_RELATED_REPOS);
         results.push({
             threadId,
             activityTag,
             confidence: boundedConfidence(assignment?.confidence),
             source: "ai",
+            relatedRepos,
         });
     }
     return results;
@@ -219,41 +305,61 @@ export function parseThreadTagClassificationResponse(text, requestedThreadIds, a
 export function parseSuggestedThreadTags(text) {
     return normalizeTagDefinitions(jsonObjectFromText(text).tags);
 }
-async function readStoredTags(workspaceRoot, input, config) {
+async function readStoredTags(workspaceRoot, input, config, repositories) {
     try {
         const row = recordValue(JSON.parse(await readFile(tagsFilePath(workspaceRoot, input.threadId), "utf8")));
         const activityTag = sanitizeTagId(stringValue(row?.activityTag));
         const allowedTagIds = new Set(config.tags.map((tag) => tag.id));
-        const isLegacyDefaultCache = row?.version === 1 && config.source === "default";
-        const isCurrentCache = row?.version === 2 && stringValue(row.configFingerprint) === config.fingerprint;
-        if ((!isLegacyDefaultCache && !isCurrentCache) ||
+        const isCurrentCache = row?.version === 3 &&
+            stringValue(row.configFingerprint) === config.fingerprint &&
+            stringValue(row.repositoryFingerprint) === repositoryFingerprint(repositories);
+        if (!isCurrentCache ||
             stringValue(row?.threadId) !== input.threadId ||
             stringValue(row?.contentFingerprint) !== contentFingerprint(input) ||
             !allowedTagIds.has(activityTag)) {
             return null;
         }
+        const repositoriesById = new Map(repositories.map((repository) => [repository.id, repository]));
+        const relatedRepos = (Array.isArray(row?.relatedRepos) ? row.relatedRepos : [])
+            .flatMap((value) => {
+            const stored = recordValue(value);
+            const repository = repositoriesById.get(stringValue(stored?.id));
+            if (!repository) {
+                return [];
+            }
+            return [{
+                    id: repository.id,
+                    label: repository.label,
+                    confidence: boundedConfidence(stored?.confidence),
+                    source: stored?.source === "cwd" ? "cwd" : "ai",
+                }];
+        })
+            .slice(0, MAX_RELATED_REPOS);
         return {
             threadId: input.threadId,
             activityTag,
             confidence: boundedConfidence(row?.confidence),
             source: "ai",
+            relatedRepos,
         };
     }
     catch {
         return null;
     }
 }
-async function writeStoredTags(workspaceRoot, input, classification, config) {
+async function writeStoredTags(workspaceRoot, input, classification, config, repositories) {
     const filePath = tagsFilePath(workspaceRoot, input.threadId);
     await mkdir(path.dirname(filePath), { recursive: true });
     const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
     const payload = {
-        version: 2,
+        version: 3,
         threadId: input.threadId,
         contentFingerprint: contentFingerprint(input),
         configFingerprint: config.fingerprint,
+        repositoryFingerprint: repositoryFingerprint(repositories),
         activityTag: classification.activityTag,
         confidence: classification.confidence,
+        relatedRepos: classification.relatedRepos,
         source: "ai",
         updatedAt: new Date().toISOString(),
     };
@@ -263,15 +369,23 @@ async function writeStoredTags(workspaceRoot, input, classification, config) {
 function configuredTagsPrompt(tags) {
     return tags.map((tag) => `- ${tag.id} (${tag.label}): ${tag.description}`);
 }
-function classifierPrompt(inputs, tags) {
+function classifierPrompt(inputs, tags, repositories) {
     return [
         "You classify Codex threads inside Doer.",
         "Return only one valid JSON object. Do not use Markdown fences or add explanations.",
         "Classify every input thread into exactly one activityTag from the configured list.",
         "Configured activityTag values:",
         ...configuredTagsPrompt(tags),
-        "Use label and preview as the main evidence. Use cwd only as supporting project context.",
-        `Output shape: {"assignments":[{"threadId":"...","activityTag":"${tags[0]?.id ?? OTHER_TAG_ID}","confidence":0.9}]}`,
+        "Also select zero to three relatedRepos for each thread from the repository candidates below.",
+        "A related repository is a code repository that the thread discusses, inspects, modifies, tests, deploys, or otherwise directly works on.",
+        "Do not invent repository ids and do not select a repository merely because it shares the agent workspace.",
+        `Repository candidates: ${JSON.stringify(repositories.map((repository) => ({
+            id: repository.id,
+            label: repository.label,
+            relativePath: repository.relativePath,
+        })))}`,
+        "Use label and preview as the main evidence. Use cwd as strong supporting repository evidence.",
+        `Output shape: {"assignments":[{"threadId":"...","activityTag":"${tags[0]?.id ?? OTHER_TAG_ID}","confidence":0.9,"relatedRepos":[{"id":"repository-id","confidence":0.9}]}]}`,
         "",
         JSON.stringify({ threads: inputs }),
     ].join("\n");
@@ -284,7 +398,7 @@ function suggestionPrompt(inputs, candidateTags) {
         "Every tag needs: a stable lowercase kebab-case id, a concise label, a one-sentence classification description, and a distinct #RRGGBB color.",
         "Write labels and descriptions in the predominant language of the supplied threads. Use Korean when the threads are predominantly Korean.",
         `Always include "${OTHER_TAG_ID}" as the final fallback tag.`,
-        "Avoid tags for project paths or running status; those are managed separately.",
+        "Avoid tags for repositories or running status; those are managed separately.",
         "Prefer work-intent categories that will remain useful for future threads.",
         'Output shape: {"tags":[{"id":"feature","label":"Feature","description":"Implementation and product changes.","color":"#22c55e"}]}',
         candidateTags?.length
@@ -299,12 +413,30 @@ function suggestionPrompt(inputs, candidateTags) {
         })}` : "",
     ].filter(Boolean).join("\n");
 }
+function withCwdRelatedRepos(classification, input, repositories) {
+    const merged = new Map();
+    for (const relatedRepo of classification.relatedRepos) {
+        merged.set(relatedRepo.id, relatedRepo);
+    }
+    for (const relatedRepo of relatedReposFromCwd(input.cwd, repositories)) {
+        merged.set(relatedRepo.id, relatedRepo);
+    }
+    return {
+        ...classification,
+        relatedRepos: [...merged.values()]
+            .sort((left, right) => (Number(right.source === "cwd") - Number(left.source === "cwd")
+            || right.confidence - left.confidence
+            || left.label.localeCompare(right.label)))
+            .slice(0, MAX_RELATED_REPOS),
+    };
+}
 async function classifyThreads(args) {
     const config = await readConfig(args.workspaceRoot);
+    const repositories = await discoverWorkspaceRepositories(args.workspaceRoot);
     const classifications = new Map();
     const staleInputs = [];
     for (const input of args.inputs) {
-        const stored = args.force ? null : await readStoredTags(args.workspaceRoot, input, config);
+        const stored = args.force ? null : await readStoredTags(args.workspaceRoot, input, config, repositories);
         if (stored) {
             classifications.set(input.threadId, stored);
         }
@@ -317,17 +449,18 @@ async function classifyThreads(args) {
         try {
             const resultText = await runCodexTextTask({
                 manager: args.manager,
-                prompt: classifierPrompt(staleInputs, config.tags),
+                prompt: classifierPrompt(staleInputs, config.tags, repositories),
             });
-            const resolved = parseThreadTagClassificationResponse(resultText, new Set(staleInputs.map((input) => input.threadId)), new Set(config.tags.map((tag) => tag.id)));
+            const resolved = parseThreadTagClassificationResponse(resultText, new Set(staleInputs.map((input) => input.threadId)), new Set(config.tags.map((tag) => tag.id)), repositories);
             const inputsById = new Map(staleInputs.map((input) => [input.threadId, input]));
             await Promise.all(resolved.map(async (classification) => {
                 const input = inputsById.get(classification.threadId);
                 if (!input) {
                     return;
                 }
-                await writeStoredTags(args.workspaceRoot, input, classification, config);
-                classifications.set(classification.threadId, classification);
+                const completedClassification = withCwdRelatedRepos(classification, input, repositories);
+                await writeStoredTags(args.workspaceRoot, input, completedClassification, config, repositories);
+                classifications.set(classification.threadId, completedClassification);
             }));
             if (resolved.length !== staleInputs.length) {
                 classificationError = `AI classified ${resolved.length} of ${staleInputs.length} threads`;

package/dist/agent-thread-tags-rpc.test.js

@@ -1,6 +1,9 @@
 import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 import test from "node:test";
-import { parseSuggestedThreadTags, parseThreadTagClassificationResponse, } from "./agent-thread-tags-rpc.js";
+import { discoverWorkspaceRepositories, parseSuggestedThreadTags, parseThreadTagClassificationResponse, relatedReposFromCwd, } from "./agent-thread-tags-rpc.js";
 test("parses only requested valid thread tag assignments", () => {
     const result = parseThreadTagClassificationResponse(JSON.stringify({
         assignments: [
@@ -14,6 +17,7 @@ test("parses only requested valid thread tag assignments", () => {
             activityTag: "feature",
             confidence: 0.91,
             source: "ai",
+            relatedRepos: [],
         }]);
 });
 test("accepts fenced JSON and clamps confidence", () => {
@@ -24,6 +28,58 @@ test("accepts classifications from a custom configured range", () => {
     const result = parseThreadTagClassificationResponse("{\"assignments\":[{\"threadId\":\"a\",\"activityTag\":\"customer-request\",\"confidence\":0.8}]}", new Set(["a"]), new Set(["customer-request", "other"]));
     assert.equal(result[0]?.activityTag, "customer-request");
 });
+test("accepts only configured related repository ids", () => {
+    const repositories = [{
+            id: "doer",
+            label: "doer",
+            relativePath: "doer",
+            absolutePath: "/workspace/doer",
+        }];
+    const result = parseThreadTagClassificationResponse(JSON.stringify({
+        assignments: [{
+                threadId: "a",
+                activityTag: "feature",
+                confidence: 0.9,
+                relatedRepos: [
+                    { id: "doer", confidence: 0.82 },
+                    { id: "invented", confidence: 1 },
+                ],
+            }],
+    }), new Set(["a"]), new Set(["feature", "other"]), repositories);
+    assert.deepEqual(result[0]?.relatedRepos, [{
+            id: "doer",
+            label: "doer",
+            confidence: 0.82,
+            source: "ai",
+        }]);
+});
+test("uses the most specific repository containing cwd", () => {
+    const repositories = [
+        { id: ".", label: "workspace", relativePath: ".", absolutePath: "/workspace" },
+        { id: "doer", label: "doer", relativePath: "doer", absolutePath: "/workspace/doer" },
+    ];
+    assert.deepEqual(relatedReposFromCwd("/workspace/doer/src", repositories), [{
+            id: "doer",
+            label: "doer",
+            confidence: 1,
+            source: "cwd",
+        }]);
+});
+test("discovers the workspace root and immediate child git repositories", async () => {
+    const root = await mkdtemp(path.join(os.tmpdir(), "doer-thread-repos-"));
+    try {
+        await mkdir(path.join(root, ".git"));
+        await mkdir(path.join(root, "child", ".git"), { recursive: true });
+        await mkdir(path.join(root, "not-a-repo"), { recursive: true });
+        await mkdir(path.join(root, "worktree"), { recursive: true });
+        await writeFile(path.join(root, "worktree", ".git"), "gitdir: ../actual\n", "utf8");
+        const repositories = await discoverWorkspaceRepositories(root);
+        assert.deepEqual(repositories.map((repository) => repository.id).sort(), [".", "child", "worktree"]);
+    }
+    finally {
+        await rm(root, { recursive: true, force: true });
+    }
+});
 test("normalizes AI suggested tags and always adds other", () => {
     const result = parseSuggestedThreadTags(JSON.stringify({
         tags: [

package/dist/agent.js

@@ -7,7 +7,6 @@ import { handleFsRpcMessage } from "./agent-fs-rpc.js";
 import { handleGitRpcMessage } from "./agent-git-rpc.js";
 import { handleNotesRpcMessage } from "./agent-notes-rpc.js";
 import { subscribeToNotesAiRpc } from "./agent-notes-ai-rpc.js";
-import { subscribeToThreadTagsRpc } from "./agent-thread-tags-rpc.js";
 import { ensureBundledDoerSkills } from "./agent-bundled-skills.js";
 import { subscribeToCodexAppRpc } from "./agent-codex-app-rpc.js";
 import { createCodexAppServerManager } from "./codex-app-server-manager.js";
@@ -19,7 +18,7 @@ import { subscribeToSkillRpc } from "./agent-skill-rpc.js";
 import { subscribeToMaintenanceRpc } from "./agent-maintenance-rpc.js";
 import { subscribeToHttpProxyRpc } from "./agent-http-proxy-rpc.js";
 import { sendSignalToTaskProcess } from "./agent-task-execution.js";
-import { buildAgentCodexAppEventsSubject, buildAgentCodexAppRpcSubject, buildAgentDaemonRpcSubject, buildAgentFsRpcSubject, buildAgentGitRpcSubject, buildAgentHttpProxyRpcSubject, buildAgentMaintenanceRpcSubject, buildAgentNotesRpcSubject, buildAgentNotesAiRpcSubject, buildAgentThreadTagsRpcSubject, buildAgentSettingsRpcSubject, buildAgentSkillRpcSubject, formatLocalTimestamp, parseArgs, resolveAgentVersion, resolveArgOrEnv, resolveContainerReachableServerBaseUrl, sanitizeUserId, sleep, } from "./agent-runtime-utils.js";
+import { buildAgentCodexAppEventsSubject, buildAgentCodexAppRpcSubject, buildAgentDaemonRpcSubject, buildAgentFsRpcSubject, buildAgentGitRpcSubject, buildAgentHttpProxyRpcSubject, buildAgentMaintenanceRpcSubject, buildAgentNotesRpcSubject, buildAgentNotesAiRpcSubject, buildAgentSettingsRpcSubject, buildAgentSkillRpcSubject, formatLocalTimestamp, parseArgs, resolveAgentVersion, resolveArgOrEnv, resolveContainerReachableServerBaseUrl, sanitizeUserId, sleep, } 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";
@@ -310,15 +309,6 @@ async function main() {
                     agentId: initialAgentId,
                     codexAppServerManager,
                 });
-                subscribeToThreadTagsRpc({
-                    nc: jetstream.nc,
-                    subject: buildAgentThreadTagsRpcSubject(userId, initialAgentId),
-                    agentId: initialAgentId,
-                    workspaceRoot: resolveWorkspaceRoot(),
-                    manager: codexAppServerManager,
-                    onInfo: writeAgentInfo,
-                    onError: writeAgentError,
-                });
                 subscribeToDaemonRpc({
                     nc: jetstream.nc,
                     subject: buildAgentDaemonRpcSubject(userId, initialAgentId),

package/dist/codex-app-server-client.js

@@ -12,6 +12,16 @@ function resolveCodexCliBinPath() {
     }
     return path.resolve(path.dirname(packageJsonPath), codexBin);
 }
+export class CodexAppServerRequestError extends Error {
+    code;
+    data;
+    constructor(message, code = -32603, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = "CodexAppServerRequestError";
+    }
+}
 export class CodexAppServerClient {
     options;
     child = null;
@@ -20,10 +30,15 @@ export class CodexAppServerClient {
     startPromise = null;
     stopPromise = null;
     pending = new Map();
+    activeTurns = new Map();
+    activeTurnsChanged = new Set();
     constructor(options) {
         this.options = options;
     }
     async request(method, params, timeoutMs) {
+        if (this.stopPromise) {
+            throw new Error("Codex app-server is stopping");
+        }
         await this.start();
         return await this.requestStarted(method, params, timeoutMs);
     }
@@ -68,7 +83,9 @@ export class CodexAppServerClient {
         }
     }
     async startInner() {
-        this.child = spawn(process.execPath, [resolveCodexCliBinPath(), ...this.options.args], {
+        const executable = this.options.executable ?? process.execPath;
+        const executableArgs = this.options.executableArgs ?? [resolveCodexCliBinPath()];
+        this.child = spawn(executable, [...executableArgs, ...this.options.args], {
             cwd: this.options.cwd,
             detached: process.platform !== "win32",
             env: this.options.env,
@@ -91,6 +108,8 @@ export class CodexAppServerClient {
             removeExitHooks();
             this.signalProcessGroup(childPid, "SIGTERM");
             this.rejectPending(new Error("Codex app-server exited"));
+            this.activeTurns.clear();
+            this.notifyActiveTurnsChanged();
             this.stdoutLines?.close();
             this.stdoutLines = null;
             this.child = null;
@@ -144,6 +163,16 @@ export class CodexAppServerClient {
             return;
         }
         const record = message;
+        if (typeof record.method === "string") {
+            if (this.isRequestId(record.id)) {
+                void this.handleServerRequest(record.id, record.method, record.params);
+            }
+            else {
+                this.trackTurnNotification(record.method, record.params);
+                this.options.onNotification?.(record.method, record.params);
+            }
+            return;
+        }
         if (record.id !== undefined) {
             const id = Number(record.id);
             const pending = Number.isInteger(id) ? this.pending.get(id) : null;
@@ -161,8 +190,71 @@ export class CodexAppServerClient {
             }
             return;
         }
-        if (typeof record.method === "string") {
-            this.options.onNotification?.(record.method, record.params);
+    }
+    isRequestId(value) {
+        return (typeof value === "string" && value.length > 0)
+            || (typeof value === "number" && Number.isFinite(value));
+    }
+    async handleServerRequest(id, method, params) {
+        try {
+            if (!this.options.onServerRequest) {
+                throw new CodexAppServerRequestError(`Unsupported Codex app-server request: ${method}`, -32601);
+            }
+            const result = await this.options.onServerRequest(method, params);
+            this.writeMessage({ id, result });
+        }
+        catch (error) {
+            const requestError = error instanceof CodexAppServerRequestError
+                ? error
+                : new CodexAppServerRequestError(error instanceof Error ? error.message : String(error));
+            this.options.onLog?.(`[codex-app-server] server request failed method=${method} error=${requestError.message}`);
+            this.writeMessage({
+                id,
+                error: {
+                    code: requestError.code,
+                    message: requestError.message,
+                    ...(requestError.data === undefined ? {} : { data: requestError.data }),
+                },
+            });
+        }
+    }
+    writeMessage(message) {
+        const child = this.child;
+        if (!child || child.killed || child.stdin.destroyed) {
+            return;
+        }
+        child.stdin.write(`${JSON.stringify(message)}\n`, "utf8");
+    }
+    trackTurnNotification(method, params) {
+        if (method !== "turn/started" && method !== "turn/completed" && method !== "turn/interrupted") {
+            return;
+        }
+        const record = params && typeof params === "object" && !Array.isArray(params)
+            ? params
+            : null;
+        const turn = record?.turn && typeof record.turn === "object" && !Array.isArray(record.turn)
+            ? record.turn
+            : null;
+        const threadId = typeof record?.threadId === "string" ? record.threadId : "";
+        const turnId = typeof turn?.id === "string"
+            ? turn.id
+            : typeof record?.turnId === "string"
+                ? record.turnId
+                : "";
+        if (!threadId || !turnId) {
+            return;
+        }
+        if (method === "turn/started") {
+            this.activeTurns.set(threadId, turnId);
+        }
+        else if (this.activeTurns.get(threadId) === turnId) {
+            this.activeTurns.delete(threadId);
+        }
+        this.notifyActiveTurnsChanged();
+    }
+    notifyActiveTurnsChanged() {
+        for (const listener of this.activeTurnsChanged) {
+            listener();
         }
     }
     rejectPending(error) {
@@ -173,6 +265,7 @@ export class CodexAppServerClient {
         }
     }
     async stopChild(child) {
+        await this.interruptActiveTurns();
         const pid = child.pid;
         if (!pid) {
             child.kill("SIGTERM");
@@ -189,6 +282,42 @@ export class CodexAppServerClient {
             this.signalProcessGroup(pid, "SIGTERM");
         }
     }
+    async interruptActiveTurns() {
+        const turns = [...this.activeTurns.entries()].map(([threadId, turnId]) => ({ threadId, turnId }));
+        if (turns.length === 0) {
+            return;
+        }
+        this.options.onLog?.(`[codex-app-server] interrupting ${turns.length} active turn(s) before shutdown`);
+        await Promise.allSettled(turns.map(({ threadId, turnId }) => this.requestStarted("turn/interrupt", { threadId, turnId }, 5_000)));
+        const timeoutMs = this.options.gracefulShutdownTimeoutMs ?? 10_000;
+        const drained = await this.waitForTurnsToFinish(turns, timeoutMs);
+        if (!drained) {
+            this.options.onLog?.(`[codex-app-server] timed out waiting for active turns to finish before shutdown`);
+        }
+    }
+    async waitForTurnsToFinish(turns, timeoutMs) {
+        const isFinished = () => turns.every(({ threadId, turnId }) => this.activeTurns.get(threadId) !== turnId);
+        if (isFinished()) {
+            return true;
+        }
+        return await new Promise((resolve) => {
+            const onChanged = () => {
+                if (isFinished()) {
+                    cleanup();
+                    resolve(true);
+                }
+            };
+            const timer = setTimeout(() => {
+                cleanup();
+                resolve(false);
+            }, timeoutMs);
+            const cleanup = () => {
+                clearTimeout(timer);
+                this.activeTurnsChanged.delete(onChanged);
+            };
+            this.activeTurnsChanged.add(onChanged);
+        });
+    }
     registerProcessExitHooks(pid) {
         if (!pid || process.platform === "win32") {
             return () => { };
@@ -211,14 +340,15 @@ export class CodexAppServerClient {
         process.once("exit", cleanup);
         for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
             const handler = () => {
-                cleanup();
-                remove();
-                try {
-                    process.kill(process.pid, signal);
-                }
-                catch {
-                    process.exitCode = 1;
-                }
+                void this.stop().finally(() => {
+                    remove();
+                    try {
+                        process.kill(process.pid, signal);
+                    }
+                    catch {
+                        process.exitCode = 1;
+                    }
+                });
             };
             signalHandlers.set(signal, handler);
             process.once(signal, handler);

package/dist/codex-app-server-client.test.js

@@ -0,0 +1,91 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { CodexAppServerClient } from "./codex-app-server-client.js";
+const fixtureSource = String.raw `
+  const fs = require("node:fs");
+  const readline = require("node:readline");
+  const tracePath = process.env.DOER_CODEX_FIXTURE_TRACE;
+  const trace = (value) => fs.appendFileSync(tracePath, value + "\n");
+  const send = (value) => process.stdout.write(JSON.stringify(value) + "\n");
+  let waitingRequestId = null;
+  readline.createInterface({ input: process.stdin }).on("line", (line) => {
+    const message = JSON.parse(line);
+    if (message.method === "initialize") {
+      send({ id: message.id, result: {} });
+      return;
+    }
+    if (message.method === "test/server-request") {
+      waitingRequestId = message.id;
+      send({
+        id: "server-request-1",
+        method: "item/tool/call",
+        params: { tool: "fixture", arguments: {} },
+      });
+      return;
+    }
+    if (message.id === "server-request-1") {
+      trace("server-request-response");
+      send({ id: waitingRequestId, result: message.result });
+      return;
+    }
+    if (message.method === "test/start-turn") {
+      send({
+        method: "turn/started",
+        params: {
+          threadId: "thread-1",
+          turn: { id: "turn-1", status: "inProgress" },
+        },
+      });
+      send({ id: message.id, result: {} });
+      return;
+    }
+    if (message.method === "turn/interrupt") {
+      trace("turn-interrupt");
+      send({ id: message.id, result: {} });
+      send({
+        method: "turn/completed",
+        params: {
+          threadId: "thread-1",
+          turn: { id: "turn-1", status: "interrupted" },
+        },
+      });
+    }
+  });
+  process.on("SIGTERM", () => {
+    trace("sigterm");
+    process.exit(0);
+  });
+`;
+test("handles server requests and drains active turns before shutdown", async () => {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "doer-app-server-client-"));
+    const tracePath = path.join(tempDir, "trace.log");
+    const client = new CodexAppServerClient({
+        cwd: tempDir,
+        args: [],
+        executable: process.execPath,
+        executableArgs: ["--eval", fixtureSource],
+        env: {
+            ...process.env,
+            DOER_CODEX_FIXTURE_TRACE: tracePath,
+        },
+        gracefulShutdownTimeoutMs: 2_000,
+        onServerRequest: async (method, params) => {
+            assert.equal(method, "item/tool/call");
+            assert.deepEqual(params, { tool: "fixture", arguments: {} });
+            return { contentItems: [], success: true };
+        },
+    });
+    const serverRequestResult = await client.request("test/server-request");
+    assert.deepEqual(serverRequestResult, { contentItems: [], success: true });
+    await client.request("test/start-turn");
+    await client.stop();
+    const trace = (await readFile(tracePath, "utf8")).trim().split("\n");
+    assert.deepEqual(trace, [
+        "server-request-response",
+        "turn-interrupt",
+        "sigterm",
+    ]);
+});

package/dist/codex-app-server-manager.js

@@ -1,6 +1,6 @@
 import { buildAgentSettingsEnvPatch, readAgentModelInstructions, resolveAgentModelInstructionsFilePath, } from "./agent-settings.js";
 import { buildCustomMcpConfigArgs, buildDaemonMcpConfigArgs, buildMobileMcpConfigArgs, buildThreadsMcpConfigArgs, spawnManagedCodexCommand, } from "./agent-codex-cli.js";
-import { CodexAppServerClient } from "./codex-app-server-client.js";
+import { CodexAppServerClient, CodexAppServerRequestError, } from "./codex-app-server-client.js";
 import { startCodexChatBridge } from "./codex-chat-bridge.js";
 import { allocateMcpOauthCallbackPort, buildMcpOauthCallbackBaseUrl, relayMcpOauthCallbackToLocalListener, } from "./mcp-oauth-relay.js";
 function toTomlStringLiteral(value) {
@@ -12,6 +12,35 @@ function buildConfigArg(key, tomlValue) {
 function buildFeatureArg(enabled, name) {
     return [enabled ? "--enable" : "--disable", name];
 }
+function safeServerRequestResponse(method) {
+    switch (method) {
+        case "item/commandExecution/requestApproval":
+        case "item/fileChange/requestApproval":
+            return { decision: "decline" };
+        case "item/tool/requestUserInput":
+            return { answers: {} };
+        case "mcpServer/elicitation/request":
+            return { action: "decline", content: null, _meta: null };
+        case "item/permissions/requestApproval":
+            return { permissions: {}, scope: "turn" };
+        case "item/tool/call":
+            return {
+                contentItems: [{
+                        type: "inputText",
+                        text: "This client does not provide a handler for dynamic tools.",
+                    }],
+                success: false,
+            };
+        case "applyPatchApproval":
+        case "execCommandApproval":
+            return { decision: { denied: { rejection: "Client approval UI is unavailable." } } };
+        case "account/chatgptAuthTokens/refresh":
+        case "attestation/generate":
+            throw new CodexAppServerRequestError(`Unsupported Codex app-server request: ${method}`, -32601);
+        default:
+            throw new CodexAppServerRequestError(`Unknown Codex app-server request: ${method}`, -32601);
+    }
+}
 function resolveCodexModel(settings) {
     const providerKey = settings.codex.modelProvider || "openai";
     if (providerKey === "zai") {
@@ -143,6 +172,7 @@ export function createCodexAppServerManager(args) {
     let client = null;
     let providerProxy = null;
     let createPromise = null;
+    let lifecyclePromise = null;
     let mcpOauthCallbackPortPromise = null;
     let generation = 0;
     const notificationListeners = new Set();
@@ -189,6 +219,10 @@ export function createCodexAppServerManager(args) {
             args: appServerArgs,
             env,
             onLog: args.onLog,
+            onServerRequest: async (method) => {
+                args.onLog?.(`codex app-server server request method=${method} handled=safe-fallback`);
+                return safeServerRequestResponse(method);
+            },
             onNotification: (method, params) => {
                 for (const listener of notificationListeners) {
                     listener(method, params);
@@ -198,6 +232,9 @@ export function createCodexAppServerManager(args) {
         });
     };
     const getClient = async () => {
+        if (lifecyclePromise) {
+            await lifecyclePromise;
+        }
         if (client) {
             return client;
         }
@@ -238,6 +275,21 @@ export function createCodexAppServerManager(args) {
             args.onLog?.(`failed to stop provider proxy: ${error instanceof Error ? error.message : String(error)}`);
         });
     };
+    const scheduleRestart = async (reason) => {
+        if (lifecyclePromise) {
+            return await lifecyclePromise;
+        }
+        const pendingRestart = restartClient(reason);
+        lifecyclePromise = pendingRestart;
+        try {
+            await pendingRestart;
+        }
+        finally {
+            if (lifecyclePromise === pendingRestart) {
+                lifecyclePromise = null;
+            }
+        }
+    };
     const runMcpLogout = async (name) => {
         const settings = await args.readAgentSettingsConfig({ workspaceRoot: args.workspaceRoot });
         const server = settings.mcp.servers.find((candidate) => candidate.name === name && candidate.transport === "streamable_http");
@@ -304,7 +356,7 @@ export function createCodexAppServerManager(args) {
             await runMcpLogout(normalizedName);
         },
         async restart(reason) {
-            await restartClient(reason);
+            await scheduleRestart(reason);
         },
         async stop() {
             const activeClient = client;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doer-agent",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",