@shuind/dsh-codex-harness 0.1.7

package/lib/index.js

@@ -0,0 +1,843 @@
+import z from "@deepseek-ai/schemastery";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { randomBytes } from "node:crypto";
+import { resolve } from "node:path";
+String.raw`start: begin_patch hunk+ end_patch
+begin_patch: "*** Begin Patch" LF
+end_patch: "*** End Patch" LF?
+hunk: add_hunk | delete_hunk | update_hunk
+add_hunk: "*** Add File: " filename LF add_line+
+delete_hunk: "*** Delete File: " filename LF
+update_hunk: "*** Update File: " filename LF change_move? change?
+filename: /(.+)/
+add_line: "+" /(.*)/ LF -> line
+change_move: "*** Move to: " filename LF
+change: (change_context | change_line)+ eof_line?
+change_context: ("@@" | "@@ " /(.+)/) LF
+change_line: ("+" | "-" | " ") /(.*)/ LF
+eof_line: "*** End of File" LF
+%import common.LF
+`;
+function invalid(message) {
+	throw new Error(`apply_patch: ${message}`);
+}
+function isFileHeader(line) {
+	const trimmed = line.trim();
+	return trimmed.startsWith("*** Add File: ") || trimmed.startsWith("*** Delete File: ") || trimmed.startsWith("*** Update File: ");
+}
+function pathFrom(line, prefix) {
+	const path = line.slice(prefix.length).trim();
+	if (path.length === 0) invalid(`${prefix.trim()} requires a file path`);
+	return path;
+}
+function isChangeMarker(line) {
+	const marker = line.trimEnd();
+	return marker === "@@" || marker.startsWith("@@ ");
+}
+function isPotentialChangeMarker(line) {
+	return line.trimEnd().startsWith("@@");
+}
+/** Parse one complete Codex patch after normalizing CRLF input to LF. */
+function parsePatch(input) {
+	const lines = input.replaceAll("\r\n", "\n").trim().split("\n");
+	if (lines[0]?.trim() !== "*** Begin Patch") invalid("input must start with \"*** Begin Patch\"");
+	if (lines.at(-1)?.trim() !== "*** End Patch") invalid("input must end with \"*** End Patch\"");
+	const files = [];
+	let index = 1;
+	const end = lines.length - 1;
+	while (index < end) {
+		const header = lines[index++]?.trim();
+		if (header === void 0) invalid("unexpected end of input");
+		if (header.startsWith("*** Add File: ")) {
+			const path = pathFrom(header, "*** Add File: ");
+			const content = [];
+			while (index < end && lines[index]?.startsWith("+") === true) {
+				content.push(lines[index].slice(1));
+				index++;
+			}
+			if (content.length === 0) invalid(`add file ${JSON.stringify(path)} needs at least one content line`);
+			files.push({
+				kind: "add",
+				path,
+				content: `${content.join("\n")}\n`
+			});
+			continue;
+		}
+		if (header.startsWith("*** Delete File: ")) {
+			files.push({
+				kind: "delete",
+				path: pathFrom(header, "*** Delete File: ")
+			});
+			continue;
+		}
+		if (!header.startsWith("*** Update File: ")) invalid(`unexpected directive ${JSON.stringify(header)}`);
+		const path = pathFrom(header, "*** Update File: ");
+		let moveTo;
+		if (lines[index]?.trim().startsWith("*** Move to: ") === true) {
+			moveTo = pathFrom(lines[index].trim(), "*** Move to: ");
+			index++;
+		}
+		const hunks = [];
+		while (index < end && !isFileHeader(lines[index])) {
+			const patchLines = [];
+			let context;
+			if (isPotentialChangeMarker(lines[index])) {
+				const marker = lines[index].trimEnd();
+				if (!isChangeMarker(marker)) invalid(`invalid update hunk marker ${JSON.stringify(lines[index])}`);
+				index++;
+				context = marker.length === 2 ? void 0 : marker.slice(3);
+			}
+			while (index < end && !isFileHeader(lines[index]) && !isPotentialChangeMarker(lines[index]) && lines[index].trimEnd() !== "*** End of File") {
+				const line = lines[index++];
+				const kind = line[0];
+				if (kind !== " " && kind !== "+" && kind !== "-") invalid(`unexpected update line ${JSON.stringify(line)}`);
+				patchLines.push({
+					kind: kind === " " ? "context" : kind === "+" ? "add" : "delete",
+					text: line.slice(1)
+				});
+			}
+			const endOfFile = lines[index]?.trimEnd() === "*** End of File";
+			if (endOfFile) index++;
+			if (patchLines.length === 0) {
+				if (context !== void 0 || endOfFile) invalid("an update hunk needs context or changed lines");
+				break;
+			}
+			hunks.push({
+				...context === void 0 ? {} : { context },
+				lines: patchLines,
+				endOfFile
+			});
+		}
+		if (hunks.length === 0 && moveTo === void 0) invalid(`update file ${JSON.stringify(path)} has no changes`);
+		files.push({
+			kind: "update",
+			path,
+			...moveTo === void 0 ? {} : { moveTo },
+			hunks
+		});
+	}
+	if (files.length === 0) invalid("no files were modified");
+	return files;
+}
+function splitText(text) {
+	if (text.length === 0) return {
+		lines: [],
+		trailingNewline: false
+	};
+	const trailingNewline = text.endsWith("\n");
+	const lines = text.split("\n");
+	if (trailingNewline) lines.pop();
+	return {
+		lines,
+		trailingNewline
+	};
+}
+function joinText(value) {
+	const body = value.lines.join("\n");
+	return value.trailingNewline ? `${body}\n` : body;
+}
+function findSequence(lines, expected, from, endOfFile) {
+	if (expected.length === 0) return Math.min(from, lines.length);
+	if (expected.length > lines.length) return -1;
+	const first = endOfFile ? Math.max(from, lines.length - expected.length) : from;
+	const last = lines.length - expected.length;
+	const matchers = [
+		(actual, wanted) => actual === wanted,
+		(actual, wanted) => actual.trimEnd() === wanted.trimEnd(),
+		(actual, wanted) => actual.trim() === wanted.trim()
+	];
+	for (const matchesLine of matchers) for (let index = first; index <= last; index++) {
+		let matches = true;
+		for (let offset = 0; offset < expected.length; offset++) if (!matchesLine(lines[index + offset], expected[offset])) {
+			matches = false;
+			break;
+		}
+		if (matches) return index;
+	}
+	return -1;
+}
+/** Apply parsed update hunks and return LF-normalized text. */
+function applyPatchHunks(original, hunks) {
+	const value = splitText(original.replaceAll("\r\n", "\n"));
+	let cursor = 0;
+	for (const hunk of hunks) {
+		const expected = hunk.lines.filter((line) => line.kind !== "add").map((line) => line.text);
+		const start = findSequence(value.lines, expected, cursor, hunk.endOfFile);
+		if (start < 0) {
+			const detail = expected.join("\n");
+			invalid(`could not find expected lines${detail.length === 0 ? "" : `:\n${detail}`}`);
+		}
+		const replacement = hunk.lines.filter((line) => line.kind !== "delete").map((line) => line.text);
+		value.lines.splice(start, expected.length, ...replacement);
+		cursor = start + replacement.length;
+		value.trailingNewline = !hunk.endOfFile;
+	}
+	return joinText(value);
+}
+//#endregion
+//#region lib/types/exec.js
+/** Codex `exec_command` and `write_stdin` execution over dsh capability seams. */
+const STATES = /* @__PURE__ */ new WeakMap();
+function stateFor(agent) {
+	const current = STATES.get(agent);
+	if (current !== void 0) return current;
+	const created = {
+		nextId: 0,
+		sessions: /* @__PURE__ */ new Map()
+	};
+	STATES.set(agent, created);
+	return created;
+}
+function positiveFinite(name, value) {
+	if (value !== void 0 && (!Number.isFinite(value) || value < 0)) throw new Error(`${name} must be a non-negative finite number`);
+}
+function waitMs(value, fallback) {
+	return Math.max(0, Math.min(3e4, Math.trunc(value ?? fallback)));
+}
+function outputLimit(maxOutputBytes, maxOutputTokens) {
+	if (maxOutputTokens === void 0) return maxOutputBytes;
+	positiveFinite("max_output_tokens", maxOutputTokens);
+	return Math.max(1, Math.min(maxOutputBytes, Math.trunc(maxOutputTokens * 4)));
+}
+function limitOutput(text, maxBytes) {
+	if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
+	let end = Math.min(text.length, maxBytes);
+	while (end > 0 && Buffer.byteLength(text.slice(0, end), "utf8") > maxBytes) end--;
+	return `${text.slice(0, end)}\n[output truncated]`;
+}
+function newChunkId() {
+	return randomBytes(3).toString("hex");
+}
+function withChunkId(result) {
+	return {
+		chunk_id: newChunkId(),
+		...result
+	};
+}
+/** Render the ordinary Responses tool result text used by Codex's unified exec tools. */
+function renderExecResult(result) {
+	const sections = [];
+	if (result.chunk_id !== void 0) sections.push(`Chunk ID: ${result.chunk_id}`);
+	sections.push(`Wall time: ${result.wall_time_seconds.toFixed(4)} seconds`);
+	if (result.exit_code !== void 0) sections.push(`Process exited with code ${result.exit_code}`);
+	if (result.session_id !== void 0) sections.push(`Process running with session ID ${result.session_id}`);
+	if (result.original_token_count !== void 0) sections.push(`Original token count: ${result.original_token_count}`);
+	sections.push("Output:", result.output);
+	return sections.join("\n");
+}
+function sessionCwd$1(exec, workdir) {
+	const base = exec.agent?.session.header.cwd ?? process.cwd();
+	if (workdir === void 0) return exec.agent?.session.header.cwd;
+	return resolve(base, workdir);
+}
+function readShellOutput(read, maxBytes) {
+	return limitOutput(read.delta, maxBytes);
+}
+function terminalResult(result, maxBytes, startedAt) {
+	const output = limitOutput(result.viewport, maxBytes);
+	return withChunkId({
+		wall_time_seconds: (performance.now() - startedAt) / 1e3,
+		output,
+		...result.sessionStatus.kind === "exited" ? { ...result.sessionStatus.exitCode === null ? {} : { exit_code: result.sessionStatus.exitCode } } : {}
+	});
+}
+function sleep(ms, signal) {
+	return new Promise((resolve) => {
+		let timer;
+		const finish = (result) => {
+			if (timer !== void 0) clearTimeout(timer);
+			signal.removeEventListener("abort", onAbort);
+			resolve(result);
+		};
+		const onAbort = () => finish("aborted");
+		if (signal.aborted) {
+			finish("aborted");
+			return;
+		}
+		signal.addEventListener("abort", onAbort, { once: true });
+		timer = setTimeout(() => finish("elapsed"), ms);
+	});
+}
+async function waitForShell(process, ms, signal) {
+	const timer = sleep(ms, signal);
+	const completed = await Promise.race([process.done.then(() => true), timer.then((result) => result === "aborted" ? false : void 0)]);
+	if (signal.aborted) signal.throwIfAborted();
+	return completed === true || process.status !== "running";
+}
+function allocateSession(agent, session) {
+	const state = stateFor(agent);
+	const id = ++state.nextId;
+	state.sessions.set(id, session);
+	return id;
+}
+function storedSession(agent, id) {
+	const session = stateFor(agent).sessions.get(id);
+	if (session === void 0) throw new Error(`unknown unified exec session ${id}`);
+	return session;
+}
+function forgetSession(agent, id) {
+	stateFor(agent).sessions.delete(id);
+}
+function commandFor(args) {
+	return args.cmd;
+}
+/** Execute one Codex command through the configured pipe or PTY capability. */
+async function runExecCommand(ctx, args, exec, config) {
+	if (args.cmd.trim().length === 0) throw new Error("cmd must be a non-empty string");
+	positiveFinite("yield_time_ms", args.yield_time_ms);
+	const maxBytes = outputLimit(config.maxOutputBytes, args.max_output_tokens);
+	const workdir = sessionCwd$1(exec, args.workdir);
+	const startedAt = performance.now();
+	if (args.tty === true) {
+		const agent = exec.agent;
+		const terminals = ctx.get("terminals");
+		if (agent === void 0 || terminals === void 0) throw new Error("exec_command with tty=true requires the dsh terminal capability and an owning agent session");
+		const spawnRequest = {
+			type: "shell",
+			...args.shell === void 0 ? {} : { shell: args.shell },
+			login: args.login ?? true,
+			...workdir === void 0 ? {} : { cwd: workdir }
+		};
+		const spawned = await terminals.spawn(agent, spawnRequest, exec.signal);
+		const sendRequest = {
+			text: commandFor(args),
+			submit: true,
+			waitMs: waitMs(args.yield_time_ms, config.defaultYieldTimeMs),
+			signal: exec.signal
+		};
+		const result = await terminals.startSend(agent, spawned.sessionId, sendRequest).done;
+		const output = terminalResult(result, maxBytes, startedAt);
+		if (result.sessionStatus.kind === "running") output.session_id = allocateSession(agent, {
+			kind: "terminal",
+			owner: agent,
+			id: spawned.sessionId
+		});
+		else await terminals.kill(agent, spawned.sessionId, "Codex command exited");
+		return output;
+	}
+	const policy = ctx.get("sandboxPolicy")?.resolve(exec.agent === void 0 ? {} : { session: exec.agent.session });
+	const dshEnv = ctx.get("shellEnv")?.collect(exec);
+	const shellRequest = {
+		command: commandFor(args),
+		...args.shell === void 0 ? {} : { shell: args.shell },
+		login: args.login ?? true,
+		...workdir === void 0 ? {} : { workdir },
+		stdoutMaxBytes: maxBytes,
+		...dshEnv === void 0 ? {} : { dshEnv },
+		...policy === void 0 ? {} : { sandboxPolicy: policy }
+	};
+	const process = ctx.shell.start(ctx.shell.resolve(shellRequest));
+	const completed = await waitForShell(process, waitMs(args.yield_time_ms, config.defaultYieldTimeMs), exec.signal);
+	const output = readShellOutput(process.readOutput(), maxBytes);
+	if (!completed || process.status === "running") {
+		if (exec.agent === void 0) {
+			process.kill();
+			await process.done;
+			return withChunkId({
+				wall_time_seconds: (performance.now() - startedAt) / 1e3,
+				output: readShellOutput(process.readOutput(), maxBytes)
+			});
+		}
+		return withChunkId({
+			wall_time_seconds: (performance.now() - startedAt) / 1e3,
+			output,
+			session_id: allocateSession(exec.agent, {
+				kind: "shell",
+				process
+			})
+		});
+	}
+	return withChunkId({
+		wall_time_seconds: (performance.now() - startedAt) / 1e3,
+		output,
+		...process.exitCode === null ? {} : { exit_code: process.exitCode }
+	});
+}
+/** Poll or write to one session returned by {@link runExecCommand}. */
+async function runWriteStdin(ctx, args, exec, config) {
+	positiveFinite("yield_time_ms", args.yield_time_ms);
+	if (!Number.isSafeInteger(args.session_id) || args.session_id <= 0) throw new Error("session_id must be a positive integer");
+	const agent = exec.agent;
+	if (agent === void 0) throw new Error("write_stdin requires an owning agent session");
+	const session = storedSession(agent, args.session_id);
+	const maxBytes = outputLimit(config.maxOutputBytes, args.max_output_tokens);
+	const startedAt = performance.now();
+	const chars = args.chars ?? "";
+	if (session.kind === "shell") {
+		if (chars.length > 0) throw new Error("this unified exec session uses pipes and does not accept stdin; rerun exec_command with tty=true");
+		const completed = await waitForShell(session.process, waitMs(args.yield_time_ms, config.pollYieldTimeMs), exec.signal);
+		const output = readShellOutput(session.process.readOutput(), maxBytes);
+		if (completed && session.process.status !== "running") {
+			forgetSession(agent, args.session_id);
+			return withChunkId({
+				wall_time_seconds: (performance.now() - startedAt) / 1e3,
+				output,
+				...session.process.exitCode === null ? {} : { exit_code: session.process.exitCode }
+			});
+		}
+		return withChunkId({
+			wall_time_seconds: (performance.now() - startedAt) / 1e3,
+			output,
+			session_id: args.session_id
+		});
+	}
+	const terminals = ctx.get("terminals");
+	if (terminals === void 0) throw new Error("the dsh terminal capability is no longer available");
+	const sendRequest = {
+		text: chars,
+		submit: false,
+		waitMs: waitMs(args.yield_time_ms, chars.length > 0 ? config.writeYieldTimeMs : config.pollYieldTimeMs),
+		signal: exec.signal
+	};
+	const result = await terminals.startSend(agent, session.id, sendRequest).done;
+	const output = terminalResult(result, maxBytes, startedAt);
+	if (result.sessionStatus.kind === "running") output.session_id = args.session_id;
+	else {
+		forgetSession(agent, args.session_id);
+		await terminals.kill(agent, session.id, "Codex command exited");
+	}
+	return output;
+}
+//#endregion
+//#region lib/types/index.js
+/** Codex-compatible prompt overlay and core tools for a dsh agent preset. */
+const name = "codex";
+const inject = [
+	"tools",
+	"systemPrompt",
+	"shell",
+	"fs"
+];
+/** Runtime configuration schema for the Codex tool bridge. */
+const Config = z.object({
+	defaultYieldTimeMs: z.number().step(1).min(0).default(1e4),
+	pollYieldTimeMs: z.number().step(1).min(0).default(5e3),
+	writeYieldTimeMs: z.number().step(1).min(0).default(250),
+	maxOutputBytes: z.number().step(1).min(1).default(64e3)
+});
+const CODEX_BASE_PROMPT = String.raw`You are Codex, based on {{model}}. You are running as a coding agent in dsh Web on a user's computer.
+
+## General
+
+- When searching for text or files, prefer using rg or rg --files respectively because rg is much faster than alternatives like grep. If rg is not available, use the next best alternative.
+
+## Editing constraints
+
+- Default to ASCII when editing or creating files. Only introduce non-ASCII or other Unicode characters when there is a clear justification and the file already uses them.
+- Add succinct code comments that explain non-obvious code. Do not add comments that merely narrate assignments or control flow.
+- Use apply_patch for single-file edits when practical. The apply_patch tool accepts its freeform patch language; do not wrap that patch in JSON.
+- You may be in a dirty git worktree. Never revert existing changes you did not make unless the user explicitly requests it. If unrelated files are changed, leave them alone.
+
+## Planning
+
+- Use update_plan for work with multiple meaningful steps. Keep the plan current as the task progresses.
+- Do not use a plan for a trivial one-step request.
+
+## dsh session
+
+- The user and you share one workspace. Inspect the repository and every applicable AGENTS.md before editing.
+- This session's preset was selected when the session was created and stays fixed for its lifetime. Do not attempt to switch the preset or replace its tool catalog while the session is running.
+- dsh provides the execution, filesystem, session, policy, and Skills capabilities behind these tools. Use those extension points as supplied; do not invent a second harness or bypass the filesystem service for file edits.
+- The core Codex tool names, arguments, and result formats are fixed: use exec_command for terminal work, write_stdin for an existing interactive command, apply_patch for file changes, and update_plan for multi-step tasks.
+
+## Task execution
+
+- Keep the user informed with concise progress updates and lead with the result.
+- Prefer existing functions and extension points over new machinery.
+- Do not claim that a command, edit, or test succeeded unless it actually succeeded.
+- Use the exact tool names and argument formats supplied by this session; do not invent replacement editing tools.
+
+## Presenting your work
+
+- Be concise, direct, friendly, and actionable.
+- For substantial work, explain what changed and why, then mention relevant verification and next steps.
+- Do not dump large files into the conversation; refer to their paths.
+- Use plain text with short sections only when they improve scanability.
+`;
+const EXEC_COMMAND_DESCRIPTION = "Runs a command in a PTY, returning output or a session ID for ongoing interaction.";
+const WRITE_STDIN_DESCRIPTION = "Writes characters to an existing unified exec session and returns recent output.";
+const APPLY_PATCH_DESCRIPTION = "The `apply_patch` tool can be used to edit files. This is a FREEFORM tool, so do not wrap the patch in JSON.";
+const UPDATE_PLAN_DESCRIPTION = "Updates the task plan.\nProvide an optional explanation and a list of plan items, each with a step and status.\nAt most one step can be in_progress at a time.";
+const PLAN_STATUSES = [
+	"pending",
+	"in_progress",
+	"completed"
+];
+function sessionCwd(exec) {
+	return exec.agent?.session.header.cwd;
+}
+function resolvePolicy(ctx, exec) {
+	return ctx.get("sandboxPolicy")?.resolve(exec.agent === void 0 ? {} : { session: exec.agent.session });
+}
+async function resolveTarget(ctx, path, exec) {
+	const cwd = sessionCwd(exec);
+	return ctx.fs.resolve(path, cwd === void 0 ? { signal: exec.signal } : {
+		cwd,
+		signal: exec.signal
+	});
+}
+async function observedTarget(ctx, target, exec) {
+	const info = await ctx.fs.stat(target, exec.signal);
+	if (info === void 0) throw new Error(`apply_patch: file not found: ${target.displayPath}`);
+	if (info.type !== "file") throw new Error(`apply_patch: not a regular file: ${target.displayPath}`);
+	ctx.emit("fs/observed", target, {
+		kind: "present",
+		version: info.version
+	}, exec);
+	return info;
+}
+async function writePatchedFile(ctx, target, content, fallback, exec, policy) {
+	const intent = await ctx.waterfall("fs/write-intent", target, exec, () => fallback);
+	const outcome = await ctx.fs.writeText(target, content, intent, exec.signal, policy);
+	ctx.emit("fs/observed", target, {
+		kind: "present",
+		version: outcome.version
+	}, exec);
+	return outcome.operation === "create" ? "created" : "updated";
+}
+async function deletePatchedFile(ctx, target, version, exec, policy) {
+	const remove = ctx.fs.remove;
+	if (typeof remove !== "function") throw new Error("apply_patch: the configured dsh filesystem does not support file deletion");
+	await remove.call(ctx.fs, target, { version }, exec.signal, policy);
+	ctx.emit("fs/observed", target, { kind: "absent" }, exec);
+}
+async function applyOnePatch(ctx, file, exec, policy) {
+	const target = await resolveTarget(ctx, file.path, exec);
+	if (file.kind === "add") {
+		if (await ctx.fs.stat(target, exec.signal) !== void 0) throw new Error(`apply_patch: file already exists: ${target.displayPath}`);
+		ctx.emit("fs/observed", target, { kind: "absent" }, exec);
+		await writePatchedFile(ctx, target, file.content, { kind: "createIfAbsent" }, exec, policy);
+		return {
+			path: file.path,
+			operation: "created"
+		};
+	}
+	const sourceInfo = await observedTarget(ctx, target, exec);
+	const original = await ctx.fs.readText(target, exec.signal);
+	const updated = file.kind === "delete" ? void 0 : applyPatchHunks(original, file.hunks);
+	if (file.kind === "delete") {
+		await deletePatchedFile(ctx, target, sourceInfo.version, exec, policy);
+		return {
+			path: file.path,
+			operation: "deleted"
+		};
+	}
+	if (file.moveTo === void 0) {
+		await writePatchedFile(ctx, target, updated, {
+			kind: "replaceIfVersion",
+			version: sourceInfo.version
+		}, exec, policy);
+		return {
+			path: file.path,
+			operation: "updated"
+		};
+	}
+	const destination = await resolveTarget(ctx, file.moveTo, exec);
+	if (destination.targetKey === target.targetKey) {
+		await writePatchedFile(ctx, target, updated, {
+			kind: "replaceIfVersion",
+			version: sourceInfo.version
+		}, exec, policy);
+		return {
+			path: file.path,
+			operation: "updated",
+			moveTo: file.moveTo
+		};
+	}
+	if (await ctx.fs.stat(destination, exec.signal) !== void 0) throw new Error(`apply_patch: move destination already exists: ${destination.displayPath}`);
+	ctx.emit("fs/observed", destination, { kind: "absent" }, exec);
+	await writePatchedFile(ctx, destination, updated, { kind: "createIfAbsent" }, exec, policy);
+	await deletePatchedFile(ctx, target, sourceInfo.version, exec, policy);
+	return {
+		path: file.path,
+		operation: "moved",
+		moveTo: file.moveTo
+	};
+}
+function patchSummary(value) {
+	const letter = (operation) => {
+		switch (operation) {
+			case "created": return "A";
+			case "updated": return "M";
+			case "deleted": return "D";
+			case "moved": return "M";
+			default: return operation;
+		}
+	};
+	return `Success. Updated the following files:\n${value.files.map((file) => `${letter(file.operation)} ${file.operation === "moved" ? file.moveTo : file.path}`).join("\n")}\n`;
+}
+function planTodos(args) {
+	const seen = /* @__PURE__ */ new Set();
+	let active = 0;
+	const todos = [];
+	for (const item of args.plan) {
+		const content = item.step.trim();
+		if (content.length === 0) throw new Error("update_plan: every step must be non-empty");
+		if (seen.has(content)) throw new Error(`update_plan: duplicate step ${JSON.stringify(content)}`);
+		seen.add(content);
+		if (item.status === "in_progress") active++;
+		todos.push({
+			content,
+			status: item.status
+		});
+	}
+	if (active > 1) throw new Error("update_plan: at most one step may be in_progress");
+	return todos;
+}
+function registerExecTools(ctx, config) {
+	ctx.tools.register(defineTool({
+		name: "exec_command",
+		description: EXEC_COMMAND_DESCRIPTION,
+		parameters: {
+			cmd: {
+				type: "string",
+				required: true,
+				description: "Shell command to execute."
+			},
+			workdir: {
+				type: "string",
+				description: "Working directory for the command. Defaults to the turn cwd."
+			},
+			tty: {
+				type: "boolean",
+				description: "True allocates a PTY for the command; false or omitted uses plain pipes."
+			},
+			yield_time_ms: {
+				type: "number",
+				description: "Wait before yielding output. Defaults to 10000 ms; effective range is 250-30000 ms."
+			},
+			max_output_tokens: {
+				type: "number",
+				description: "Output token budget. Defaults to 10000 tokens; larger requests may be capped by policy."
+			},
+			shell: {
+				type: "string",
+				description: "Shell binary to launch. Defaults to the user's default shell."
+			},
+			login: {
+				type: "boolean",
+				description: "True runs the shell with -l/-i semantics; false disables them. Defaults to true."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					chunk_id: { type: "string" },
+					wall_time_seconds: {
+						type: "number",
+						required: true
+					},
+					exit_code: { type: "number" },
+					session_id: { type: "number" },
+					original_token_count: { type: "number" },
+					output: {
+						type: "string",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: renderExecResult(value)
+			}]
+		},
+		async execute(args, exec) {
+			return runExecCommand(ctx, args, exec, config);
+		},
+		presentCall: (args) => ({
+			card: "terminal",
+			title: args.cmd,
+			...args.workdir === void 0 ? {} : { cwd: args.workdir }
+		})
+	}));
+	ctx.tools.register(defineTool({
+		name: "write_stdin",
+		description: WRITE_STDIN_DESCRIPTION,
+		parameters: {
+			session_id: {
+				type: "number",
+				required: true,
+				description: "Identifier of the running unified exec session."
+			},
+			chars: {
+				type: "string",
+				description: "Bytes to write to stdin. Defaults to empty, which polls without writing."
+			},
+			yield_time_ms: {
+				type: "number",
+				description: "Wait before yielding output. Non-empty writes default to 250 ms and cap at 30000 ms; empty polls wait 5000-300000 ms by default."
+			},
+			max_output_tokens: {
+				type: "number",
+				description: "Output token budget. Defaults to 10000 tokens; larger requests may be capped by policy."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					chunk_id: { type: "string" },
+					wall_time_seconds: {
+						type: "number",
+						required: true
+					},
+					exit_code: { type: "number" },
+					session_id: { type: "number" },
+					original_token_count: { type: "number" },
+					output: {
+						type: "string",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: renderExecResult(value)
+			}]
+		},
+		async execute(args, exec) {
+			return runWriteStdin(ctx, args, exec, config);
+		}
+	}));
+}
+function registerPatchTool(ctx) {
+	ctx.tools.register(defineTool({
+		name: "apply_patch",
+		description: APPLY_PATCH_DESCRIPTION,
+		parameters: { input: {
+			type: "string",
+			required: true,
+			description: "The complete patch text."
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: { files: {
+					type: "array",
+					required: true,
+					items: {
+						type: "object",
+						additionalProperties: false,
+						properties: {
+							path: {
+								type: "string",
+								required: true
+							},
+							operation: {
+								type: "string",
+								required: true,
+								enum: [
+									"created",
+									"updated",
+									"deleted",
+									"moved"
+								]
+							},
+							moveTo: { type: "string" }
+						}
+					}
+				} }
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: patchSummary(value)
+			}]
+		},
+		async execute(args, exec) {
+			const files = parsePatch(args.input);
+			const policy = resolvePolicy(ctx, exec);
+			const applied = [];
+			for (const file of files) applied.push(await applyOnePatch(ctx, file, exec, policy));
+			return { files: applied };
+		},
+		presentCall(args) {
+			return {
+				card: "generic",
+				title: "Apply patch",
+				kind: "edit",
+				rawInput: args.input
+			};
+		}
+	}));
+}
+function registerPlanTool(ctx) {
+	ctx.tools.register(defineTool({
+		name: "update_plan",
+		description: UPDATE_PLAN_DESCRIPTION,
+		parameters: {
+			explanation: {
+				type: "string",
+				description: "Optional explanation for this plan update."
+			},
+			plan: {
+				type: "array",
+				required: true,
+				description: "The list of steps",
+				items: {
+					type: "object",
+					additionalProperties: false,
+					properties: {
+						step: {
+							type: "string",
+							required: true,
+							description: "Task step text."
+						},
+						status: {
+							type: "string",
+							required: true,
+							enum: [...PLAN_STATUSES],
+							description: "Step status."
+						}
+					}
+				}
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {}
+			},
+			render: () => [{
+				type: "text",
+				text: "Plan updated"
+			}]
+		},
+		execute(args, exec) {
+			const agent = exec.agent;
+			if (agent === void 0) throw new Error("update_plan requires an owning agent session");
+			agent.session.append("todo/write", { todos: planTodos(args) });
+			return Promise.resolve({});
+		}
+	}));
+}
+/** Mount the Codex prompt/tool layer inside one fixed agent preset. */
+function apply(ctx, config = {}) {
+	const resolved = {
+		defaultYieldTimeMs: config.defaultYieldTimeMs ?? 1e4,
+		pollYieldTimeMs: config.pollYieldTimeMs ?? 5e3,
+		writeYieldTimeMs: config.writeYieldTimeMs ?? 250,
+		maxOutputBytes: config.maxOutputBytes ?? 64e3
+	};
+	if (ctx.fs.sandboxMode !== void 0 && ctx.get("sandboxPolicy") === void 0) throw new Error("codex: a sandboxing filesystem requires ctx.sandboxPolicy");
+	ctx.systemPrompt.section({
+		name: "codex:base",
+		order: 10,
+		text: CODEX_BASE_PROMPT
+	});
+	registerExecTools(ctx, resolved);
+	registerPatchTool(ctx);
+	registerPlanTool(ctx);
+}
+var types_default = {
+	name,
+	inject,
+	Config,
+	apply
+};
+//#endregion
+export { Config, apply, types_default as default, inject, name };