@suwujs/king-ai 0.2.0

package/dist/src/engine.js

@@ -0,0 +1,1014 @@
+import { execFileSync, spawn } from "node:child_process";
+import { access, mkdir, writeFile } from "node:fs/promises";
+import { existsSync, writeFileSync } from "node:fs";
+import { join, delimiter as PATH_DELIMITER } from "node:path";
+import { cleanLine, stripLoneSurrogates } from "./text.js";
+const IS_WIN = process.platform === "win32";
+const DOCTOR_PROMPT = "Connectivity check. Reply with exactly: OK";
+const MAX_FAILURE_CHARS = 4000;
+const TURN_TIMEOUT_MS = Number(process.env.KING_AI_TURN_TIMEOUT_MS) || 0;
+const SESSION_TIMEOUT_MS = Number(process.env.KING_AI_SESSION_TIMEOUT_MS) || 0;
+export function splitExtraArgs(raw) {
+    if (!raw)
+        return [];
+    const args = [];
+    let current = "";
+    let quote = null;
+    let escaping = false;
+    for (const ch of raw) {
+        if (escaping) {
+            current += ch;
+            escaping = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escaping = true;
+            continue;
+        }
+        if (quote) {
+            if (ch === quote)
+                quote = null;
+            else
+                current += ch;
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            quote = ch;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            if (current) {
+                args.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += ch;
+    }
+    if (escaping)
+        current += "\\";
+    if (current)
+        args.push(current);
+    return args;
+}
+function envExtraArgs(...names) {
+    for (const name of names) {
+        const args = splitExtraArgs(process.env[name]);
+        if (args.length)
+            return args;
+    }
+    return [];
+}
+function pushTail(lines, line, max = 80) {
+    lines.push(line);
+    if (lines.length > max)
+        lines.splice(0, lines.length - max);
+}
+function textOfContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (typeof part === "string")
+            return part;
+        if (part &&
+            typeof part === "object" &&
+            "type" in part &&
+            part.type === "text" &&
+            "text" in part &&
+            typeof part.text === "string") {
+            return part.text;
+        }
+        return "";
+    })
+        .filter(Boolean)
+        .join(" ");
+}
+export function formatEngineLogLine(engine, line) {
+    const cleaned = cleanLine(line);
+    if (!cleaned)
+        return null;
+    if (!cleaned.startsWith("{"))
+        return cleaned;
+    try {
+        const obj = JSON.parse(cleaned);
+        if (engine === "claude") {
+            if (obj.type === "system" && obj.subtype === "init")
+                return "[claude] session initialized";
+            if (obj.type === "assistant") {
+                const message = obj.message;
+                const text = textOfContent(message?.content).replace(/\s+/g, " ").trim();
+                return text ? `[claude] ${text.slice(0, 500)}` : null;
+            }
+            if (obj.type === "user") {
+                const message = obj.message;
+                const text = textOfContent(message?.content).replace(/\s+/g, " ").trim();
+                return text ? `[tool] ${text.slice(0, 500)}` : null;
+            }
+            if (obj.type === "result") {
+                if (obj.is_error === true)
+                    return `[claude] failed: ${String(obj.result ?? "error").slice(0, 500)}`;
+                return "[claude] turn completed";
+            }
+            if (obj.subtype === "status" && obj.status === "compacting")
+                return "[claude] native context compaction started";
+            if (obj.subtype === "compact_boundary")
+                return "[claude] native context compaction finished";
+            return null;
+        }
+        if (engine === "codex") {
+            if (process.env.KING_AI_CODEX_VERBOSE === "1")
+                return cleaned;
+            const method = typeof obj.method === "string" ? obj.method : "";
+            const params = obj.params;
+            const item = params?.item;
+            if (method === "item/started" && item?.type === "commandExecution" && typeof item.command === "string") {
+                return `[codex] $ ${item.command.replace(/\s+/g, " ").slice(0, 500)}`;
+            }
+            if (method === "item/completed" && item?.type === "agentMessage" && typeof item.text === "string") {
+                return `[codex] ${item.text.replace(/\s+/g, " ").slice(0, 500)}`;
+            }
+            if (method === "turn/completed")
+                return "[codex] turn completed";
+            return null;
+        }
+    }
+    catch {
+        return cleaned;
+    }
+    return cleaned;
+}
+function resolveSpawn(bin) {
+    if (!IS_WIN)
+        return { command: bin, shell: false, wantsStdinPrompt: false };
+    const exts = (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+    for (const dir of (process.env.PATH ?? "").split(PATH_DELIMITER)) {
+        for (const ext of ["", ...exts]) {
+            const candidate = join(dir, bin + ext);
+            if (existsSync(candidate)) {
+                const batch = /\.(cmd|bat)$/i.test(candidate);
+                return { command: candidate, shell: batch, wantsStdinPrompt: batch };
+            }
+        }
+    }
+    return { command: bin, shell: true, wantsStdinPrompt: true };
+}
+export async function binOnPath(bin) {
+    return new Promise((resolve) => {
+        const probe = spawn(IS_WIN ? "where" : "which", [bin], { stdio: "ignore" });
+        probe.on("error", () => resolve(false));
+        probe.on("close", (code) => resolve(code === 0));
+    });
+}
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureCommonHome(home) {
+    await mkdir(join(home, "memory"), { recursive: true });
+    await mkdir(join(home, "notes"), { recursive: true });
+    await mkdir(join(home, "workspace"), { recursive: true });
+    const index = join(home, "memory", "MEMORY.md");
+    if (!(await exists(index))) {
+        await writeFile(index, "# Memory index\n\nOne line per durable fact, pointing at the file that holds it:\n`- [Title](file.md) - one-line hook`\n\nWrite the fact itself in its own `memory/<topic>.md` file; keep this index short.\n", "utf8");
+    }
+}
+export function personaHeader(persona) {
+    return `# ${persona.name}${persona.role ? ` - ${persona.role}` : ""}
+
+You are ${persona.name}, a teammate running from this local agent home.
+
+This directory is your private home and working directory. It persists across wakes and is yours alone.
+
+Layout:
+- CLAUDE.md this file; keep it short.
+- memory/ durable notes indexed by memory/MEMORY.md.
+- notes/ scratch notes and reply drafts.
+- .claude/skills/ your skills.
+- workspace/ project files, clones, downloads, builds, and temporary work. Use workspace/ for project work instead of cluttering the home root.
+
+Privacy boundary:
+- Stay inside this home directory unless the operator explicitly asks otherwise in this runtime.
+- Do not read, list, search, quote, summarize, or send files outside this home directory.
+- If a task seems to need a file outside this home, ask in the runtime first.
+
+Use the \`king-ai\` command on PATH to interact with the remote runtime.
+`;
+}
+function failurePreview(exitCode, signalName, stderr, stdout) {
+    const detail = [...stderr, ...stdout].join("\n").trim();
+    const prefix = signalName ? `process terminated by ${signalName}` : `process exited with code ${exitCode}`;
+    return detail ? `${prefix}\n${detail}`.slice(0, MAX_FAILURE_CHARS) : prefix;
+}
+export function claudeStreamUserMessage(text) {
+    return JSON.stringify({ type: "user", message: { role: "user", content: [{ type: "text", text: stripLoneSurrogates(text) }] } }) + "\n";
+}
+function codexUserInput(text, imagePaths = []) {
+    return [
+        { type: "text", text: stripLoneSurrogates(text), text_elements: [] },
+        ...imagePaths.filter((path) => path.trim()).map((path) => ({ type: "localImage", path }))
+    ];
+}
+function codexImageArgs(imagePaths) {
+    return (imagePaths ?? []).filter((path) => path.trim()).flatMap((path) => ["--image", path]);
+}
+function unknownRecord(value) {
+    return value && typeof value === "object" ? value : null;
+}
+function nestedRecord(value, key) {
+    return unknownRecord(unknownRecord(value)?.[key]);
+}
+function errorMessage(value, fallback) {
+    const rec = unknownRecord(value);
+    const nested = unknownRecord(rec?.error);
+    const message = rec?.message ?? nested?.message;
+    return typeof message === "string" && message.trim() ? message.slice(0, MAX_FAILURE_CHARS) : fallback;
+}
+export function reduceCodexAppEvent(state, msg) {
+    const logs = [];
+    let activeTurnId = state.activeTurnId;
+    let steerGate = state.steerGate;
+    const method = typeof msg.method === "string" ? msg.method : "";
+    const result = unknownRecord(msg.result);
+    const params = unknownRecord(msg.params);
+    const threadId = nestedRecord(result, "thread")?.id ?? (method === "thread/started" ? nestedRecord(params, "thread")?.id : undefined);
+    const turnId = nestedRecord(result, "turn")?.id ?? result?.turnId ?? (method === "turn/started" ? nestedRecord(params, "turn")?.id : undefined);
+    if (typeof turnId === "string") {
+        activeTurnId = turnId;
+        steerGate = false;
+    }
+    if (method === "thread/tokenUsage/updated") {
+        return { logs, activeTurnId, steerGate, usage: nestedRecord(params, "tokenUsage")?.total };
+    }
+    if (method === "account/rateLimits/updated") {
+        const pct = unknownRecord(nestedRecord(params, "rateLimits")?.primary)?.usedPercent;
+        if (typeof pct === "number" && pct >= 90)
+            logs.push(`[codex] account rate limit at ${Math.round(pct)}% - turns will start failing when it reaches 100%`);
+        return { logs, activeTurnId, steerGate };
+    }
+    if (method === "item/started" || method === "item/completed") {
+        const item = nestedRecord(params, "item");
+        const type = item?.type;
+        if (type === "contextCompaction") {
+            logs.push(`[codex] native context compaction ${method === "item/started" ? "started" : "finished"}`);
+        }
+        else if (item && type === "commandExecution" && method === "item/started" && typeof item.command === "string") {
+            logs.push(`[codex] $ ${item.command.replace(/\s+/g, " ").slice(0, 200)}`);
+        }
+        else if (item && type === "agentMessage" && method === "item/completed" && typeof item.text === "string" && item.text.trim()) {
+            logs.push(`[codex] ${item.text.replace(/\s+/g, " ").slice(0, 200)}`);
+        }
+        if (method === "item/completed")
+            steerGate = true;
+        return { logs, activeTurnId, steerGate };
+    }
+    if (method === "item/agentMessage/delta" || method === "item/reasoning/textDelta" || method === "item/reasoning/summaryTextDelta") {
+        return { logs, activeTurnId, steerGate: false };
+    }
+    if (method === "turn/completed") {
+        const turn = nestedRecord(params, "turn") ?? nestedRecord(result, "turn");
+        const failed = turn?.status === "failed" ? String(nestedRecord(turn, "error")?.message ?? "codex turn failed") : undefined;
+        return { logs, activeTurnId: null, steerGate: false, turnCompletedError: failed };
+    }
+    return { logs, activeTurnId, steerGate, threadId: typeof threadId === "string" ? threadId : undefined };
+}
+function spawnCapture(bin, args, opts) {
+    return new Promise((resolve) => {
+        const child = spawn(bin, args, {
+            cwd: opts.cwd,
+            env: opts.env,
+            stdio: [opts.stdinText == null ? "ignore" : "pipe", "pipe", "pipe"],
+            shell: opts.shell ?? false
+        });
+        if (opts.stdinText != null) {
+            child.stdin?.write(opts.stdinText);
+            child.stdin?.end();
+        }
+        const onAbort = () => child.kill("SIGTERM");
+        opts.signal.addEventListener("abort", onAbort, { once: true });
+        let stdout = "";
+        const stderr = [];
+        child.stdout?.on("data", (buf) => {
+            const text = buf.toString("utf8");
+            stdout += text;
+            const line = cleanLine(text);
+            if (line)
+                opts.onLog?.(line);
+        });
+        child.stderr?.on("data", (buf) => {
+            for (const raw of buf.toString("utf8").split("\n")) {
+                const line = cleanLine(raw);
+                if (line)
+                    stderr.push(line);
+            }
+        });
+        child.on("error", (err) => {
+            opts.signal.removeEventListener("abort", onAbort);
+            resolve({ text: "", error: err.message });
+        });
+        child.on("close", (code, signalName) => {
+            opts.signal.removeEventListener("abort", onAbort);
+            const exitCode = code ?? (signalName ? 128 : 1);
+            resolve({
+                text: stdout.trim(),
+                error: exitCode === 0 ? undefined : failurePreview(exitCode, signalName, stderr, [])
+            });
+        });
+    });
+}
+function spawnEngine(bin, args, opts) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(bin, args, {
+            cwd: opts.home,
+            env: opts.env,
+            stdio: [opts.stdinText == null ? "ignore" : "pipe", "pipe", "pipe"],
+            shell: opts.shell ?? false
+        });
+        if (opts.stdinText != null) {
+            child.stdin?.write(opts.stdinText);
+            child.stdin?.end();
+        }
+        const stderr = [];
+        const stdout = [];
+        let sessionId = null;
+        let usage;
+        let model = null;
+        let timer = null;
+        const onAbort = () => child.kill("SIGTERM");
+        opts.signal.addEventListener("abort", onAbort, { once: true });
+        if (TURN_TIMEOUT_MS > 0)
+            timer = setTimeout(onAbort, TURN_TIMEOUT_MS);
+        child.stdout?.on("data", (buf) => {
+            for (const raw of buf.toString("utf8").split("\n")) {
+                const line = cleanLine(raw);
+                if (!line)
+                    continue;
+                stdout.push(line);
+                opts.onLog(line);
+                if (!line.startsWith("{"))
+                    continue;
+                try {
+                    const obj = JSON.parse(line);
+                    if (typeof obj.session_id === "string")
+                        sessionId = obj.session_id;
+                    if (obj.type === "result" && typeof obj.usage === "object")
+                        usage = obj.usage;
+                    const message = obj.message;
+                    if (typeof obj.model === "string")
+                        model = obj.model;
+                    if (typeof message?.model === "string")
+                        model = message.model;
+                }
+                catch {
+                    // Ignore non-event JSON.
+                }
+            }
+        });
+        child.stderr?.on("data", (buf) => {
+            for (const raw of buf.toString("utf8").split("\n")) {
+                const line = cleanLine(raw);
+                if (!line)
+                    continue;
+                stderr.push(line);
+                opts.onLog(line);
+            }
+        });
+        child.on("error", reject);
+        child.on("close", (code, signalName) => {
+            if (timer)
+                clearTimeout(timer);
+            opts.signal.removeEventListener("abort", onAbort);
+            const exitCode = code ?? (signalName ? 128 : 1);
+            resolve({
+                exitCode,
+                error: exitCode === 0 ? undefined : failurePreview(exitCode, signalName, stderr, stdout),
+                sessionId,
+                usage,
+                model
+            });
+        });
+    });
+}
+class ClaudeSession {
+    carriesStandingPrompt;
+    child;
+    outBuf = "";
+    pending = null;
+    exited = false;
+    exitCode = 0;
+    sid = null;
+    currentModel = null;
+    stderrTail = [];
+    stdoutTail = [];
+    steerQueue = [];
+    constructor(bin, args, opts, carriesStandingPrompt) {
+        this.carriesStandingPrompt = carriesStandingPrompt;
+        this.child = spawn(bin, args, {
+            cwd: opts.home,
+            env: opts.env,
+            stdio: ["pipe", "pipe", "pipe"],
+            shell: opts.shell ?? false
+        });
+        this.child.stdout?.on("data", (buf) => this.onStdout(buf, opts.onLog));
+        this.child.stderr?.on("data", (buf) => this.onStderr(buf, opts.onLog));
+        this.child.on("error", (err) => this.die(1, err.message));
+        this.child.on("close", (code, signalName) => this.die(code ?? (signalName ? 128 : 1), signalName ? `terminated by ${signalName}` : `exited with code ${code ?? 1}`));
+        if (opts.stdinText)
+            this.child.stdin?.write(opts.stdinText);
+    }
+    get alive() {
+        return !this.exited && this.child.stdin?.writable === true;
+    }
+    get sessionId() {
+        return this.sid;
+    }
+    send(prompt) {
+        if (this.pending)
+            return Promise.resolve({ exitCode: 1, error: "engine session is already running a turn", sessionId: this.sid });
+        if (!this.alive) {
+            const exitCode = this.exitCode || 1;
+            const detail = failurePreview(exitCode, null, this.stderrTail, this.stdoutTail);
+            return Promise.resolve({ exitCode, error: detail || "engine session is not alive", sessionId: this.sid });
+        }
+        return new Promise((resolve) => {
+            const pending = { resolve, stdout: [], stderr: [], timer: null };
+            if (SESSION_TIMEOUT_MS > 0) {
+                pending.timer = setTimeout(() => {
+                    this.settle({
+                        exitCode: 124,
+                        error: `engine turn exceeded KING_AI_TURN_TIMEOUT_MS (${Math.round(SESSION_TIMEOUT_MS / 1000)}s) - aborted; session will respawn`,
+                        sessionId: this.sid
+                    });
+                    this.stop();
+                }, SESSION_TIMEOUT_MS);
+                pending.timer.unref?.();
+            }
+            this.pending = pending;
+            this.child.stdin?.write(claudeStreamUserMessage(prompt));
+        });
+    }
+    steer(text) {
+        if (!this.pending || !this.alive || !text.trim())
+            return;
+        this.steerQueue.push(text);
+    }
+    stop() {
+        this.exited = true;
+        this.child.stdin?.end();
+        this.child.kill("SIGTERM");
+    }
+    onStdout(buf, onLog) {
+        this.outBuf += buf.toString("utf8");
+        let nl;
+        while ((nl = this.outBuf.indexOf("\n")) >= 0) {
+            const line = cleanLine(this.outBuf.slice(0, nl));
+            this.outBuf = this.outBuf.slice(nl + 1);
+            if (!line)
+                continue;
+            pushTail(this.stdoutTail, line);
+            if (this.pending)
+                pushTail(this.pending.stdout, line);
+            const display = formatEngineLogLine("claude", line);
+            if (display)
+                onLog(display);
+            if (!line.startsWith("{"))
+                continue;
+            try {
+                const obj = JSON.parse(line);
+                if (typeof obj.session_id === "string")
+                    this.sid = obj.session_id;
+                if (typeof obj.model === "string")
+                    this.currentModel = obj.model;
+                const message = obj.message;
+                if (typeof message?.model === "string")
+                    this.currentModel = message.model;
+                if (obj.type === "result") {
+                    this.steerQueue = [];
+                    const isError = obj.is_error === true;
+                    const detail = failurePreview(1, null, this.pending?.stderr ?? [], this.pending?.stdout ?? []);
+                    const resultText = String(obj.result ?? "").trim();
+                    this.settle({
+                        exitCode: isError ? 1 : 0,
+                        error: isError ? (resultText && resultText !== "error" ? resultText : detail || "engine turn error").slice(0, MAX_FAILURE_CHARS) : undefined,
+                        sessionId: this.sid,
+                        usage: obj.usage && typeof obj.usage === "object" ? obj.usage : undefined,
+                        model: this.currentModel
+                    });
+                }
+                else if (obj.type === "user") {
+                    this.flushSteer();
+                }
+            }
+            catch {
+                // Ignore malformed event JSON.
+            }
+        }
+    }
+    onStderr(buf, onLog) {
+        for (const raw of buf.toString("utf8").split("\n")) {
+            const line = cleanLine(raw);
+            if (!line)
+                continue;
+            pushTail(this.stderrTail, line);
+            if (this.pending)
+                pushTail(this.pending.stderr, line);
+            onLog(line);
+        }
+    }
+    flushSteer() {
+        if (!this.pending || !this.alive)
+            return;
+        while (this.steerQueue.length > 0) {
+            const text = this.steerQueue.shift();
+            if (!text)
+                continue;
+            try {
+                this.child.stdin?.write(claudeStreamUserMessage(text));
+            }
+            catch {
+                break;
+            }
+        }
+    }
+    settle(result) {
+        const pending = this.pending;
+        this.pending = null;
+        if (!pending)
+            return;
+        if (pending.timer)
+            clearTimeout(pending.timer);
+        pending.resolve(result);
+    }
+    die(exitCode, error) {
+        this.exited = true;
+        this.exitCode = exitCode;
+        const pending = this.pending;
+        if (!pending)
+            return;
+        const detail = failurePreview(exitCode, null, pending.stderr, pending.stdout);
+        this.settle({ exitCode, error: detail || error, sessionId: this.sid });
+    }
+}
+function ensureGitRepoForCodex(home) {
+    if (existsSync(join(home, ".git")))
+        return;
+    const gitEnv = { cwd: home, stdio: "ignore" };
+    const identity = ["-c", "user.name=king-ai", "-c", "user.email=king-ai@local", "-c", "commit.gpgsign=false"];
+    execFileSync("git", ["init"], gitEnv);
+    execFileSync("git", [...identity, "commit", "--allow-empty", "-m", "king-ai init"], gitEnv);
+}
+class CodexSession {
+    opts;
+    child;
+    outBuf = "";
+    reqId = 0;
+    initializeId = null;
+    threadReqId = null;
+    turnStart = { input: 0, cached: 0, output: 0 };
+    usage = { input: 0, cached: 0, output: 0 };
+    pending = null;
+    queuedTurn = null;
+    ready = false;
+    exited = false;
+    exitCode = 0;
+    threadId = null;
+    threadWasResume = false;
+    activeTurnId = null;
+    steerGate = false;
+    stderrTail = [];
+    stdoutTail = [];
+    carriesStandingPrompt;
+    constructor(bin, args, opts) {
+        this.opts = opts;
+        this.threadId = opts.resumeSessionId ?? null;
+        this.carriesStandingPrompt = !!opts.standingPrompt;
+        this.child = spawn(bin, args, { cwd: opts.home, env: opts.env, stdio: ["pipe", "pipe", "pipe"] });
+        this.child.stdout?.on("data", (buf) => this.onStdout(buf));
+        this.child.stderr?.on("data", (buf) => {
+            for (const raw of buf.toString("utf8").split("\n")) {
+                const line = cleanLine(raw);
+                if (!line)
+                    continue;
+                pushTail(this.stderrTail, line);
+                opts.onLog(line);
+            }
+        });
+        this.child.on("error", (err) => this.die(1, err.message));
+        this.child.on("close", (code, sig) => this.die(code ?? (sig ? 128 : 1), sig ? `terminated by ${sig}` : `exited with code ${code ?? 1}`));
+        queueMicrotask(() => {
+            this.initializeId = this.req("initialize", { clientInfo: { name: "king-ai", version: "0.1.0" }, capabilities: { experimentalApi: true } });
+        });
+    }
+    get alive() {
+        return !this.exited && this.child.stdin?.writable === true;
+    }
+    get sessionId() {
+        return this.threadId;
+    }
+    send(prompt, options) {
+        if (this.pending)
+            return Promise.resolve({ exitCode: 1, error: "engine session is already running a turn", sessionId: this.threadId });
+        if (!this.alive) {
+            const exitCode = this.exitCode || 1;
+            return Promise.resolve({ exitCode, error: failurePreview(exitCode, null, this.stderrTail, this.stdoutTail), sessionId: this.threadId });
+        }
+        return new Promise((resolve) => {
+            const pending = { resolve, timer: null };
+            if (SESSION_TIMEOUT_MS > 0) {
+                pending.timer = setTimeout(() => {
+                    this.stop();
+                    this.settle("engine session timed out", 124);
+                }, SESSION_TIMEOUT_MS);
+                pending.timer.unref?.();
+            }
+            this.pending = pending;
+            this.turnStart = { ...this.usage };
+            if (this.ready && this.threadId)
+                this.startTurn(prompt, options);
+            else
+                this.queuedTurn = { prompt, options };
+        });
+    }
+    steer(text) {
+        if (!this.threadId || !this.activeTurnId || this.steerGate || !this.alive || !text.trim())
+            return;
+        this.req("turn/steer", {
+            threadId: this.threadId,
+            expectedTurnId: this.activeTurnId,
+            input: codexUserInput(text)
+        });
+    }
+    stop() {
+        this.exited = true;
+        this.child.stdin?.end();
+        this.child.kill("SIGTERM");
+    }
+    nextId() {
+        this.reqId += 1;
+        return this.reqId;
+    }
+    req(method, params) {
+        const id = this.nextId();
+        this.child.stdin?.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
+        return id;
+    }
+    notify(method, params) {
+        this.child.stdin?.write(JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n");
+    }
+    threadParams() {
+        return {
+            cwd: this.opts.home,
+            approvalPolicy: "never",
+            sandbox: "danger-full-access",
+            experimentalRawEvents: true,
+            ...(this.opts.standingPrompt ? { developerInstructions: this.opts.standingPrompt } : {}),
+            ...(this.opts.model ? { model: this.opts.model } : {})
+        };
+    }
+    startThread() {
+        const params = this.threadParams();
+        this.threadWasResume = !!this.threadId;
+        this.threadReqId = this.threadId
+            ? this.req("thread/resume", { threadId: this.threadId, ...params })
+            : this.req("thread/start", params);
+    }
+    startTurn(prompt, options) {
+        if (!this.threadId)
+            return;
+        this.req("turn/start", { threadId: this.threadId, input: codexUserInput(prompt, options?.imagePaths) });
+    }
+    onStdout(buf) {
+        this.outBuf += buf.toString("utf8");
+        let nl;
+        while ((nl = this.outBuf.indexOf("\n")) >= 0) {
+            const raw = this.outBuf.slice(0, nl);
+            this.outBuf = this.outBuf.slice(nl + 1);
+            const line = cleanLine(raw);
+            if (!line)
+                continue;
+            pushTail(this.stdoutTail, line);
+            let msg;
+            try {
+                msg = JSON.parse(line);
+            }
+            catch {
+                this.opts.onLog(line);
+                continue;
+            }
+            if (process.env.KING_AI_CODEX_VERBOSE === "1")
+                this.opts.onLog(line);
+            this.handle(msg);
+        }
+    }
+    handle(msg) {
+        if (msg.id === this.initializeId) {
+            this.initializeId = null;
+            if (msg.error)
+                return this.settle(errorMessage(msg.error, "codex initialize failed"));
+            this.notify("initialized", {});
+            this.startThread();
+            return;
+        }
+        if (msg.id === this.threadReqId && msg.error) {
+            if (this.threadWasResume) {
+                this.opts.onLog(`[codex] thread/resume failed (${errorMessage(msg.error, "unknown error")}) - starting a fresh thread`);
+                this.threadId = null;
+                this.threadWasResume = false;
+                this.startThread();
+                return;
+            }
+            this.threadReqId = null;
+            this.settle(errorMessage(msg.error, "codex thread start failed"));
+            return;
+        }
+        const method = typeof msg.method === "string" ? msg.method : "";
+        if (method === "error") {
+            this.settle(errorMessage(msg.params, "codex app-server error"));
+            return;
+        }
+        if (msg.error) {
+            this.settle(errorMessage(msg.error, "codex app-server error"));
+            return;
+        }
+        const reduced = reduceCodexAppEvent({ activeTurnId: this.activeTurnId, steerGate: this.steerGate }, msg);
+        for (const line of reduced.logs)
+            this.opts.onLog(line);
+        this.activeTurnId = reduced.activeTurnId;
+        this.steerGate = reduced.steerGate;
+        if (reduced.usage)
+            this.updateUsage(reduced.usage);
+        if (reduced.threadId) {
+            this.threadId = reduced.threadId;
+            this.threadReqId = null;
+            this.threadWasResume = false;
+            this.ready = true;
+            if (this.queuedTurn && this.pending) {
+                const queued = this.queuedTurn;
+                this.queuedTurn = null;
+                this.startTurn(queued.prompt, queued.options);
+            }
+        }
+        if (method === "turn/completed") {
+            this.settle(reduced.turnCompletedError);
+        }
+    }
+    updateUsage(total) {
+        if (!total || typeof total !== "object")
+            return;
+        const rec = total;
+        const num = (value) => (typeof value === "number" && Number.isFinite(value) ? value : 0);
+        this.usage = {
+            input: Math.max(this.usage.input, num(rec.inputTokens)),
+            cached: Math.max(this.usage.cached, num(rec.cachedInputTokens)),
+            output: Math.max(this.usage.output, num(rec.outputTokens) + num(rec.reasoningOutputTokens))
+        };
+    }
+    turnUsage() {
+        const inputTotal = Math.max(0, this.usage.input - this.turnStart.input);
+        const cached = Math.max(0, this.usage.cached - this.turnStart.cached);
+        return {
+            input_tokens: Math.max(0, inputTotal - cached),
+            cache_read_input_tokens: cached,
+            output_tokens: Math.max(0, this.usage.output - this.turnStart.output)
+        };
+    }
+    settle(error, exitCode = error ? 1 : 0) {
+        const pending = this.pending;
+        this.pending = null;
+        if (!pending)
+            return;
+        if (pending.timer)
+            clearTimeout(pending.timer);
+        pending.resolve({
+            exitCode,
+            error,
+            sessionId: this.threadId,
+            usage: this.turnUsage(),
+            model: this.opts.model ?? null
+        });
+    }
+    die(exitCode, error) {
+        this.exited = true;
+        this.exitCode = exitCode;
+        const detail = failurePreview(exitCode, null, this.stderrTail, this.stdoutTail);
+        this.settle(detail || error, exitCode);
+    }
+}
+class ClaudeAdapter {
+    id = "claude";
+    bin = "claude";
+    async seedHome(home, persona) {
+        await ensureCommonHome(home);
+        await mkdir(join(home, ".claude", "skills"), { recursive: true });
+        const claudeMd = join(home, "CLAUDE.md");
+        if (!(await exists(claudeMd)))
+            await writeFile(claudeMd, personaHeader(persona), "utf8");
+    }
+    async classify(args) {
+        const extra = envExtraArgs("KING_AI_TRIAGE_ARGS");
+        const model = ["--model", args.model || "haiku"];
+        const { command, shell, wantsStdinPrompt } = resolveSpawn(this.bin);
+        const usingJson = extra.length === 0;
+        const base = extra.length ? [...extra, "-p"] : ["-p", ...model, "--output-format", "json", "--dangerously-skip-permissions", "--strict-mcp-config"];
+        const argv = wantsStdinPrompt ? base : extra.length ? [...base, args.prompt] : ["-p", args.prompt, ...base.slice(1)];
+        const res = await spawnCapture(command, argv, {
+            cwd: args.cwd,
+            env: { ...args.env, MAX_THINKING_TOKENS: "0" },
+            signal: args.signal,
+            shell,
+            stdinText: wantsStdinPrompt ? args.prompt : undefined,
+            onLog: args.onLog
+        });
+        if (res.error || !usingJson)
+            return res;
+        try {
+            const parsed = JSON.parse(res.text);
+            return { text: parsed.result ?? res.text, usage: parsed.usage };
+        }
+        catch {
+            return res;
+        }
+    }
+    probe(args) {
+        const model = args.tier === "small" ? ["--model", "haiku"] : [];
+        const { command, shell, wantsStdinPrompt } = resolveSpawn(this.bin);
+        const base = ["-p", ...model, "--output-format", "text", "--dangerously-skip-permissions", "--strict-mcp-config"];
+        const argv = wantsStdinPrompt ? base : ["-p", DOCTOR_PROMPT, ...base.slice(1)];
+        return spawnCapture(command, argv, {
+            cwd: args.cwd,
+            env: { ...args.env, MAX_THINKING_TOKENS: "0" },
+            signal: args.signal,
+            shell,
+            stdinText: wantsStdinPrompt ? DOCTOR_PROMPT : undefined
+        });
+    }
+    run(args) {
+        const extra = envExtraArgs("KING_AI_CLAUDE_ARGS");
+        const model = args.model ? ["--model", args.model] : [];
+        const resume = args.resumeSessionId ? ["--resume", args.resumeSessionId] : [];
+        const { command, shell, wantsStdinPrompt } = resolveSpawn(this.bin);
+        const base = extra.length ? [...extra, ...resume, "-p"] : ["-p", ...resume, ...model, "--output-format", "stream-json", "--verbose", "--dangerously-skip-permissions"];
+        const argv = wantsStdinPrompt ? base : extra.length ? [...base, args.prompt] : ["-p", args.prompt, ...base.slice(1)];
+        const env = { ...args.env, MAX_THINKING_TOKENS: args.env.MAX_THINKING_TOKENS ?? "0" };
+        if (args.fastModel)
+            env.ANTHROPIC_SMALL_FAST_MODEL = args.fastModel;
+        return spawnEngine(command, argv, {
+            ...args,
+            env,
+            shell,
+            stdinText: wantsStdinPrompt ? args.prompt : undefined
+        });
+    }
+    startSession(args) {
+        if (IS_WIN || envExtraArgs("KING_AI_CLAUDE_ARGS").length)
+            return null;
+        const model = args.model ? ["--model", args.model] : [];
+        const resume = args.resumeSessionId ? ["--resume", args.resumeSessionId] : [];
+        const standingFile = join(args.home, ".king-ai-standing-prompt.md");
+        let systemPrompt = [];
+        let carriesStandingPrompt = false;
+        if (args.standingPrompt) {
+            try {
+                writeFileSync(standingFile, args.standingPrompt, { mode: 0o600 });
+                systemPrompt = ["--append-system-prompt-file", standingFile];
+                carriesStandingPrompt = true;
+            }
+            catch {
+                systemPrompt = [];
+            }
+        }
+        const argv = [
+            "-p",
+            "--input-format",
+            "stream-json",
+            "--output-format",
+            "stream-json",
+            "--verbose",
+            ...resume,
+            ...systemPrompt,
+            ...model,
+            "--dangerously-skip-permissions"
+        ];
+        const env = { ...args.env, MAX_THINKING_TOKENS: args.env.MAX_THINKING_TOKENS ?? "0" };
+        if (args.fastModel)
+            env.ANTHROPIC_SMALL_FAST_MODEL = args.fastModel;
+        return new ClaudeSession(this.bin, argv, { ...args, env }, carriesStandingPrompt);
+    }
+}
+class CodexAdapter {
+    id = "codex";
+    bin = "codex";
+    async seedHome(home, persona) {
+        await ensureCommonHome(home);
+        const agentsMd = join(home, "AGENTS.md");
+        if (!(await exists(agentsMd)))
+            await writeFile(agentsMd, personaHeader(persona), "utf8");
+    }
+    classify(args) {
+        const extra = envExtraArgs("KING_AI_TRIAGE_ARGS");
+        const model = ["--model", args.model || "gpt-5.4-mini"];
+        const { command, shell } = resolveSpawn(this.bin);
+        const argv = extra.length ? ["exec", ...extra, args.prompt] : ["exec", ...model, "--skip-git-repo-check", args.prompt];
+        return spawnCapture(command, argv, {
+            cwd: args.cwd,
+            env: args.env,
+            signal: args.signal,
+            shell,
+            onLog: args.onLog
+        });
+    }
+    probe(args) {
+        const model = args.tier === "small" ? ["--model", "gpt-5.4-mini"] : [];
+        const { command, shell } = resolveSpawn(this.bin);
+        return spawnCapture(command, ["exec", ...model, "--skip-git-repo-check", DOCTOR_PROMPT], {
+            cwd: args.cwd,
+            env: args.env,
+            signal: args.signal,
+            shell
+        });
+    }
+    run(args) {
+        const extra = envExtraArgs("KING_AI_CODEX_ARGS");
+        const model = args.model ? ["--model", args.model] : [];
+        const { command, shell } = resolveSpawn(this.bin);
+        const base = extra.length ? extra : ["--dangerously-bypass-approvals-and-sandbox", "--skip-git-repo-check"];
+        return spawnEngine(command, ["exec", ...model, ...codexImageArgs(args.imagePaths), ...base, args.prompt], {
+            ...args,
+            shell
+        });
+    }
+    startSession(args) {
+        if (IS_WIN ||
+            envExtraArgs("KING_AI_CODEX_ARGS").length ||
+            process.env.KING_AI_CODEX_NO_APP_SERVER === "1")
+            return null;
+        try {
+            ensureGitRepoForCodex(args.home);
+        }
+        catch (err) {
+            args.onLog(`[codex] could not initialize git repo for app-server: ${err instanceof Error ? err.message : String(err)}`);
+            return null;
+        }
+        return new CodexSession(this.bin, ["app-server", "--listen", "stdio://"], args);
+    }
+}
+export const ADAPTERS = {
+    claude: new ClaudeAdapter(),
+    codex: new CodexAdapter()
+};
+export function getAdapter(id) {
+    return ADAPTERS[id];
+}
+export async function detectEngines() {
+    const entries = await Promise.all(Object.keys(ADAPTERS).map(async (id) => ((await binOnPath(ADAPTERS[id].bin)) ? id : null)));
+    return entries.filter((id) => id != null);
+}
+function parseResponseMode(value) {
+    return value === "me" || value === "each" || value === "one-of-us" ? value : undefined;
+}
+function extractJsonObject(text) {
+    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    const body = fenced ? fenced[1] : text;
+    const start = body.indexOf("{");
+    const end = body.lastIndexOf("}");
+    return start >= 0 && end > start ? body.slice(start, end + 1) : body.trim();
+}
+function salvageTriage(text) {
+    const actionable = text.match(/"actionable"\s*:\s*(true|false)/i);
+    if (!actionable)
+        return null;
+    const reason = text.match(/"reason"\s*:\s*"((?:[^"\\]|\\.)*)"/i);
+    const promptNote = text.match(/"prompt_?note"\s*:\s*"((?:[^"\\]|\\.)*)"/i);
+    const responseMode = text.match(/"response_?mode"\s*:\s*"(me|each|one-of-us)"/i);
+    return {
+        actionable: actionable[1].toLowerCase() === "true",
+        reason: reason ? reason[1].replace(/\\"/g, '"').slice(0, 500) : "recovered from partial triage output",
+        promptNote: promptNote ? promptNote[1].replace(/\\"/g, '"').slice(0, 1200) : undefined,
+        responseMode: parseResponseMode(responseMode?.[1])
+    };
+}
+export function parseTriage(text) {
+    const cleaned = stripLoneSurrogates(text).trim();
+    const raw = extractJsonObject(cleaned);
+    try {
+        const obj = JSON.parse(raw);
+        if (typeof obj.actionable !== "boolean")
+            return salvageTriage(cleaned);
+        return {
+            actionable: obj.actionable,
+            reason: typeof obj.reason === "string" ? obj.reason.slice(0, 500) : undefined,
+            promptNote: typeof obj.promptNote === "string" ? obj.promptNote.slice(0, 1200) : typeof obj.prompt_note === "string" ? obj.prompt_note.slice(0, 1200) : undefined,
+            responseMode: parseResponseMode(obj.responseMode ?? obj.response_mode)
+        };
+    }
+    catch {
+        return salvageTriage(cleaned);
+    }
+}