@hunsu/codex-runner 0.1.0

package/dist/index.js

@@ -0,0 +1,1780 @@
+import { createDefaultManagerConfig, createDefaultHarness, createDefaultMemberConfig, DEFAULT_TEAM_PROMPT, getHarnessMember, getHarnessMemberConfig, harnessSnapshotForTeam, memberConfigFromMemberEntity, renderPromptTemplate } from "@hunsu/protocol";
+import { delimiter, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { Buffer } from "node:buffer";
+export const DEFAULT_TEAM_INSTRUCTION = DEFAULT_TEAM_PROMPT;
+const GOAL_ASSIGNEE_OUTPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        executorId: { type: "string" },
+        goal: { type: "string" }
+    },
+    required: ["executorId", "goal"],
+    additionalProperties: false
+};
+const GOAL_EVALUATOR_OUTPUT_SCHEMA = {
+    type: ["object", "null"],
+    properties: {
+        executorId: { type: "string" },
+        prompt: { type: "string" }
+    },
+    required: ["executorId", "prompt"],
+    additionalProperties: false
+};
+const PATH_REQUIRES_OUTPUT_SCHEMA = {
+    type: ["string", "array"],
+    items: { type: "string" }
+};
+const GOAL_EXECUTION_PLAN_OUTPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        kind: { type: "string", enum: ["goal"] },
+        stage: { type: "string", enum: ["needs_evaluation"] },
+        id: { type: "string" },
+        assignee: GOAL_ASSIGNEE_OUTPUT_SCHEMA,
+        evaluator: GOAL_EVALUATOR_OUTPUT_SCHEMA,
+        remainingAttempts: {
+            type: "integer",
+            minimum: 0
+        },
+        requires: PATH_REQUIRES_OUTPUT_SCHEMA
+    },
+    required: ["kind", "stage", "id", "assignee", "evaluator", "remainingAttempts", "requires"],
+    additionalProperties: false
+};
+export const TEAM_EXECUTION_PLAN_SCHEMA = {
+    type: "object",
+    properties: {
+        kind: { type: "string", enum: ["queue"] },
+        id: { type: "string" },
+        items: {
+            type: "array",
+            items: GOAL_EXECUTION_PLAN_OUTPUT_SCHEMA
+        }
+    },
+    required: ["kind", "id", "items"],
+    additionalProperties: false
+};
+export const GOAL_EVALUATION_SCHEMA = {
+    type: "object",
+    properties: {
+        type: { type: "string", enum: ["pass", "fail"] },
+        summary: { type: "string" },
+        reason: { type: "string" },
+        feedback: { type: "string" },
+        nextGoal: { type: "string" },
+        evidence: { type: "array", items: { type: "string" } }
+    },
+    required: ["type", "summary", "reason", "feedback", "nextGoal", "evidence"],
+    additionalProperties: false
+};
+export const DEFAULT_CODEX_THREAD_OPTIONS = {
+    sandboxMode: "workspace-write",
+    approvalPolicy: "never",
+    approvalsReviewer: "user",
+    networkAccessEnabled: false
+};
+class RunnerEventBus {
+    subscribers = new Map();
+    push(event) {
+        const subscribers = this.subscribers.get(event.runId);
+        if (!subscribers) {
+            return;
+        }
+        for (const subscriber of subscribers) {
+            if (subscriber.closed) {
+                continue;
+            }
+            subscriber.queue.push(event);
+            subscriber.resolve?.();
+            subscriber.resolve = undefined;
+        }
+    }
+    close(runId) {
+        const subscribers = this.subscribers.get(runId);
+        if (!subscribers) {
+            return;
+        }
+        for (const subscriber of subscribers) {
+            subscriber.closed = true;
+            subscriber.resolve?.();
+            subscriber.resolve = undefined;
+        }
+    }
+    async *events(runId) {
+        const subscriber = { queue: [], closed: false };
+        let subscribers = this.subscribers.get(runId);
+        if (!subscribers) {
+            subscribers = new Set();
+            this.subscribers.set(runId, subscribers);
+        }
+        subscribers.add(subscriber);
+        try {
+            while (true) {
+                const event = subscriber.queue.shift();
+                if (event) {
+                    yield event;
+                    continue;
+                }
+                if (subscriber.closed) {
+                    return;
+                }
+                await new Promise(resolve => {
+                    subscriber.resolve = resolve;
+                });
+            }
+        }
+        finally {
+            subscribers.delete(subscriber);
+            if (subscribers.size === 0) {
+                this.subscribers.delete(runId);
+            }
+        }
+    }
+}
+class CodexAppServerRequestError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+    }
+}
+class CodexAppServerProcessTransport {
+    child;
+    stdout;
+    messageHandlers = new Set();
+    errorHandlers = new Set();
+    closeHandlers = new Set();
+    constructor(options) {
+        this.child = spawn(options.command, options.args, {
+            cwd: options.cwd,
+            env: createCodexEnvironment(options.environment)
+        });
+        this.stdout = createInterface({ input: this.child.stdout });
+        this.stdout.on("line", line => this.handleLine(line));
+        this.child.stderr.on("data", () => undefined);
+        this.child.once("error", error => this.emitError(error));
+        this.child.once("close", () => this.emitClose());
+    }
+    send(message) {
+        if (this.child.stdin.destroyed || !this.child.stdin.writable) {
+            throw new Error("Codex app-server stdin is closed");
+        }
+        this.child.stdin.write(`${JSON.stringify(message)}\n`);
+    }
+    close() {
+        this.stdout.close();
+        if (!this.child.killed) {
+            this.child.kill("SIGTERM");
+        }
+    }
+    onMessage(handler) {
+        this.messageHandlers.add(handler);
+        return () => this.messageHandlers.delete(handler);
+    }
+    onError(handler) {
+        this.errorHandlers.add(handler);
+        return () => this.errorHandlers.delete(handler);
+    }
+    onClose(handler) {
+        this.closeHandlers.add(handler);
+        return () => this.closeHandlers.delete(handler);
+    }
+    handleLine(line) {
+        if (!line.trim()) {
+            return;
+        }
+        try {
+            const message = JSON.parse(line);
+            for (const handler of this.messageHandlers) {
+                handler(message);
+            }
+        }
+        catch (error) {
+            this.emitError(new Error(`Invalid Codex app-server JSON-RPC message: ${error instanceof Error ? error.message : String(error)}`));
+        }
+    }
+    emitError(error) {
+        for (const handler of this.errorHandlers) {
+            handler(error);
+        }
+    }
+    emitClose() {
+        for (const handler of this.closeHandlers) {
+            handler();
+        }
+    }
+}
+export class CodexAppServerClient {
+    requestTimeoutMs;
+    transportFactory;
+    clientInfo;
+    serverRequestHandler;
+    transport;
+    startPromise;
+    initialized;
+    nextId = 1;
+    pending = new Map();
+    notificationHandlers = new Set();
+    constructor(options = {}) {
+        const environment = options.environment ?? {};
+        const command = options.command ?? "codex";
+        const args = options.args ?? ["app-server", "--stdio"];
+        this.requestTimeoutMs = options.requestTimeoutMs ?? 60_000;
+        this.clientInfo = options.clientInfo ?? { name: "hunsu-studio", title: "Hunsu Studio", version: "0.1.0" };
+        this.transportFactory = options.transportFactory ?? (() => new CodexAppServerProcessTransport({
+            command,
+            args,
+            environment,
+            cwd: options.cwd
+        }));
+        this.serverRequestHandler = options.handleServerRequest ?? defaultAppServerRequestHandler;
+    }
+    setServerRequestHandler(handler) {
+        this.serverRequestHandler = handler;
+    }
+    async initialize() {
+        await this.ensureStarted();
+        return this.initialized;
+    }
+    async request(method, params, options = {}) {
+        await this.ensureStarted();
+        return this.requestRaw(method, params, options.timeoutMs);
+    }
+    notify(method, params) {
+        this.transport?.send(params === undefined ? { method } : { method, params });
+    }
+    onNotification(handler) {
+        this.notificationHandlers.add(handler);
+        return () => this.notificationHandlers.delete(handler);
+    }
+    close() {
+        this.disposeTransport(new Error("Codex app-server client closed"), true);
+    }
+    async ensureStarted() {
+        if (this.transport && this.initialized) {
+            return;
+        }
+        if (this.startPromise) {
+            return this.startPromise;
+        }
+        this.startPromise = this.start();
+        try {
+            await this.startPromise;
+        }
+        finally {
+            this.startPromise = undefined;
+        }
+    }
+    async start() {
+        const transport = this.transportFactory();
+        this.transport = transport;
+        transport.onMessage(message => this.handleMessage(message));
+        transport.onError(error => this.disposeTransport(error, true));
+        transport.onClose(() => {
+            this.disposeTransport(new Error("Codex app-server process exited"), false);
+        });
+        this.initialized = await this.requestRaw("initialize", {
+            clientInfo: this.clientInfo,
+            capabilities: null
+        }, this.requestTimeoutMs);
+        this.notify("initialized");
+    }
+    requestRaw(method, params, timeoutMs = this.requestTimeoutMs) {
+        const transport = this.transport;
+        if (!transport) {
+            throw new Error("Codex app-server transport is not started");
+        }
+        const id = `hunsu-${this.nextId++}`;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                const error = new Error(`Codex app-server request timed out: ${method}`);
+                reject(error);
+                this.disposeTransport(error, true);
+            }, timeoutMs);
+            this.pending.set(id, { method, resolve, reject, timer });
+            try {
+                transport.send(params === undefined ? { id, method } : { id, method, params });
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    handleMessage(message) {
+        if (message.id !== undefined && (message.result !== undefined || message.error !== undefined) && !message.method) {
+            this.handleResponse(message);
+            return;
+        }
+        if (message.id !== undefined && typeof message.method === "string") {
+            void this.handleServerRequest(message);
+            return;
+        }
+        if (typeof message.method === "string") {
+            for (const handler of this.notificationHandlers) {
+                handler(message);
+            }
+        }
+    }
+    handleResponse(message) {
+        const pending = this.pending.get(message.id);
+        if (!pending) {
+            return;
+        }
+        clearTimeout(pending.timer);
+        this.pending.delete(message.id);
+        if (message.error) {
+            pending.reject(new Error(`Codex app-server ${pending.method} failed: ${message.error.message}`));
+            return;
+        }
+        pending.resolve(message.result);
+    }
+    async handleServerRequest(message) {
+        try {
+            const result = await this.serverRequestHandler(message);
+            this.transport?.send({ id: message.id, result });
+        }
+        catch (error) {
+            const requestError = error instanceof CodexAppServerRequestError
+                ? error
+                : new CodexAppServerRequestError(-32603, error instanceof Error ? error.message : String(error));
+            this.transport?.send({
+                id: message.id,
+                error: {
+                    code: requestError.code,
+                    message: requestError.message,
+                    data: requestError.data
+                }
+            });
+        }
+    }
+    rejectPending(error) {
+        for (const [id, pending] of this.pending) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+            this.pending.delete(id);
+        }
+    }
+    disposeTransport(error, closeTransport) {
+        const transport = this.transport;
+        this.transport = undefined;
+        this.initialized = undefined;
+        this.rejectPending(error);
+        if (closeTransport) {
+            transport?.close();
+        }
+    }
+}
+export class CodexAppServerRunner {
+    eventBus = new RunnerEventBus();
+    client;
+    threadOptions;
+    activeByRunId = new Map();
+    activeByThreadId = new Map();
+    activeByTurnId = new Map();
+    constructor(options = {}) {
+        this.threadOptions = {
+            ...DEFAULT_CODEX_THREAD_OPTIONS,
+            ...options.threadOptions
+        };
+        this.client = options.client ?? new CodexAppServerClient({
+            ...options.clientOptions,
+            environment: options.clientOptions?.environment ?? options.environment ?? {}
+        });
+        this.client.setServerRequestHandler(message => this.handleServerRequest(message));
+        this.client.onNotification(message => this.handleNotification(message));
+    }
+    async runTeamPlanning(input) {
+        const config = teamPlanningConfigFor(input);
+        return this.executeTurn(input, config, buildTeamPlanningPrompt(input), undefined, true, TEAM_EXECUTION_PLAN_SCHEMA);
+    }
+    async runMemberPath(input) {
+        const member = memberConfigFor(input, input.memberPath.executorId);
+        return this.executeTurn(input, member, buildMemberPathPrompt(input), undefined, false, input.outputSchema);
+    }
+    async runMoveFinalizer(input) {
+        const config = moveFinalizerConfigFor();
+        return this.executeTurn(input, config, buildMoveFinalizerPrompt(input), undefined, true);
+    }
+    async runHunsuDraftTurn(input) {
+        const config = hunsuDraftConfigFor(input.manager);
+        return this.executeTurn(input, config, buildHunsuDraftPrompt(input), input.providerThreadId, false, undefined, { reusePreparedThread: true });
+    }
+    async prepareHunsuDraftSession(input) {
+        const config = hunsuDraftConfigFor(input.manager);
+        const providerThreadId = await this.prepareThread(input, config, input.providerThreadId, false);
+        return {
+            runId: input.runId,
+            provider: "codex",
+            providerThreadId
+        };
+    }
+    async resumeRun(input) {
+        const config = teamPlanningConfigFor(input);
+        return this.executeTurn(input, config, buildTeamPlanningPrompt(input), input.providerThreadId, true, TEAM_EXECUTION_PLAN_SCHEMA);
+    }
+    async pauseRun(runId) {
+        this.eventBus.push({ type: "runner.status.changed", runId, phase: "waiting", headline: "Pause requested", detail: "Codex app-server will stop after the current turn boundary." });
+    }
+    async stopRun(runId) {
+        const active = this.activeByRunId.get(runId);
+        this.eventBus.push({ type: "runner.status.changed", runId, phase: "waiting", headline: "Stop requested" });
+        if (active?.threadId && active.turnId) {
+            try {
+                await this.client.request("turn/interrupt", { threadId: active.threadId, turnId: active.turnId }, { timeoutMs: 10_000 });
+            }
+            catch (error) {
+                this.eventBus.push({ type: "runner.error", runId, error: `Codex app-server interrupt failed: ${error instanceof Error ? error.message : String(error)}` });
+            }
+            active.completed = true;
+            active.reject(new Error("Codex turn interrupted by Studio"));
+            return;
+        }
+        if (active) {
+            active.completed = true;
+            this.client.close();
+            active.reject(new Error("Codex turn interrupted by Studio before app-server returned a turn id"));
+            return;
+        }
+        this.eventBus.close(runId);
+    }
+    async providerStatus() {
+        try {
+            const initialized = await this.client.initialize();
+            const status = { backend: "app-server", available: true, initialized };
+            try {
+                status.account = await this.client.request("account/read", { refreshToken: false });
+            }
+            catch (error) {
+                status.accountError = error instanceof Error ? error.message : String(error);
+            }
+            try {
+                status.rateLimits = await this.client.request("account/rateLimits/read");
+            }
+            catch (error) {
+                status.rateLimitsError = error instanceof Error ? error.message : String(error);
+            }
+            const errors = [status.accountError, status.rateLimitsError].filter(Boolean);
+            if (errors.length > 0) {
+                status.error = errors.join("; ");
+            }
+            return status;
+        }
+        catch (error) {
+            return { backend: "app-server", available: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    events(runId) {
+        return this.eventBus.events(runId);
+    }
+    async executeTurn(input, config, prompt, providerThreadId, readOnly = false, outputSchema, options = {}) {
+        const shouldReusePreparedThread = options.reusePreparedThread === true && providerThreadId !== undefined && !outputSchema;
+        try {
+            const threadId = shouldReusePreparedThread
+                ? providerThreadId
+                : await this.prepareThread(input, config, providerThreadId, readOnly, outputSchema);
+            if (shouldReusePreparedThread) {
+                this.eventBus.push({
+                    type: "runner.status.changed",
+                    runId: input.runId,
+                    phase: "working",
+                    headline: "Prepared thread reused",
+                    detail: threadId,
+                    providerThreadId: threadId
+                });
+            }
+            try {
+                return await this.startTurn(input, config, threadId, prompt, readOnly, outputSchema);
+            }
+            catch (error) {
+                if (!shouldReusePreparedThread) {
+                    throw error;
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                this.eventBus.push({
+                    type: "runner.status.changed",
+                    runId: input.runId,
+                    phase: "working",
+                    headline: "Prepared thread reuse failed",
+                    detail: message,
+                    providerThreadId
+                });
+                const resumedThreadId = await this.prepareThread(input, config, providerThreadId, readOnly, outputSchema);
+                return await this.startTurn(input, config, resumedThreadId, prompt, readOnly, outputSchema);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.eventBus.push({ type: "runner.error", runId: input.runId, error: message });
+            throw error;
+        }
+        finally {
+            this.eventBus.close(input.runId);
+        }
+    }
+    async startTurn(input, config, threadId, prompt, readOnly, outputSchema) {
+        let active;
+        try {
+            return await new Promise((resolve, reject) => {
+                active = {
+                    runId: input.runId,
+                    threadId,
+                    rawEvents: [],
+                    activeCommandExecutionIds: new Set(),
+                    backgroundTerminalCleanupRequested: false,
+                    finalEmitted: false,
+                    completed: false,
+                    resolve,
+                    reject
+                };
+                this.trackActiveTurn(active);
+                this.client.request("turn/start", this.turnStartParamsFor(input, config, threadId, prompt, readOnly, outputSchema), { timeoutMs: 60_000 })
+                    .then(turnResponse => {
+                    const turn = readRecord(turnResponse, "turn");
+                    if (!active || active.completed) {
+                        return;
+                    }
+                    const turnId = readString(turn, "id");
+                    if (turnId) {
+                        this.setActiveTurnId(active, turnId);
+                    }
+                    if (turn && readString(turn, "status") !== "inProgress") {
+                        this.completeActiveTurn(active, turn);
+                    }
+                })
+                    .catch(error => {
+                    if (!active?.completed) {
+                        reject(error instanceof Error ? error : new Error(String(error)));
+                    }
+                });
+            });
+        }
+        finally {
+            if (active) {
+                this.untrackActiveTurn(active);
+            }
+        }
+    }
+    async prepareThread(input, config, providerThreadId, readOnly, outputSchema) {
+        const threadResponse = providerThreadId
+            ? await this.client.request("thread/resume", this.threadResumeParamsFor(input, config, providerThreadId, readOnly))
+            : await this.client.request("thread/start", this.threadStartParamsFor(input, config, readOnly));
+        const threadId = readNestedString(threadResponse, ["thread", "id"]) ?? providerThreadId;
+        if (!threadId) {
+            throw new Error("Codex app-server did not return a thread id");
+        }
+        this.eventBus.push({
+            type: "runner.status.changed",
+            runId: input.runId,
+            phase: "working",
+            headline: "Thread ready",
+            detail: threadId,
+            providerThreadId: threadId
+        });
+        if (outputSchema) {
+            await this.client.request("thread/goal/clear", { threadId }, { timeoutMs: 60_000 });
+            this.eventBus.push({
+                type: "runner.status.changed",
+                runId: input.runId,
+                phase: "working",
+                headline: "Provider goal cleared",
+                providerThreadId: threadId
+            });
+        }
+        else {
+            await this.client.request("thread/goal/set", this.threadGoalSetParamsFor(input, config, threadId), { timeoutMs: 60_000 });
+            this.eventBus.push({
+                type: "runner.status.changed",
+                runId: input.runId,
+                phase: "working",
+                headline: "Provider goal set",
+                providerThreadId: threadId
+            });
+        }
+        return threadId;
+    }
+    threadStartParamsFor(input, config, readOnly) {
+        const options = this.effectiveThreadOptions(input, config, readOnly);
+        return {
+            cwd: input.repositoryPath,
+            approvalPolicy: options.approvalPolicy,
+            approvalsReviewer: options.approvalsReviewer ?? "user",
+            sandbox: options.sandboxMode,
+            model: options.model ?? null,
+            serviceTier: config.serviceTier === "fast" ? "fast" : null,
+            ephemeral: false,
+            threadSource: "user"
+        };
+    }
+    threadResumeParamsFor(input, config, providerThreadId, readOnly) {
+        const options = this.effectiveThreadOptions(input, config, readOnly);
+        return {
+            threadId: providerThreadId,
+            cwd: input.repositoryPath,
+            approvalPolicy: options.approvalPolicy,
+            approvalsReviewer: options.approvalsReviewer ?? "user",
+            sandbox: options.sandboxMode,
+            model: options.model ?? null,
+            serviceTier: config.serviceTier === "fast" ? "fast" : null
+        };
+    }
+    threadGoalSetParamsFor(input, config, threadId) {
+        return {
+            threadId,
+            objective: renderProviderGoal(input, config)
+        };
+    }
+    turnStartParamsFor(input, config, threadId, prompt, readOnly, outputSchema) {
+        const options = this.effectiveThreadOptions(input, config, readOnly);
+        return {
+            threadId,
+            input: [{ type: "text", text: prompt, text_elements: [] }],
+            cwd: input.repositoryPath,
+            approvalPolicy: options.approvalPolicy,
+            approvalsReviewer: options.approvalsReviewer ?? "user",
+            sandboxPolicy: appServerSandboxPolicyFor(input.repositoryPath, options, readOnly),
+            model: options.model ?? null,
+            serviceTier: config.serviceTier === "fast" ? "fast" : null,
+            effort: options.modelReasoningEffort ?? null,
+            outputSchema: outputSchema ?? null
+        };
+    }
+    effectiveThreadOptions(input, config, readOnly) {
+        const memberOptions = threadOptionsForMember(config);
+        const options = {
+            ...this.threadOptions,
+            ...input.codexThreadOptions,
+            ...memberOptions
+        };
+        if (readOnly) {
+            options.networkAccessEnabled = input.codexThreadOptions?.networkAccessEnabled ?? this.threadOptions.networkAccessEnabled ?? memberOptions.networkAccessEnabled;
+            options.sandboxMode = "read-only";
+            options.approvalPolicy = "never";
+            options.approvalsReviewer = "user";
+        }
+        return options;
+    }
+    handleNotification(message) {
+        const active = activeTurnForMessage(message, this.activeByThreadId, this.activeByTurnId);
+        if (!active) {
+            return;
+        }
+        active.rawEvents.push(rawCodexEvent(message));
+        const params = isRecord(message.params) ? message.params : {};
+        const messageTurnId = readString(params, "turnId") ?? readNestedString(params, ["turn", "id"]);
+        this.eventBus.push({
+            type: "runner.appServer.message",
+            runId: active.runId,
+            direction: "server-notification",
+            providerThreadId: active.threadId,
+            providerTurnId: messageTurnId ?? active.turnId,
+            method: message.method,
+            message
+        });
+        if (messageTurnId && messageTurnId !== active.turnId) {
+            this.setActiveTurnId(active, messageTurnId);
+        }
+        if (message.method === "item/started" || message.method === "item/completed") {
+            this.trackCommandExecutionItem(active, message.method, readRecord(params, "item"));
+        }
+        const effects = interpretAppServerNotification({
+            runId: active.runId,
+            providerThreadId: active.threadId,
+            providerTurnId: messageTurnId ?? active.turnId
+        }, message);
+        for (const effect of effects) {
+            switch (effect.kind) {
+                case "setTurnId":
+                    this.setActiveTurnId(active, effect.turnId);
+                    break;
+                case "usage":
+                    active.usage = effect.usage;
+                    break;
+                case "teamEvent":
+                    this.eventBus.push(effect.event);
+                    break;
+                case "finalResponse":
+                    active.finalResponse = effect.finalResponse;
+                    this.requestBackgroundTerminalCleanupIfNeeded(active);
+                    break;
+                case "completeTurn":
+                    this.completeActiveTurn(active, effect.turn);
+                    break;
+            }
+        }
+    }
+    trackCommandExecutionItem(active, method, item) {
+        if (readString(item, "type") !== "commandExecution") {
+            return;
+        }
+        const itemId = appServerItemId(item);
+        if (!itemId) {
+            return;
+        }
+        const status = readString(item, "status");
+        if (method === "item/completed" || status === "completed" || status === "failed" || status === "declined") {
+            active.activeCommandExecutionIds.delete(itemId);
+            return;
+        }
+        active.activeCommandExecutionIds.add(itemId);
+    }
+    requestBackgroundTerminalCleanupIfNeeded(active) {
+        if (active.backgroundTerminalCleanupRequested || active.activeCommandExecutionIds.size === 0) {
+            return;
+        }
+        active.backgroundTerminalCleanupRequested = true;
+        void this.client.request("thread/backgroundTerminals/clean", { threadId: active.threadId }, { timeoutMs: 10_000 }).catch(() => undefined);
+    }
+    completeActiveTurn(active, turn) {
+        if (active.completed) {
+            return;
+        }
+        active.completed = true;
+        const turnId = readString(turn, "id") ?? active.turnId;
+        if (turnId) {
+            this.setActiveTurnId(active, turnId);
+        }
+        const status = readString(turn, "status");
+        if (status === "failed") {
+            const error = readRecord(turn, "error");
+            const message = readString(error, "message") ?? "Codex app-server turn failed";
+            this.eventBus.push({ type: "runner.error", runId: active.runId, error: message });
+            active.reject(new Error(message));
+            return;
+        }
+        if (status === "interrupted") {
+            active.reject(new Error("Codex app-server turn interrupted"));
+            return;
+        }
+        const finalResponse = active.finalResponse ?? finalResponseFromAppServerTurn(turn);
+        if (finalResponse && !active.finalEmitted) {
+            active.finalEmitted = true;
+            this.eventBus.push({ type: "runner.final", runId: active.runId, finalResponse });
+        }
+        active.resolve({
+            runId: active.runId,
+            provider: "codex",
+            providerThreadId: active.threadId,
+            providerTurnId: active.turnId,
+            finalResponse,
+            rawResult: {
+                rawEvents: active.rawEvents,
+                finalResponse,
+                usage: active.usage,
+                turn
+            }
+        });
+    }
+    trackActiveTurn(active) {
+        this.activeByRunId.set(active.runId, active);
+        this.activeByThreadId.set(active.threadId, active);
+        if (active.turnId) {
+            this.activeByTurnId.set(active.turnId, active);
+        }
+    }
+    setActiveTurnId(active, turnId) {
+        if (active.turnId && active.turnId !== turnId) {
+            this.activeByTurnId.delete(active.turnId);
+        }
+        active.turnId = turnId;
+        this.activeByTurnId.set(turnId, active);
+    }
+    untrackActiveTurn(active) {
+        this.activeByRunId.delete(active.runId);
+        this.activeByThreadId.delete(active.threadId);
+        if (active.turnId) {
+            this.activeByTurnId.delete(active.turnId);
+        }
+    }
+    async handleServerRequest(message) {
+        const params = isRecord(message.params) ? message.params : {};
+        const active = activeTurnForMessage(message, this.activeByThreadId, this.activeByTurnId);
+        active?.rawEvents.push(rawCodexEvent(message));
+        const runId = active?.runId;
+        if (runId) {
+            this.eventBus.push({
+                type: "runner.appServer.message",
+                runId,
+                direction: "server-request",
+                providerThreadId: active?.threadId,
+                providerTurnId: active?.turnId,
+                method: message.method,
+                message
+            });
+        }
+        const approvalSummary = appServerApprovalSummary(message.method, params);
+        if (runId && approvalSummary) {
+            this.eventBus.push({ type: "runner.status.changed", runId, phase: "waiting", headline: "Approval requested", detail: approvalSummary, providerThreadId: active?.threadId, providerTurnId: active?.turnId });
+        }
+        if (message.method === "item/permissions/requestApproval") {
+            if (active?.threadId && active.turnId) {
+                void this.client.request("turn/interrupt", { threadId: active.threadId, turnId: active.turnId }, { timeoutMs: 10_000 }).catch(() => undefined);
+            }
+            if (runId) {
+                this.eventBus.push({ type: "runner.error", runId, error: "Codex app-server requested additional permissions; Hunsu declined and interrupted the turn." });
+            }
+            if (active && !active.completed) {
+                active.completed = true;
+                active.reject(new Error("Codex app-server requested additional permissions; Hunsu declined and interrupted the turn."));
+            }
+        }
+        return defaultAppServerRequestHandler(message);
+    }
+}
+export function createDefaultCodexRunner(options = {}) {
+    return new CodexAppServerRunner(options);
+}
+function defaultAppServerRequestHandler(message) {
+    switch (message.method) {
+        case "item/commandExecution/requestApproval":
+            return { decision: "decline" };
+        case "item/fileChange/requestApproval":
+            return { decision: "decline" };
+        case "execCommandApproval":
+        case "applyPatchApproval":
+            return { decision: "denied" };
+        case "item/permissions/requestApproval":
+            return { permissions: {}, scope: "turn", strictAutoReview: true };
+        default:
+            throw new CodexAppServerRequestError(-32601, `Unsupported Codex app-server request: ${message.method ?? "unknown"}`);
+    }
+}
+function appServerSandboxPolicyFor(repositoryPath, options, readOnly) {
+    const networkAccess = options.networkAccessEnabled === true;
+    if (readOnly || options.sandboxMode === "read-only") {
+        return { type: "readOnly", networkAccess };
+    }
+    if (options.sandboxMode === "danger-full-access") {
+        return { type: "dangerFullAccess", networkAccess };
+    }
+    return {
+        type: "workspaceWrite",
+        writableRoots: [repositoryPath],
+        networkAccess,
+        excludeTmpdirEnvVar: false,
+        excludeSlashTmp: false
+    };
+}
+function activeTurnForMessage(message, byThreadId, byTurnId) {
+    const params = isRecord(message.params) ? message.params : {};
+    const turnId = readString(params, "turnId") ?? readNestedString(params, ["turn", "id"]);
+    if (turnId) {
+        const active = byTurnId.get(turnId);
+        if (active) {
+            return active;
+        }
+    }
+    const threadId = readString(params, "threadId") ?? readNestedString(params, ["thread", "id"]);
+    return threadId ? byThreadId.get(threadId) : undefined;
+}
+function rawCodexEvent(message) {
+    return { source: "codex.app-server", message };
+}
+function interpretAppServerNotification(context, message) {
+    const params = isRecord(message.params) ? message.params : {};
+    switch (message.method) {
+        case "turn/started": {
+            const turn = readRecord(params, "turn");
+            const turnId = readString(turn, "id") ?? readString(params, "turnId") ?? context.providerTurnId ?? "turn";
+            return [
+                ...(turnId ? [{ kind: "setTurnId", turnId }] : []),
+                {
+                    kind: "teamEvent",
+                    event: {
+                        type: "runner.turn.started",
+                        runId: context.runId,
+                        providerThreadId: context.providerThreadId,
+                        providerTurnId: turnId,
+                        turn,
+                        startedAtMs: readNumber(params, "startedAtMs")
+                    }
+                },
+                {
+                    kind: "teamEvent",
+                    event: {
+                        type: "runner.status.changed",
+                        runId: context.runId,
+                        phase: "working",
+                        headline: "Working",
+                        detail: turnId,
+                        providerThreadId: context.providerThreadId,
+                        providerTurnId: turnId
+                    }
+                }
+            ];
+        }
+        case "turn/completed": {
+            const turn = readRecord(params, "turn");
+            const turnId = readString(turn, "id") ?? readString(params, "turnId") ?? context.providerTurnId;
+            return [
+                {
+                    kind: "teamEvent",
+                    event: {
+                        type: "runner.turn.completed",
+                        runId: context.runId,
+                        providerThreadId: context.providerThreadId,
+                        providerTurnId: turnId,
+                        turn,
+                        completedAtMs: readNumber(params, "completedAtMs")
+                    }
+                },
+                { kind: "completeTurn", turn }
+            ];
+        }
+        case "thread/tokenUsage/updated": {
+            const usage = appServerUsageFromNotification(params);
+            return [
+                { kind: "usage", usage },
+                {
+                    kind: "teamEvent",
+                    event: {
+                        type: "runner.status.changed",
+                        runId: context.runId,
+                        phase: "working",
+                        headline: "Working",
+                        detail: formatAppServerUsage(usage),
+                        providerThreadId: context.providerThreadId,
+                        providerTurnId: context.providerTurnId
+                    }
+                }
+            ];
+        }
+        case "item/started":
+        case "item/completed":
+            return mapAppServerThreadItemEvent(context, message.method, readRecord(params, "item"));
+        case "item/agentMessage/delta":
+        case "item/agentMessage/textDelta":
+        case "item/agentMessage/outputDelta":
+        case "item/assistantMessage/delta":
+        case "item/assistantMessage/textDelta":
+        case "item/assistantMessage/outputDelta": {
+            const delta = readDeltaText(params);
+            if (!delta) {
+                return [];
+            }
+            const itemId = appServerItemId(params) ?? "agentMessage";
+            const providerTurnId = readString(params, "turnId") ?? context.providerTurnId;
+            return [{
+                    kind: "teamEvent",
+                    event: {
+                        type: "runner.item.delta",
+                        runId: context.runId,
+                        providerThreadId: context.providerThreadId,
+                        providerTurnId,
+                        itemId,
+                        deltaKind: "agentMessage",
+                        delta
+                    }
+                }];
+        }
+        case "item/commandExecution/outputDelta":
+        case "item/fileChange/outputDelta":
+        case "item/plan/delta":
+        case "item/reasoning/textDelta":
+        case "item/reasoning/summaryTextDelta": {
+            const delta = readDeltaText(params);
+            if (!delta) {
+                return [];
+            }
+            const deltaKind = appServerDeltaKind(message.method);
+            const itemId = appServerItemId(params) ?? deltaKind;
+            const providerTurnId = readString(params, "turnId") ?? context.providerTurnId;
+            return [{
+                    kind: "teamEvent",
+                    event: {
+                        type: "runner.item.delta",
+                        runId: context.runId,
+                        providerThreadId: context.providerThreadId,
+                        providerTurnId,
+                        itemId,
+                        deltaKind,
+                        delta,
+                        contentIndex: readNumber(params, "contentIndex")
+                    }
+                }];
+        }
+        case "turn/plan/updated": {
+            const explanation = readString(params, "explanation");
+            return [{
+                    kind: "teamEvent",
+                    event: {
+                        type: "runner.status.changed",
+                        runId: context.runId,
+                        phase: "thinking",
+                        headline: "Planning",
+                        detail: explanation ? truncateText(explanation, 500) : "Codex plan updated.",
+                        providerThreadId: context.providerThreadId,
+                        providerTurnId: context.providerTurnId
+                    }
+                }];
+        }
+        case "error": {
+            const error = readRecord(params, "error");
+            return [{
+                    kind: "teamEvent",
+                    event: { type: "runner.error", runId: context.runId, error: readString(error, "message") ?? "Codex app-server error" }
+                }];
+        }
+        default:
+            return [];
+    }
+}
+function appServerUsageFromNotification(params) {
+    const usage = readRecord(params, "tokenUsage");
+    const last = readRecord(usage, "last");
+    if (!last) {
+        return undefined;
+    }
+    return {
+        input_tokens: readNumber(last, "inputTokens") ?? 0,
+        cached_input_tokens: readNumber(last, "cachedInputTokens") ?? 0,
+        output_tokens: readNumber(last, "outputTokens") ?? 0,
+        reasoning_output_tokens: readNumber(last, "reasoningOutputTokens") ?? 0
+    };
+}
+function formatAppServerUsage(usage) {
+    if (!usage) {
+        return "Codex app-server usage updated.";
+    }
+    return `Codex turn usage. Input ${usage.input_tokens}, output ${usage.output_tokens}, reasoning ${usage.reasoning_output_tokens}.`;
+}
+function appServerApprovalSummary(method, params) {
+    switch (method) {
+        case "item/commandExecution/requestApproval":
+            return `Codex app-server requested command approval; Hunsu declined: ${readString(params, "command") ?? "unknown command"}`;
+        case "item/fileChange/requestApproval":
+            return `Codex app-server requested file-change approval; Hunsu declined${readString(params, "grantRoot") ? ` for ${readString(params, "grantRoot")}` : ""}.`;
+        case "item/permissions/requestApproval":
+            return "Codex app-server requested additional permissions; Hunsu declined.";
+        case "execCommandApproval":
+            return `Codex app-server requested command approval; Hunsu declined: ${params.command?.join(" ") ?? "unknown command"}`;
+        case "applyPatchApproval":
+            return "Codex app-server requested patch approval; Hunsu declined.";
+        default:
+            return undefined;
+    }
+}
+function mapAppServerThreadItemEvent(context, method, item) {
+    const phase = method === "item/started" ? "started" : "completed";
+    const normalized = normalizeAppServerThreadItem(item);
+    if (!normalized) {
+        return [];
+    }
+    const itemId = normalized.id ?? appServerItemId(item) ?? normalized.type;
+    const lifecycleEffect = {
+        kind: "teamEvent",
+        event: phase === "started"
+            ? {
+                type: "runner.item.started",
+                runId: context.runId,
+                providerThreadId: context.providerThreadId,
+                providerTurnId: context.providerTurnId,
+                itemId,
+                item: normalized
+            }
+            : {
+                type: "runner.item.completed",
+                runId: context.runId,
+                providerThreadId: context.providerThreadId,
+                providerTurnId: context.providerTurnId,
+                itemId,
+                item: normalized
+            }
+    };
+    switch (normalized.type) {
+        case "agentMessage": {
+            const text = normalized.text;
+            if (phase !== "completed" || !text) {
+                return [lifecycleEffect];
+            }
+            return [
+                lifecycleEffect,
+                { kind: "finalResponse", finalResponse: text }
+            ];
+        }
+        case "reasoning": {
+            return [lifecycleEffect];
+        }
+        case "plan": {
+            return [lifecycleEffect];
+        }
+        case "commandExecution": {
+            return [lifecycleEffect];
+        }
+        case "fileChange": {
+            return [lifecycleEffect];
+        }
+        case "mcpToolCall": {
+            return [lifecycleEffect];
+        }
+        case "webSearch": {
+            return [lifecycleEffect];
+        }
+        default:
+            return [lifecycleEffect];
+    }
+}
+function appServerDeltaKind(method) {
+    switch (method) {
+        case "item/agentMessage/delta":
+        case "item/agentMessage/textDelta":
+        case "item/agentMessage/outputDelta":
+        case "item/assistantMessage/delta":
+        case "item/assistantMessage/textDelta":
+        case "item/assistantMessage/outputDelta":
+            return "agentMessage";
+        case "item/plan/delta":
+            return "plan";
+        case "item/reasoning/textDelta":
+            return "reasoningText";
+        case "item/reasoning/summaryTextDelta":
+            return "reasoningSummary";
+        case "item/fileChange/outputDelta":
+            return "fileChangeOutput";
+        case "item/commandExecution/outputDelta":
+        default:
+            return "commandOutput";
+    }
+}
+function normalizeAppServerThreadItem(item) {
+    const type = readString(item, "type");
+    if (!item || !type) {
+        return undefined;
+    }
+    const normalized = {
+        id: appServerItemId(item),
+        type,
+        raw: item
+    };
+    const text = readString(item, "text");
+    if (text !== undefined) {
+        normalized.text = text;
+    }
+    else {
+        const contentText = readAppServerContentText(item);
+        if (contentText !== undefined) {
+            normalized.text = contentText;
+        }
+    }
+    const summary = readAppServerTextParts(item.summary);
+    if (summary.length > 0) {
+        normalized.summary = summary;
+    }
+    const content = readAppServerTextParts(item.content);
+    if (content.length > 0) {
+        normalized.content = content;
+    }
+    const command = readString(item, "command");
+    if (command !== undefined) {
+        normalized.command = command;
+    }
+    const cwd = readString(item, "cwd");
+    if (cwd !== undefined) {
+        normalized.cwd = cwd;
+    }
+    const status = readString(item, "status");
+    if (status !== undefined) {
+        normalized.status = status;
+    }
+    const commandActions = readAppServerCommandActions(item);
+    if (commandActions.length > 0) {
+        normalized.commandActions = commandActions;
+    }
+    const aggregatedOutput = readString(item, "aggregatedOutput");
+    if (aggregatedOutput !== undefined) {
+        normalized.aggregatedOutput = aggregatedOutput;
+    }
+    const exitCode = readNumber(item, "exitCode");
+    if (exitCode !== undefined) {
+        normalized.exitCode = exitCode;
+    }
+    const durationMs = readNumber(item, "durationMs");
+    if (durationMs !== undefined) {
+        normalized.durationMs = durationMs;
+    }
+    if ("changes" in item) {
+        normalized.changes = item.changes;
+    }
+    const server = readString(item, "server");
+    if (server !== undefined) {
+        normalized.server = server;
+    }
+    const tool = readString(item, "tool");
+    if (tool !== undefined) {
+        normalized.tool = tool;
+    }
+    const query = readString(item, "query");
+    if (query !== undefined) {
+        normalized.query = query;
+    }
+    return normalized;
+}
+function readAppServerContentText(item) {
+    const content = readAppServerTextParts(item.content);
+    if (content.length === 0) {
+        return undefined;
+    }
+    return content.join("\n\n");
+}
+function readAppServerTextParts(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap((part) => {
+        if (typeof part === "string") {
+            return part ? [part] : [];
+        }
+        if (!isRecord(part)) {
+            return [];
+        }
+        const text = readString(part, "text") ?? readString(part, "content") ?? readString(part, "summary");
+        return text ? [text] : [];
+    });
+}
+function readAppServerCommandActions(item) {
+    const value = item.commandActions;
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap((action) => {
+        if (!isRecord(action)) {
+            return [];
+        }
+        const type = readString(action, "type");
+        switch (type) {
+            case "read":
+                return [{ type, command: readString(action, "command"), name: readString(action, "name"), path: readString(action, "path") }];
+            case "listFiles":
+                return [{ type, command: readString(action, "command"), path: readString(action, "path") }];
+            case "search":
+                return [{ type, command: readString(action, "command"), query: readString(action, "query"), path: readString(action, "path") }];
+            case "unknown":
+                return [{ type, command: readString(action, "command") }];
+            default:
+                return [];
+        }
+    });
+}
+function finalResponseFromAppServerTurn(turn) {
+    const items = Array.isArray(turn?.items) ? turn.items : [];
+    for (const item of [...items].reverse()) {
+        if (isRecord(item) && item.type === "agentMessage" && typeof item.text === "string") {
+            return item.text;
+        }
+    }
+    return undefined;
+}
+function appServerItemId(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return readString(value, "itemId") ?? readString(value, "id");
+}
+function readRecord(value, key) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const child = value[key];
+    return isRecord(child) ? child : undefined;
+}
+function readString(value, key) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const child = value[key];
+    return typeof child === "string" ? child : undefined;
+}
+function readDeltaText(value) {
+    const delta = readString(value, "delta");
+    if (delta !== undefined) {
+        return delta;
+    }
+    const deltaBase64 = readString(value, "deltaBase64");
+    if (!deltaBase64) {
+        return undefined;
+    }
+    try {
+        return Buffer.from(deltaBase64, deltaBase64.includes("-") || deltaBase64.includes("_") ? "base64url" : "base64").toString("utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+function readNumber(value, key) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const child = value[key];
+    return typeof child === "number" ? child : undefined;
+}
+function readStringArray(value, key) {
+    if (!isRecord(value) || !Array.isArray(value[key])) {
+        return [];
+    }
+    return value[key].filter((item) => typeof item === "string");
+}
+function readNestedString(value, keys) {
+    let current = value;
+    for (const key of keys) {
+        if (!isRecord(current)) {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return typeof current === "string" ? current : undefined;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function buildTeamPlanningPrompt(input) {
+    const protocol = teamHarnessForInput(input);
+    return [
+        "<role>",
+        "  <purpose>",
+        "    Plan a closure-free executable ExecutionPlan.",
+        "  </purpose>",
+        "",
+        "  <instructions>",
+        indentBlock(teamInstructionFor(input, protocol), 4),
+        "  </instructions>",
+        "</role>",
+        "",
+        "<goal>",
+        indentBlock(formatTeamGoal(input), 2),
+        "</goal>",
+        "",
+        "<member_profiles>",
+        formatMemberProfiles(protocol.members),
+        "</member_profiles>",
+        "",
+        "<rules>",
+        "  Return one structured ExecutionPlan object with root kind queue.",
+        "  Put each executable step in the queue items array as kind goal with stage needs_evaluation.",
+        "  Use each goal item to delegate to one assignee Executor and optionally one evaluator Executor.",
+        "  A goal assignee must name executorId and a standalone goal.",
+        "  A goal evaluator, when present, must name executorId and a prompt that can return pass or fail with type, summary, reason, feedback, nextGoal, and evidence.",
+        `  Set remainingAttempts to ${normalizePositiveInteger(input.maxAttemptCount) || maxAttemptCountForPrompt(protocol)} for each goal unless a smaller bound is clearly enough.`,
+        "  Set requires to PrevMove unless this goal intentionally depends on earlier Path ids.",
+        "</rules>"
+    ].join("\n");
+}
+function maxAttemptCountForPrompt(protocol) {
+    switch (protocol.kind) {
+        case "team_execution_plan":
+            return protocol.maxAttemptCount;
+        case "role_squad":
+        case "council_vote":
+        case "court_debate":
+            return protocol.maxRoundCount;
+    }
+}
+function normalizePositiveInteger(value) {
+    return Number.isInteger(value) && value && value > 0 ? value : undefined;
+}
+export function buildMemberPathPrompt(input) {
+    const member = memberConfigFor(input, input.memberPath.executorId);
+    const renderedMemberPrompt = renderPromptTemplate(member.promptTemplate, memberPromptTemplateContext(input));
+    return [
+        "<member>",
+        renderedMemberPrompt.trim() || "No additional Member prompt.",
+        "</member>",
+        "",
+        "<goal>",
+        input.memberPath.goal.trim(),
+        "</goal>",
+        "",
+        "<constraints>",
+        "Do not read .hunsu files.",
+        "Do not create commits.",
+        "Use bounded commands for verification; do not run preview servers, dev servers, watchers, or other long-running processes in the foreground.",
+        "If you start a preview server, dev server, watcher, or any other long-running command, stop it before your final response.",
+        "Do not leave running command sessions, local listeners, or background processes open at the end of the turn.",
+        "</constraints>"
+    ].join("\n");
+}
+export function buildMoveFinalizerPrompt(input) {
+    const selectedDestination = selectedDestinationForPrompt(input);
+    const pathOutputs = input.pathOutputs.map(output => [
+        `- ${output.pathId} (${output.executorId})`,
+        `  goal: ${output.goal}`,
+        output.commit ? `  commit: ${output.commit}` : undefined,
+        output.finalResponse ? `  output: ${truncateText(output.finalResponse, 2000)}` : undefined
+    ].filter(Boolean).join("\n")).join("\n");
+    return [
+        "You are the MOVE finalizer for a completed Hunsu Execute.",
+        "Write the Git commit message for MOVE N+1 from the source MOVE to terminal Path diff.",
+        "Do not edit files. Do not create Git commits. Return only the commit message content.",
+        "",
+        `MOVE id: ${input.moveId}`,
+        `Source MOVE commit: ${input.sourceMoveCommit}`,
+        `Terminal Path commit: ${input.terminalPathCommit}`,
+        input.terminalMemberPathId ? `Terminal Path id: ${input.terminalMemberPathId}` : undefined,
+        "",
+        "Destination:",
+        selectedDestination ? formatDestinationForPrompt(selectedDestination) : `- ${input.requestGoal}`,
+        "",
+        "Completion summary:",
+        input.completionSummary || "Not provided.",
+        "",
+        "Path commits:",
+        Object.entries(input.pathCommits).map(([pathId, commit]) => `- ${pathId}: ${commit}`).join("\n") || "- none",
+        "",
+        "Path outputs:",
+        pathOutputs || "- none",
+        "",
+        "Diff stat:",
+        input.diffStat?.trim() || "Not provided.",
+        "",
+        "Diff name-status:",
+        input.diffNameStatus?.trim() || "Not provided.",
+        "",
+        "Diff patch:",
+        input.diffPatch?.trim() || "Not provided.",
+        "",
+        "Commit message requirements:",
+        "- First line: concise imperative subject for the MOVE result.",
+        "- Body: summarize the product changes and relevant Path outputs.",
+        "- Do not include Hunsu trailers; Studio appends system trailers."
+    ].filter((line) => line !== undefined).join("\n");
+}
+export function buildHunsuDraftPrompt(input) {
+    const managerInstructions = renderPromptTemplate(input.manager.promptTemplate, providerPromptTemplateContext(input)).trim();
+    return [
+        "<role>",
+        "You are the Hunsu Draft agent for a local Hunsu Studio session.",
+        "Help the user refine a proposed HUNSU intervention conversationally.",
+        "You may edit decoded draft request files under .hunsu-request/ in the supplied Route worktree.",
+        "Do not edit .hunsu/ encoded runtime files, .hunsu-prev/, product files, or create commits.",
+        "Available request runtime files are .hunsu-request/destinations.json, .hunsu-request/harness.json, .hunsu-request/executors.json, .hunsu-request/resources.json, and .hunsu-request/artifact-actions.json.",
+        "Edit only the files required by the user's explicit request.",
+        "Use destinations.json for Destination/TODO changes and artifact-actions.json for Artifact Action changes.",
+        "For a simple TODO/Destination addition, edit only .hunsu-request/destinations.json.",
+        ".hunsu-request/executors.json is the source of truth for Member definitions.",
+        ".hunsu-request/resources.json is the source of truth for Skill, Plugin, and Resource bindings.",
+        ".hunsu-request/harness.json stores Harness policy only; it must not contain a members field.",
+        "Do not edit .hunsu-request/harness.json unless the user explicitly asks to change root Team or Harness policy.",
+        "Do not edit .hunsu-request/executors.json unless the user explicitly asks to change Member definitions or Member config.",
+        "Do not edit .hunsu-request/resources.json unless the user explicitly asks to change Resource bindings or requirements.",
+        "Do not create, copy, or update Resource bindings or assignment entries for newly added Destinations; Team-planner routing and binding are handled outside Destination edits.",
+        "After editing .hunsu-request files, run the supplied Draft check command. It creates a DiffArtifact in Hunsu Local.",
+        "If the DiffArtifact passes, include this exact marker in your final reply: ::hunsu-diff{draftSessionId=\"<draftSessionId>\" diffArtifactId=\"<diffArtifactId>\" status=\"pass\"}",
+        "If the DiffArtifact fails, include the same marker with status=\"failed\" and explain the validation error briefly.",
+        "Confirmation is handled by Hunsu Local from the DiffArtifact id.",
+        "</role>",
+        "",
+        "<manager>",
+        `id: ${input.manager.id}`,
+        "instructions:",
+        indentBlock(managerInstructions || "No Manager-specific instructions.", 2),
+        "</manager>",
+        "",
+        "<draft_check_command>",
+        indentBlock(input.draftCheckCommand, 2),
+        "</draft_check_command>",
+        "",
+        "<source_snapshot>",
+        indentBlock(formatHunsuSourceSnapshot(input.sourceSnapshot), 2),
+        "</source_snapshot>",
+        "",
+        "<request_goal>",
+        indentBlock(input.requestGoal, 2),
+        "</request_goal>",
+        "",
+        "<conversation>",
+        indentBlock(formatHunsuDraftConversation(input.messages), 2),
+        "</conversation>",
+        "",
+        "<latest_user_message>",
+        indentBlock(input.userMessage, 2),
+        "</latest_user_message>",
+        "",
+        "<response_rules>",
+        "Answer naturally and briefly.",
+        "If you edited .hunsu-request files, summarize the changed files and the intended runtime change after running the Draft check command.",
+        "If the requested change cannot be represented in the provided .hunsu-request runtime files, say which runtime file or schema is missing.",
+        "If more detail is needed, ask a focused follow-up question.",
+        "Do not output JSON unless the user explicitly asks for an example.",
+        "</response_rules>"
+    ].join("\n");
+}
+function renderProviderGoal(input, config) {
+    const renderedPrompt = renderPromptTemplate(config.promptTemplate, providerPromptTemplateContext(input));
+    if (isHunsuDraftInput(input)) {
+        return truncateText([
+            "Objective: discuss a HUNSU draft with the user.",
+            `Source: ${input.sourceSnapshot.teamName ?? "Team"} ${input.sourceSnapshot.moveOrdinal !== undefined ? `M${String(input.sourceSnapshot.moveOrdinal).padStart(4, "0")}` : input.sourceSnapshot.sourceNodeId}`,
+            isHunsuDraftTurnInput(input) ? `User request: ${input.userMessage}` : "Status: preparing the Draft chat session before the first user message.",
+            renderedPrompt.trim() ? `Instructions:\n${renderedPrompt.trim()}` : undefined
+        ].filter(Boolean).join("\n\n"), 4000);
+    }
+    if (isMemberPathRunInput(input)) {
+        const parts = [
+            `Objective: ${input.memberPath.goal}`,
+            renderedPrompt.trim() ? `Member:\n${renderedPrompt.trim()}` : undefined
+        ].filter(Boolean);
+        return truncateText(parts.join("\n\n"), 4000);
+    }
+    const parts = [
+        `Objective:\n${formatTeamGoal(input)}`,
+        `Instructions:\n${renderedPrompt.trim() || DEFAULT_TEAM_INSTRUCTION}`
+    ].filter(Boolean);
+    return truncateText(parts.join("\n\n"), 4000);
+}
+function teamInstructionFor(input, protocol) {
+    const prompt = renderPromptTemplate(protocol.team.promptTemplate, teamPromptTemplateContext(input, protocol)).trim();
+    if (!prompt) {
+        return DEFAULT_TEAM_INSTRUCTION;
+    }
+    return prompt;
+}
+function teamPromptTemplateContext(input, protocol) {
+    const selectedDestinations = selectedDestinationsForPrompt(input);
+    return {
+        requestGoal: input.requestGoal,
+        currentDestination: selectedDestinations[0] ?? selectedDestinationForPrompt(input),
+        currentDestinations: selectedDestinations,
+        selectedDestinations,
+        activeDestinations: input.activeDestinations,
+        constraints: futureConstraintsForPrompt(input),
+        members: protocol.members.map(member => ({
+            id: member.id,
+            promptTemplate: member.promptTemplate.template,
+            model: member.model,
+            reasoningEffort: member.reasoningEffort,
+            serviceTier: member.serviceTier,
+            skills: member.skills.map(skill => skill.name),
+            plugins: member.plugins.map(plugin => plugin.id)
+        }))
+    };
+}
+function memberPromptTemplateContext(input) {
+    const selectedDestinations = selectedDestinationsForPrompt(input);
+    return {
+        requestGoal: input.requestGoal,
+        pathGoal: input.memberPath.goal,
+        memberPath: input.memberPath,
+        dependencyOutputs: input.dependencyOutputs ?? [],
+        worktreeStatus: input.worktreeStatus,
+        worktreeDiff: input.worktreeDiff,
+        attemptTranscript: input.attemptTranscript,
+        evaluationFeedback: input.attemptTranscript,
+        currentDestination: selectedDestinations[0] ?? selectedDestinationForPrompt(input),
+        currentDestinations: selectedDestinations,
+        selectedDestinations,
+        activeDestinations: input.activeDestinations,
+        constraints: futureConstraintsForPrompt(input),
+        sourceMoveId: input.sourceMoveId,
+        targetMoveOrdinal: input.targetMoveOrdinal
+    };
+}
+function providerPromptTemplateContext(input) {
+    if (isMemberPathRunInput(input)) {
+        return memberPromptTemplateContext(input);
+    }
+    if (isHunsuDraftInput(input)) {
+        return {
+            requestGoal: input.requestGoal,
+            sourceSnapshot: input.sourceSnapshot,
+            userMessage: isHunsuDraftTurnInput(input) ? input.userMessage : undefined,
+            messages: isHunsuDraftTurnInput(input) ? input.messages : []
+        };
+    }
+    return teamPromptTemplateContext(input, teamHarnessForInput(input));
+}
+function formatTeamGoal(input) {
+    const selectedDestination = selectedDestinationForPrompt(input);
+    const constraints = futureConstraintsForPrompt(input)
+        .map(item => `- ${item}`)
+        .join("\n");
+    return [
+        selectedDestination ? formatDestinationGoalForPrompt(selectedDestination) : `- ${input.requestGoal}`,
+        constraints ? `Relevant constraints:\n${constraints}` : undefined
+    ].filter((line) => line !== undefined).join("\n\n");
+}
+function selectedDestinationForPrompt(input) {
+    const selectedId = input.selectedDestinationIds?.[0];
+    if (selectedId) {
+        return input.activeDestinations.find(destination => destination.id === selectedId);
+    }
+    return [...input.activeDestinations].sort((left, right) => (right.priority ?? 0) - (left.priority ?? 0))[0];
+}
+function selectedDestinationsForPrompt(input) {
+    const selectedIds = input.selectedDestinationIds ?? [];
+    if (selectedIds.length === 0) {
+        const selected = selectedDestinationForPrompt(input);
+        return selected ? [selected] : [];
+    }
+    const selected = new Set(selectedIds);
+    return input.activeDestinations.filter(destination => selected.has(destination.id));
+}
+function futureConstraintsForPrompt(input) {
+    return input.futureConstraints && input.futureConstraints.length > 0
+        ? input.futureConstraints
+        : input.board.futureConstraints.map(constraint => constraint.constraint);
+}
+function formatDestinationGoalForPrompt(destination) {
+    const parts = [`- ${destination.title}`];
+    if (destination.acceptanceCriteria && destination.acceptanceCriteria.length > 0) {
+        parts.push(`  Acceptance: ${destination.acceptanceCriteria.join("; ")}`);
+    }
+    if (destination.constraints && destination.constraints.length > 0) {
+        parts.push(`  Constraints: ${destination.constraints.join("; ")}`);
+    }
+    if (destination.notes?.trim()) {
+        parts.push(`  Notes: ${destination.notes.trim()}`);
+    }
+    return parts.join("\n");
+}
+function formatMemberProfiles(members) {
+    return members.map(member => [
+        `  <member id="${xmlAttribute(member.id)}">`,
+        "    <profile>",
+        indentBlock(member.promptTemplate.template.trim() || "No profile.", 6),
+        "    </profile>",
+        "  </member>"
+    ].join("\n")).join("\n\n") || "  <member id=\"default\">\n    <profile>\n      No profile.\n    </profile>\n  </member>";
+}
+function indentBlock(text, spaces) {
+    const prefix = " ".repeat(spaces);
+    return text.split("\n").map(line => line ? `${prefix}${line}` : "").join("\n");
+}
+function xmlAttribute(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("\"", "&quot;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;");
+}
+function formatDestinationForPrompt(destination) {
+    const parts = [`- ${destination.title}`];
+    if (destination.acceptanceCriteria && destination.acceptanceCriteria.length > 0) {
+        parts.push(`  Acceptance: ${destination.acceptanceCriteria.join("; ")}`);
+    }
+    if (destination.constraints && destination.constraints.length > 0) {
+        parts.push(`  Constraints: ${destination.constraints.join("; ")}`);
+    }
+    if (destination.notes?.trim()) {
+        parts.push(`  Notes: ${destination.notes.trim()}`);
+    }
+    return parts.join("\n");
+}
+function formatHunsuSourceSnapshot(snapshot) {
+    return [
+        `draftSessionId source line: ${snapshot.sourceLineId}`,
+        `source node: ${snapshot.sourceNodeId}`,
+        snapshot.sourceMoveId ? `source move: ${snapshot.sourceMoveId}` : undefined,
+        snapshot.moveOrdinal !== undefined ? `position: M${String(snapshot.moveOrdinal).padStart(4, "0")}` : undefined,
+        snapshot.teamName ? `team: ${snapshot.teamName}` : undefined,
+        snapshot.summary ? `summary: ${snapshot.summary}` : undefined,
+        "destinations:",
+        snapshot.destinationSummaries.length > 0
+            ? snapshot.destinationSummaries.map(destination => `- ${destination.id} [${destination.status}] ${destination.title}`).join("\n")
+            : "- none"
+    ].filter((line) => line !== undefined).join("\n");
+}
+function formatHunsuDraftConversation(messages) {
+    if (messages.length === 0) {
+        return "No prior draft conversation.";
+    }
+    return messages.map(message => {
+        const label = message.role === "draft-agent" ? "Draft Agent" : message.role === "user" ? "User" : "System";
+        return `${label}: ${truncateText(message.text, 1200)}`;
+    }).join("\n\n");
+}
+function teamPlanningConfigFor(input) {
+    const protocol = teamHarnessForInput(input);
+    return createDefaultMemberConfig("team", teamInstructionFor(input, protocol), []);
+}
+function moveFinalizerConfigFor() {
+    return createDefaultMemberConfig("move-finalizer", "Write a precise final MOVE commit message from the completed Execute diff and evidence.", []);
+}
+function hunsuDraftConfigFor(manager = createDefaultManagerConfig()) {
+    const config = createDefaultMemberConfig(String(manager.id), manager.promptTemplate.template, manager.skills);
+    return {
+        ...config,
+        promptTemplate: { ...manager.promptTemplate },
+        plugins: manager.plugins.map(plugin => ({ ...plugin })),
+        execution: { kind: "worktree_write", network: "enabled" },
+        approval: { policy: "never" }
+    };
+}
+function memberConfigFor(input, executorId) {
+    if (input.harnessGraph) {
+        const member = getHarnessMember(input.harnessGraph, executorId);
+        if (!member) {
+            throw new Error(`Harness does not define required Member ${executorId}`);
+        }
+        return memberConfigFromMemberEntity(member);
+    }
+    const protocol = teamHarnessForInput(input);
+    const member = getHarnessMemberConfig(protocol, executorId);
+    if (!member) {
+        throw new Error(`Harness ${protocol.kind} does not define required Member ${executorId}`);
+    }
+    return member;
+}
+function teamHarnessForInput(input) {
+    if (input.harnessGraph) {
+        return harnessSnapshotForTeam(input.harnessGraph, input.teamScopeId ?? input.harnessGraph.rootTeamId);
+    }
+    return input.harness ?? createDefaultHarness();
+}
+function threadOptionsForMember(member) {
+    const options = {
+        approvalPolicy: member.approval.policy === "on_request" ? "on-request" : "never",
+        approvalsReviewer: member.approval.policy === "on_request" ? member.approval.reviewer : "user",
+        networkAccessEnabled: member.execution.network === "enabled"
+    };
+    switch (member.execution.kind) {
+        case "read_only":
+            options.sandboxMode = "read-only";
+            break;
+        case "worktree_write":
+            options.sandboxMode = "workspace-write";
+            break;
+        case "unrestricted":
+            options.sandboxMode = "danger-full-access";
+            break;
+    }
+    if (member.model && member.model !== "codex-default") {
+        options.model = member.model;
+    }
+    if (member.reasoningEffort && member.reasoningEffort !== "default") {
+        options.modelReasoningEffort = member.reasoningEffort;
+    }
+    return options;
+}
+function isMemberPathRunInput(input) {
+    return "memberPath" in input;
+}
+function isHunsuDraftTurnInput(input) {
+    return "draftSessionId" in input && "sourceSnapshot" in input && "userMessage" in input;
+}
+function isHunsuDraftInput(input) {
+    return "draftSessionId" in input && "sourceSnapshot" in input;
+}
+function createCodexEnvironment(env) {
+    const next = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (value !== undefined) {
+            next[key] = value;
+        }
+    }
+    const workspaceRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../../..");
+    const workspaceBin = join(workspaceRoot, "node_modules", ".bin");
+    next.PATH = [workspaceBin, env.PATH].filter(Boolean).join(delimiter);
+    return next;
+}
+function truncateText(text, maxLength = 4000) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    return `${text.slice(0, maxLength - 1)}...`;
+}