doer-agent 0.9.2 → 0.9.4

package/dist/agent-runtime-utils.js

@@ -28,6 +28,9 @@ 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

@@ -0,0 +1,428 @@
+import crypto from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { StringCodec } from "nats";
+import { runCodexTextTask } from "./codex-text-task.js";
+const codec = StringCodec();
+const MAX_THREADS_PER_CLASSIFICATION = 50;
+const MAX_THREADS_PER_REBUILD = 2_000;
+const MAX_TAGS = 12;
+const MIN_TAGS = 2;
+const OTHER_TAG_ID = "other";
+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" },
+    { id: "documentation", label: "Documentation", description: "Documentation, reports, notes, guides, or written content.", color: "#0ea5e9" },
+    { id: "research", label: "Research · review", description: "Investigation, audit, comparison, review, analysis, or planning.", color: "#14b8a6" },
+    { id: "feature", label: "Feature", description: "Implementation, feature work, UI/UX changes, or integrations.", color: "#22c55e" },
+    { id: "operations", label: "Operations", description: "Servers, daemons, infrastructure, databases, or maintenance.", color: "#f59e0b" },
+    { id: OTHER_TAG_ID, label: "Other", description: "Threads that do not fit any other configured tag.", color: "#64748b" },
+];
+let classificationQueue = Promise.resolve();
+function stringValue(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function nullableString(value) {
+    return stringValue(value) || null;
+}
+function recordValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function sanitizeThreadId(value) {
+    const sanitized = value.trim().replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 160);
+    if (!sanitized || sanitized === "." || sanitized === "..") {
+        throw new Error("Invalid thread id");
+    }
+    return sanitized;
+}
+function sanitizeTagId(value) {
+    return value
+        .trim()
+        .toLocaleLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 48);
+}
+function normalizedColor(value, fallback) {
+    const color = stringValue(value).toLocaleLowerCase();
+    return /^#[0-9a-f]{6}$/.test(color) ? color : fallback;
+}
+function tagsFilePath(workspaceRoot, threadId) {
+    return path.join(workspaceRoot, ".doer-agent", "threads", sanitizeThreadId(threadId), "tags.json");
+}
+function configFilePath(workspaceRoot) {
+    return path.join(workspaceRoot, ".doer-agent", "thread-tags", "config.json");
+}
+function normalizeInputs(value, limit) {
+    const rows = Array.isArray(value) ? value.slice(0, limit) : [];
+    const seen = new Set();
+    const inputs = [];
+    for (const rowValue of rows) {
+        const row = recordValue(rowValue);
+        const threadId = stringValue(row?.threadId).slice(0, 160);
+        if (!threadId || seen.has(threadId)) {
+            continue;
+        }
+        sanitizeThreadId(threadId);
+        seen.add(threadId);
+        inputs.push({
+            threadId,
+            label: stringValue(row?.label).slice(0, 500),
+            preview: nullableString(row?.preview)?.slice(0, 2_000) ?? null,
+            cwd: nullableString(row?.cwd)?.slice(0, 1_000) ?? null,
+        });
+    }
+    return inputs;
+}
+function normalizeTagDefinitions(value) {
+    const rows = Array.isArray(value) ? value.slice(0, MAX_TAGS) : [];
+    const seen = new Set();
+    const tags = [];
+    for (let index = 0; index < rows.length; index += 1) {
+        const row = recordValue(rows[index]);
+        const id = sanitizeTagId(stringValue(row?.id) || stringValue(row?.label));
+        const label = stringValue(row?.label).slice(0, 60);
+        const description = stringValue(row?.description).slice(0, 500);
+        if (!id || !label || !description || seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        tags.push({
+            id,
+            label,
+            description,
+            color: normalizedColor(row?.color, DEFAULT_TAGS[index % DEFAULT_TAGS.length]?.color ?? "#64748b"),
+        });
+    }
+    if (!seen.has(OTHER_TAG_ID)) {
+        if (tags.length >= MAX_TAGS) {
+            tags.pop();
+        }
+        tags.push({ ...DEFAULT_TAGS.find((tag) => tag.id === OTHER_TAG_ID) });
+    }
+    if (tags.length < MIN_TAGS) {
+        throw new Error(`At least ${MIN_TAGS} AI tags are required`);
+    }
+    return tags.slice(0, MAX_TAGS);
+}
+function configFingerprint(tags) {
+    return crypto.createHash("sha256").update(JSON.stringify(tags.map((tag) => ({
+        id: tag.id,
+        label: tag.label,
+        description: tag.description,
+        color: tag.color,
+    })))).digest("hex");
+}
+function publicConfig(config) {
+    return {
+        version: config.version,
+        tags: config.tags,
+        updatedAt: config.updatedAt,
+        source: config.source,
+        fingerprint: config.fingerprint,
+    };
+}
+async function readConfig(workspaceRoot) {
+    try {
+        const parsed = recordValue(JSON.parse(await readFile(configFilePath(workspaceRoot), "utf8")));
+        const tags = normalizeTagDefinitions(parsed?.tags);
+        return {
+            version: 1,
+            tags,
+            updatedAt: stringValue(parsed?.updatedAt) || new Date(0).toISOString(),
+            source: "file",
+            fingerprint: configFingerprint(tags),
+        };
+    }
+    catch {
+        const tags = DEFAULT_TAGS.map((tag) => ({ ...tag }));
+        return {
+            version: 1,
+            tags,
+            updatedAt: new Date(0).toISOString(),
+            source: "default",
+            fingerprint: configFingerprint(tags),
+        };
+    }
+}
+async function writeConfig(workspaceRoot, value) {
+    const tags = normalizeTagDefinitions(value);
+    const filePath = configFilePath(workspaceRoot);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    const payload = {
+        version: 1,
+        tags,
+        updatedAt: new Date().toISOString(),
+    };
+    await writeFile(tempPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+    await rename(tempPath, filePath);
+    return {
+        ...payload,
+        source: "file",
+        fingerprint: configFingerprint(tags),
+    };
+}
+function contentFingerprint(input) {
+    return crypto.createHash("sha256").update(JSON.stringify({
+        label: input.label,
+        preview: input.preview ?? "",
+        cwd: input.cwd ?? "",
+    })).digest("hex");
+}
+function boundedConfidence(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? Math.min(1, Math.max(0, value))
+        : 0.5;
+}
+function jsonObjectFromText(text) {
+    const trimmed = text.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "").trim();
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start < 0 || end < start) {
+        throw new Error("Thread tag AI task did not return JSON");
+    }
+    const payload = recordValue(JSON.parse(trimmed.slice(start, end + 1)));
+    if (!payload) {
+        throw new Error("Thread tag AI task returned an invalid object");
+    }
+    return payload;
+}
+export function parseThreadTagClassificationResponse(text, requestedThreadIds, allowedTagIds = new Set(DEFAULT_TAGS.map((tag) => tag.id))) {
+    const payload = jsonObjectFromText(text);
+    const assignments = Array.isArray(payload.assignments) ? payload.assignments : [];
+    const seen = new Set();
+    const results = [];
+    for (const assignmentValue of assignments) {
+        const assignment = recordValue(assignmentValue);
+        const threadId = stringValue(assignment?.threadId);
+        const activityTag = sanitizeTagId(stringValue(assignment?.activityTag));
+        if (!threadId ||
+            seen.has(threadId) ||
+            !requestedThreadIds.has(threadId) ||
+            !allowedTagIds.has(activityTag)) {
+            continue;
+        }
+        seen.add(threadId);
+        results.push({
+            threadId,
+            activityTag,
+            confidence: boundedConfidence(assignment?.confidence),
+            source: "ai",
+        });
+    }
+    return results;
+}
+export function parseSuggestedThreadTags(text) {
+    return normalizeTagDefinitions(jsonObjectFromText(text).tags);
+}
+async function readStoredTags(workspaceRoot, input, config) {
+    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) ||
+            stringValue(row?.threadId) !== input.threadId ||
+            stringValue(row?.contentFingerprint) !== contentFingerprint(input) ||
+            !allowedTagIds.has(activityTag)) {
+            return null;
+        }
+        return {
+            threadId: input.threadId,
+            activityTag,
+            confidence: boundedConfidence(row?.confidence),
+            source: "ai",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function writeStoredTags(workspaceRoot, input, classification, config) {
+    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,
+        threadId: input.threadId,
+        contentFingerprint: contentFingerprint(input),
+        configFingerprint: config.fingerprint,
+        activityTag: classification.activityTag,
+        confidence: classification.confidence,
+        source: "ai",
+        updatedAt: new Date().toISOString(),
+    };
+    await writeFile(tempPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+    await rename(tempPath, filePath);
+}
+function configuredTagsPrompt(tags) {
+    return tags.map((tag) => `- ${tag.id} (${tag.label}): ${tag.description}`);
+}
+function classifierPrompt(inputs, tags) {
+    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}]}`,
+        "",
+        JSON.stringify({ threads: inputs }),
+    ].join("\n");
+}
+function suggestionPrompt(inputs, candidateTags) {
+    return [
+        "Design a compact taxonomy for automatically classifying Codex threads inside Doer.",
+        "Return only one valid JSON object. Do not use Markdown fences or add explanations.",
+        "Create 5 to 9 mutually useful tags based on the supplied threads.",
+        "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.",
+        "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
+            ? `Consolidate these batch candidates into one taxonomy:\n${JSON.stringify(candidateTags)}`
+            : "",
+        inputs.length ? `Threads to inspect:\n${JSON.stringify({
+            threads: inputs.map((input) => ({
+                threadId: input.threadId,
+                label: input.label.slice(0, 300),
+                preview: input.preview?.slice(0, 500) ?? null,
+            })),
+        })}` : "",
+    ].filter(Boolean).join("\n");
+}
+async function classifyThreads(args) {
+    const config = await readConfig(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);
+        if (stored) {
+            classifications.set(input.threadId, stored);
+        }
+        else {
+            staleInputs.push(input);
+        }
+    }
+    let classificationError = null;
+    if (staleInputs.length > 0) {
+        try {
+            const resultText = await runCodexTextTask({
+                manager: args.manager,
+                prompt: classifierPrompt(staleInputs, config.tags),
+            });
+            const resolved = parseThreadTagClassificationResponse(resultText, new Set(staleInputs.map((input) => input.threadId)), new Set(config.tags.map((tag) => tag.id)));
+            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);
+            }));
+            if (resolved.length !== staleInputs.length) {
+                classificationError = `AI classified ${resolved.length} of ${staleInputs.length} threads`;
+            }
+        }
+        catch (error) {
+            classificationError = error instanceof Error ? error.message : String(error);
+        }
+    }
+    return {
+        classifications: [...classifications.values()],
+        classificationError,
+        config: publicConfig(config),
+    };
+}
+async function suggestConfig(args) {
+    if (args.inputs.length === 0) {
+        throw new Error("No threads available for AI tag reconstruction");
+    }
+    const candidates = [];
+    for (let offset = 0; offset < args.inputs.length; offset += 100) {
+        const batch = args.inputs.slice(offset, offset + 100);
+        const text = await runCodexTextTask({
+            manager: args.manager,
+            prompt: suggestionPrompt(batch),
+        });
+        candidates.push(...parseSuggestedThreadTags(text));
+    }
+    if (args.inputs.length <= 100) {
+        return candidates.slice(0, MAX_TAGS);
+    }
+    const consolidated = await runCodexTextTask({
+        manager: args.manager,
+        prompt: suggestionPrompt([], candidates),
+    });
+    return parseSuggestedThreadTags(consolidated);
+}
+async function handleThreadTagsRpcMessage(args) {
+    let request = {};
+    try {
+        request = JSON.parse(codec.decode(args.msg.data));
+        if (stringValue(request.agentId) !== args.agentId) {
+            throw new Error("Agent id mismatch");
+        }
+        const action = stringValue(request.action);
+        let result;
+        if (action === "get-config") {
+            result = { config: publicConfig(await readConfig(args.workspaceRoot)) };
+        }
+        else if (action === "save-config") {
+            result = { config: publicConfig(await writeConfig(args.workspaceRoot, request.tags)) };
+        }
+        else if (action === "suggest-config") {
+            result = {
+                suggestedTags: await suggestConfig({
+                    manager: args.manager,
+                    inputs: normalizeInputs(request.threads, MAX_THREADS_PER_REBUILD),
+                }),
+            };
+        }
+        else if (action === "classify") {
+            result = await classifyThreads({
+                workspaceRoot: args.workspaceRoot,
+                manager: args.manager,
+                inputs: normalizeInputs(request.threads, MAX_THREADS_PER_CLASSIFICATION),
+                force: request.force === true,
+            });
+        }
+        else {
+            throw new Error("Unsupported thread tags action");
+        }
+        args.msg.respond(codec.encode(JSON.stringify({
+            requestId: request.requestId,
+            ok: true,
+            ...result,
+        })));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        args.msg.respond(codec.encode(JSON.stringify({
+            requestId: request.requestId,
+            ok: false,
+            error: message,
+        })));
+        args.onError(`thread tags rpc failed error=${message}`);
+    }
+}
+export function subscribeToThreadTagsRpc(args) {
+    args.nc.subscribe(args.subject, {
+        callback: (error, msg) => {
+            if (error) {
+                args.onError(`thread tags rpc subscription error=${error.message}`);
+                return;
+            }
+            classificationQueue = classificationQueue.then(() => handleThreadTagsRpcMessage({ ...args, msg }), () => handleThreadTagsRpcMessage({ ...args, msg }));
+        },
+    });
+    args.onInfo(`thread tags rpc subscribed subject=${args.subject}`);
+}

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

@@ -0,0 +1,52 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { parseSuggestedThreadTags, parseThreadTagClassificationResponse, } from "./agent-thread-tags-rpc.js";
+test("parses only requested valid thread tag assignments", () => {
+    const result = parseThreadTagClassificationResponse(JSON.stringify({
+        assignments: [
+            { threadId: "a", activityTag: "feature", confidence: 0.91 },
+            { threadId: "b", activityTag: "invalid", confidence: 0.8 },
+            { threadId: "unknown", activityTag: "bug", confidence: 1 },
+        ],
+    }), new Set(["a", "b"]));
+    assert.deepEqual(result, [{
+            threadId: "a",
+            activityTag: "feature",
+            confidence: 0.91,
+            source: "ai",
+        }]);
+});
+test("accepts fenced JSON and clamps confidence", () => {
+    const result = parseThreadTagClassificationResponse("```json\n{\"assignments\":[{\"threadId\":\"a\",\"activityTag\":\"bug\",\"confidence\":2}]}\n```", new Set(["a"]));
+    assert.equal(result[0]?.confidence, 1);
+});
+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("normalizes AI suggested tags and always adds other", () => {
+    const result = parseSuggestedThreadTags(JSON.stringify({
+        tags: [
+            {
+                id: "Customer Request",
+                label: "고객 요청",
+                description: "고객이 요청한 제품 변경",
+                color: "#ABCDEF",
+            },
+        ],
+    }));
+    assert.deepEqual(result.map((tag) => tag.id), ["customer-request", "other"]);
+    assert.equal(result[0]?.color, "#abcdef");
+});
+test("keeps other when an oversized AI proposal omits it", () => {
+    const result = parseSuggestedThreadTags(JSON.stringify({
+        tags: Array.from({ length: 12 }, (_, index) => ({
+            id: `tag-${index}`,
+            label: `Tag ${index}`,
+            description: `Description ${index}`,
+            color: "#123456",
+        })),
+    }));
+    assert.equal(result.length, 12);
+    assert.equal(result.at(-1)?.id, "other");
+});

package/dist/agent.js

@@ -7,6 +7,7 @@ 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";
@@ -18,7 +19,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, buildAgentSettingsRpcSubject, buildAgentSkillRpcSubject, formatLocalTimestamp, parseArgs, resolveAgentVersion, resolveArgOrEnv, resolveContainerReachableServerBaseUrl, sanitizeUserId, sleep, } from "./agent-runtime-utils.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 { createRuntimeEnvHelpers } from "./agent-runtime-env.js";
 import { createEventPersistenceHelpers, heartbeatAgentSession, postJson, } from "./agent-runtime-io.js";
 import { handleSettingsRpcMessage } from "./agent-settings-rpc.js";
@@ -309,6 +310,15 @@ 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-text-task.js

@@ -0,0 +1,110 @@
+const DEFAULT_TIMEOUT_MS = 180_000;
+function stringValue(value) {
+    return typeof value === "string" ? value : "";
+}
+function recordValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function threadIdFromParams(params) {
+    const record = recordValue(params);
+    return stringValue(record?.threadId) || stringValue(recordValue(record?.thread)?.id);
+}
+function turnIdFromParams(params) {
+    const record = recordValue(params);
+    return stringValue(record?.turnId) || stringValue(recordValue(record?.turn)?.id);
+}
+function terminalErrorFromParams(params) {
+    const record = recordValue(params);
+    const error = recordValue(record?.error);
+    return stringValue(record?.message) || stringValue(error?.message) || stringValue(record?.reason);
+}
+function isTerminalTurnMethod(method) {
+    return method === "turn/completed" ||
+        method === "turn/failed" ||
+        method === "turn/error" ||
+        method === "turn/cancelled" ||
+        method === "turn/canceled" ||
+        method === "turn/interrupted" ||
+        method === "turn/aborted";
+}
+function buildCodexUserInput(prompt) {
+    return [{
+            type: "text",
+            text: prompt,
+            text_elements: [],
+        }];
+}
+export async function runCodexTextTask(args) {
+    let threadId = "";
+    let turnId = "";
+    let output = "";
+    let settled = false;
+    let cleanupNotification = () => { };
+    let settle = (_callback) => { };
+    const completed = new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            settle(() => reject(new Error("Timed out while waiting for Codex text task")));
+        }, args.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        settle = (callback) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            cleanupNotification();
+            callback();
+        };
+        cleanupNotification = args.manager.onNotification((method, params) => {
+            const eventThreadId = threadIdFromParams(params);
+            const eventTurnId = turnIdFromParams(params);
+            if ((!threadId || eventThreadId !== threadId) &&
+                (!turnId || eventTurnId !== turnId)) {
+                return;
+            }
+            if (turnId && eventTurnId && eventTurnId !== turnId) {
+                return;
+            }
+            if (method === "item/agentMessage/delta") {
+                const record = recordValue(params);
+                output += stringValue(record?.delta) || stringValue(record?.text);
+                return;
+            }
+            if (!isTerminalTurnMethod(method)) {
+                return;
+            }
+            if (method === "turn/completed") {
+                settle(resolve);
+                return;
+            }
+            const message = terminalErrorFromParams(params) || `Codex text task ended with ${method}`;
+            settle(() => reject(new Error(message)));
+        });
+    });
+    try {
+        const threadResult = recordValue(await args.manager.request("thread/start", {
+            cwd: null,
+            ephemeral: true,
+            sessionStartSource: "clear",
+        }, 30_000));
+        threadId = stringValue(recordValue(threadResult?.thread)?.id);
+        if (!threadId) {
+            throw new Error("Codex app-server did not return a text task thread id");
+        }
+        const turnResult = recordValue(await args.manager.request("turn/start", {
+            threadId,
+            input: buildCodexUserInput(args.prompt),
+        }, 30_000));
+        turnId = stringValue(recordValue(turnResult?.turn)?.id);
+        if (!turnId) {
+            throw new Error("Codex app-server did not return a text task turn id");
+        }
+        await completed.finally(() => cleanupNotification());
+        return output;
+    }
+    catch (error) {
+        settle(() => { });
+        throw error;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doer-agent",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",
@@ -26,8 +26,8 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@openai/codex": "^0.144.5",
-    "@openai/codex-sdk": "^0.144.5",
+    "@openai/codex": "^0.145.0",
+    "@openai/codex-sdk": "^0.145.0",
     "diff": "^9.0.0",
     "nats": "^2.29.3",
     "tar": "^7.5.15"