feat(cli): one-shot terminal client (models, chat, --text/--file/--cwd/--conversation)

HTTP client of transport-contract; pure-core arg/render/ndjson + injected fetch/fs shell.
Docs: GLOSSARY (credential/key/model name/model catalog), tasks.md milestone, ORCHESTRATOR geography.

14 files changed, 1007 insertions, 0 deletions

diff --git a/packages/cli/src/args.test.ts b/packages/cli/src/args.test.ts
new file mode 100644
index 0000000..02b9e9b
--- /dev/null
+++ b/packages/cli/src/args.test.ts
@@ -0,0 +1,140 @@
+import { describe, expect, it } from "vitest";
+import { parseArgs } from "./args.js";
+
+const defaultServer = "http://localhost:24203";
+
+describe("parseArgs", () => {
+	it("returns help for empty argv", () => {
+		expect(parseArgs([], { defaultServer })).toEqual({ kind: "help" });
+	});
+
+	it("returns help for --help", () => {
+		expect(parseArgs(["--help"], { defaultServer })).toEqual({ kind: "help" });
+	});
+
+	it("returns help for -h", () => {
+		expect(parseArgs(["-h"], { defaultServer })).toEqual({ kind: "help" });
+	});
+
+	describe("models", () => {
+		it("parses 'models' with default server", () => {
+			expect(parseArgs(["models"], { defaultServer })).toEqual({
+				kind: "models",
+				server: "http://localhost:24203",
+			});
+		});
+
+		it("parses 'models --server <url>'", () => {
+			expect(parseArgs(["models", "--server", "http://example.com"], { defaultServer })).toEqual({
+				kind: "models",
+				server: "http://example.com",
+			});
+		});
+
+		it("errors on unknown argument for models", () => {
+			const result = parseArgs(["models", "--foo"], { defaultServer });
+			expect(result.kind).toBe("error");
+			if (result.kind === "error") expect(result.message).toContain("Unknown argument");
+		});
+	});
+
+	describe("chat", () => {
+		it("parses a chat with --text", () => {
+			const result = parseArgs(["my-model", "--text", "hello"], { defaultServer });
+			expect(result).toEqual({
+				kind: "chat",
+				server: "http://localhost:24203",
+				modelName: "my-model",
+				text: "hello",
+				file: undefined,
+				cwd: undefined,
+				conversationId: undefined,
+				showReasoning: false,
+			});
+		});
+
+		it("parses a chat with --file", () => {
+			const result = parseArgs(["my-model", "--file", "foo.txt"], { defaultServer });
+			expect(result).toEqual({
+				kind: "chat",
+				server: "http://localhost:24203",
+				modelName: "my-model",
+				text: undefined,
+				file: "foo.txt",
+				cwd: undefined,
+				conversationId: undefined,
+				showReasoning: false,
+			});
+		});
+
+		it("parses a chat with both --text and --file", () => {
+			const result = parseArgs(["m", "--text", "hi", "--file", "f.txt"], { defaultServer });
+			expect(result).toMatchObject({ kind: "chat", text: "hi", file: "f.txt" });
+		});
+
+		it("parses --cwd, --conversation, --server, --show-reasoning", () => {
+			const result = parseArgs(
+				[
+					"m",
+					"--text",
+					"x",
+					"--cwd",
+					"/tmp",
+					"--conversation",
+					"abc",
+					"--server",
+					"http://s",
+					"--show-reasoning",
+				],
+				{ defaultServer },
+			);
+			expect(result).toEqual({
+				kind: "chat",
+				server: "http://s",
+				modelName: "m",
+				text: "x",
+				file: undefined,
+				cwd: "/tmp",
+				conversationId: "abc",
+				showReasoning: true,
+			});
+		});
+
+		it("errors when text and file are both missing", () => {
+			const result = parseArgs(["my-model"], { defaultServer });
+			expect(result.kind).toBe("error");
+			if (result.kind === "error") expect(result.message).toContain("--text or --file");
+		});
+
+		it("errors on unknown flag", () => {
+			const result = parseArgs(["my-model", "--text", "hi", "--bogus"], { defaultServer });
+			expect(result.kind).toBe("error");
+			if (result.kind === "error") expect(result.message).toContain("Unknown flag");
+		});
+
+		it("errors when --text has no value", () => {
+			const result = parseArgs(["m", "--text"], { defaultServer });
+			expect(result.kind).toBe("error");
+		});
+
+		it("errors when --file has no value", () => {
+			const result = parseArgs(["m", "--file"], { defaultServer });
+			expect(result.kind).toBe("error");
+		});
+
+		it("errors when --server has no value", () => {
+			const result = parseArgs(["models", "--server"], { defaultServer });
+			expect(result.kind).toBe("error");
+		});
+
+		it("errors when --cwd has no value", () => {
+			const result = parseArgs(["m", "--text", "x", "--cwd"], { defaultServer });
+			expect(result.kind).toBe("error");
+		});
+
+		it("errors when --conversation has no value", () => {
+			const result = parseArgs(["m", "--text", "x", "--conversation"], { defaultServer });
+			expect(result.kind).toBe("error");
+		});
+	});
+});
diff --git a/packages/cli/src/args.ts b/packages/cli/src/args.ts
new file mode 100644
index 0000000..2c554e8
--- /dev/null
+++ b/packages/cli/src/args.ts
@@ -0,0 +1,108 @@
+/**
+ * Pure argument parser — zero I/O, zero ambient state.
+ *
+ * Parses process.argv-style strings into a discriminated command union.
+ * Validates required flags and reports unknown flags as errors.
+ */
+
+export type ParsedCommand =
+	| { readonly kind: "models"; readonly server: string }
+	| {
+			readonly kind: "chat";
+			readonly server: string;
+			readonly modelName: string;
+			readonly text?: string | undefined;
+			readonly file?: string | undefined;
+			readonly cwd?: string | undefined;
+			readonly conversationId?: string | undefined;
+			readonly showReasoning: boolean;
+	  }
+	| { readonly kind: "help" }
+	| { readonly kind: "error"; readonly message: string };
+
+interface ParseOpts {
+	readonly defaultServer: string;
+}
+
+export function parseArgs(argv: readonly string[], opts: ParseOpts): ParsedCommand {
+	if (argv.length === 0) {
+		return { kind: "help" };
+	}
+
+	const first = argv[0] as string;
+
+	if (first === "--help" || first === "-h") {
+		return { kind: "help" };
+	}
+
+	if (first === "models") {
+		let server = opts.defaultServer;
+		for (let i = 1; i < argv.length; i++) {
+			if (argv[i] === "--server" && i + 1 < argv.length) {
+				server = argv[++i] as string;
+			} else {
+				return { kind: "error", message: `Unknown argument for 'models': ${argv[i]}` };
+			}
+		}
+		return { kind: "models", server };
+	}
+
+	// Chat mode: first arg is the model name
+	const modelName = first;
+	let text: string | undefined;
+	let file: string | undefined;
+	let cwd: string | undefined;
+	let conversationId: string | undefined;
+	let showReasoning = false;
+	let server = opts.defaultServer;
+
+	for (let i = 1; i < argv.length; i++) {
+		const arg = argv[i] as string;
+		switch (arg) {
+			case "--text":
+				if (i + 1 >= argv.length) return { kind: "error", message: "--text requires a value" };
+				text = argv[++i];
+				break;
+			case "--file":
+				if (i + 1 >= argv.length) return { kind: "error", message: "--file requires a value" };
+				file = argv[++i];
+				break;
+			case "--cwd":
+				if (i + 1 >= argv.length) return { kind: "error", message: "--cwd requires a value" };
+				cwd = argv[++i];
+				break;
+			case "--conversation":
+				if (i + 1 >= argv.length)
+					return { kind: "error", message: "--conversation requires a value" };
+				conversationId = argv[++i];
+				break;
+			case "--server":
+				if (i + 1 >= argv.length) return { kind: "error", message: "--server requires a value" };
+				server = argv[++i] as string;
+				break;
+			case "--show-reasoning":
+				showReasoning = true;
+				break;
+			default:
+				return { kind: "error", message: `Unknown flag: ${arg}` };
+		}
+	}
+
+	if (!text && !file) {
+		return {
+			kind: "error",
+			message: "At least one of --text or --file is required for a chat command",
+		};
+	}
+
+	return {
+		kind: "chat",
+		server,
+		modelName,
+		text,
+		file,
+		cwd,
+		conversationId,
+		showReasoning,
+	};
+}
diff --git a/packages/cli/src/catalog.test.ts b/packages/cli/src/catalog.test.ts
new file mode 100644
index 0000000..3b32efc
--- /dev/null
+++ b/packages/cli/src/catalog.test.ts
@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { formatCatalog } from "./catalog.js";
+
+describe("formatCatalog", () => {
+	it("formats a single model", () => {
+		expect(formatCatalog({ models: ["openai/gpt-4"] })).toBe("openai/gpt-4");
+	});
+
+	it("formats multiple models one per line", () => {
+		expect(formatCatalog({ models: ["openai/gpt-4", "anthropic/claude-3", "local/llama"] })).toBe(
+			"openai/gpt-4\nanthropic/claude-3\nlocal/llama",
+		);
+	});
+
+	it("returns empty string for empty models", () => {
+		expect(formatCatalog({ models: [] })).toBe("");
+	});
+});
diff --git a/packages/cli/src/catalog.ts b/packages/cli/src/catalog.ts
new file mode 100644
index 0000000..a2b0780
--- /dev/null
+++ b/packages/cli/src/catalog.ts
@@ -0,0 +1,11 @@
+/**
+ * Pure catalog formatter — zero I/O.
+ *
+ * Formats a ModelsResponse into one model name per line.
+ */
+
+import type { ModelsResponse } from "@dispatch/transport-contract";
+
+export function formatCatalog(r: ModelsResponse): string {
+	return r.models.join("\n");
+}
diff --git a/packages/cli/src/http.test.ts b/packages/cli/src/http.test.ts
new file mode 100644
index 0000000..becfdbb
--- /dev/null
+++ b/packages/cli/src/http.test.ts
@@ -0,0 +1,164 @@
+import type { AgentEvent } from "@dispatch/transport-contract";
+import { describe, expect, it } from "vitest";
+import { fetchModels, streamChat } from "./http.js";
+
+function ndjsonLines(...events: AgentEvent[]): string {
+	return `${events.map((e) => JSON.stringify(e)).join("\n")}\n`;
+}
+
+function makeFakeFetch(responseBody: string, headers?: Record<string, string>) {
+	const fn = async (_url: string | URL | Request, _init?: RequestInit): Promise<Response> => {
+		const encoder = new TextEncoder();
+		const chunks = responseBody.split("|||");
+		let i = 0;
+		const stream = new ReadableStream<Uint8Array>({
+			pull(controller) {
+				if (i < chunks.length) {
+					const chunk = chunks[i];
+					if (chunk !== undefined) controller.enqueue(encoder.encode(chunk));
+					i++;
+				} else {
+					controller.close();
+				}
+			},
+		});
+		return new Response(stream, {
+			status: 200,
+			headers: headers ?? {},
+		});
+	};
+	return fn as unknown as typeof fetch;
+}
+
+describe("streamChat", () => {
+	it("parses NDJSON events and returns conversationId", async () => {
+		const event1: AgentEvent = {
+			type: "text-delta",
+			conversationId: "c1",
+			turnId: "t1",
+			delta: "Hello",
+		};
+		const event2: AgentEvent = {
+			type: "done",
+			conversationId: "c1",
+			turnId: "t1",
+			reason: "completed",
+		};
+
+		const body = ndjsonLines(event1, event2);
+		const fakeFetch = makeFakeFetch(body, { "X-Conversation-Id": "c1" });
+
+		const { conversationId, events } = await streamChat(
+			{ fetchImpl: fakeFetch },
+			{
+				server: "http://localhost:24203",
+				request: { message: "hi", model: "openai/gpt-4" },
+			},
+		);
+
+		expect(conversationId).toBe("c1");
+
+		const collected: AgentEvent[] = [];
+		for await (const e of events) {
+			collected.push(e);
+		}
+
+		expect(collected).toEqual([event1, event2]);
+	});
+
+	it("handles NDJSON split across chunks", async () => {
+		const event1: AgentEvent = {
+			type: "text-delta",
+			conversationId: "c",
+			turnId: "t",
+			delta: "Hi",
+		};
+		const event2: AgentEvent = {
+			type: "usage",
+			conversationId: "c",
+			turnId: "t",
+			usage: { inputTokens: 10, outputTokens: 5 },
+		};
+
+		const fullNdjson = ndjsonLines(event1, event2);
+		// Split mid-line: after 20 chars
+		const mid = 20;
+		const chunk1 = fullNdjson.slice(0, mid);
+		const chunk2 = fullNdjson.slice(mid);
+
+		const fakeFetch = makeFakeFetch(`${chunk1}|||${chunk2}`, {
+			"X-Conversation-Id": "c",
+		});
+
+		const { events } = await streamChat(
+			{ fetchImpl: fakeFetch },
+			{
+				server: "http://localhost:24203",
+				request: { message: "hi" },
+			},
+		);
+
+		const collected: AgentEvent[] = [];
+		for await (const e of events) {
+			collected.push(e);
+		}
+
+		expect(collected).toEqual([event1, event2]);
+	});
+
+	it("throws on non-OK status", async () => {
+		const fakeFetch = (async (): Promise<Response> =>
+			new Response("not found", { status: 404 })) as unknown as typeof fetch;
+
+		await expect(
+			streamChat(
+				{ fetchImpl: fakeFetch },
+				{
+					server: "http://localhost:24203",
+					request: { message: "hi" },
+				},
+			),
+		).rejects.toThrow("POST /chat failed with status 404");
+	});
+
+	it("throws when response has no body", async () => {
+		const fakeFetch = (async (): Promise<Response> =>
+			new Response(null, { status: 200 })) as unknown as typeof fetch;
+
+		await expect(
+			streamChat(
+				{ fetchImpl: fakeFetch },
+				{
+					server: "http://localhost:24203",
+					request: { message: "hi" },
+				},
+			),
+		).rejects.toThrow("no body");
+	});
+});
+
+describe("fetchModels", () => {
+	it("returns ModelsResponse on success", async () => {
+		const models = { models: ["openai/gpt-4", "anthropic/claude-3"] };
+		const fakeFetch = (async (): Promise<Response> =>
+			new Response(JSON.stringify(models), {
+				status: 200,
+				headers: { "Content-Type": "application/json" },
+			})) as unknown as typeof fetch;
+
+		const result = await fetchModels(
+			{ fetchImpl: fakeFetch },
+			{ server: "http://localhost:24203" },
+		);
+		expect(result).toEqual(models);
+	});
+
+	it("throws on non-OK status", async () => {
+		const fakeFetch = (async (): Promise<Response> =>
+			new Response("server error", { status: 500 })) as unknown as typeof fetch;
+
+		await expect(
+			fetchModels({ fetchImpl: fakeFetch }, { server: "http://localhost:24203" }),
+		).rejects.toThrow("GET /models failed with status 500");
+	});
+});
diff --git a/packages/cli/src/http.ts b/packages/cli/src/http.ts
new file mode 100644
index 0000000..5e61afb
--- /dev/null
+++ b/packages/cli/src/http.ts
@@ -0,0 +1,86 @@
+/**
+ * Shell — HTTP transport layer (effects injected at the edges).
+ *
+ * streamChat: POST /chat, returns an async iterable of AgentEvents.
+ * fetchModels: GET /models, returns the ModelsResponse.
+ *
+ * The fetchImpl dependency is injected (outermost edge mock allowed).
+ */
+
+import type { AgentEvent, ChatRequest, ModelsResponse } from "@dispatch/transport-contract";
+import { splitNdjsonLines } from "./ndjson.js";
+
+interface FetchDeps {
+	readonly fetchImpl: typeof fetch;
+}
+
+interface StreamChatOpts {
+	readonly server: string;
+	readonly request: ChatRequest;
+}
+
+export async function streamChat(
+	deps: FetchDeps,
+	opts: StreamChatOpts,
+): Promise<{ conversationId: string | null; events: AsyncIterable<AgentEvent> }> {
+	const url = `${opts.server}/chat`;
+	const res = await deps.fetchImpl(url, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(opts.request),
+	});
+
+	if (!res.ok) {
+		const body = await res.text();
+		throw new Error(`POST /chat failed with status ${res.status}: ${body}`);
+	}
+
+	const conversationId = res.headers.get("X-Conversation-Id");
+
+	if (!res.body) {
+		throw new Error("POST /chat returned no body");
+	}
+
+	const events = readNdjsonStream(res.body);
+	return { conversationId, events };
+}
+
+async function* readNdjsonStream(body: ReadableStream<Uint8Array>): AsyncIterable<AgentEvent> {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const { lines, rest } = splitNdjsonLines(buffer);
+			buffer = rest;
+			for (const line of lines) {
+				yield JSON.parse(line) as AgentEvent;
+			}
+		}
+		if (buffer.length > 0) {
+			yield JSON.parse(buffer) as AgentEvent;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+
+interface FetchModelsOpts {
+	readonly server: string;
+}
+
+export async function fetchModels(deps: FetchDeps, opts: FetchModelsOpts): Promise<ModelsResponse> {
+	const url = `${opts.server}/models`;
+	const res = await deps.fetchImpl(url);
+
+	if (!res.ok) {
+		const body = await res.text();
+		throw new Error(`GET /models failed with status ${res.status}: ${body}`);
+	}
+
+	return (await res.json()) as ModelsResponse;
+}
diff --git a/packages/cli/src/index.ts b/packages/cli/src/index.ts
new file mode 100644
index 0000000..82e0b21
--- /dev/null
+++ b/packages/cli/src/index.ts
@@ -0,0 +1,12 @@
+/**
+ * Barrel export — the public surface of @dispatch/cli.
+ *
+ * Pure functions + http functions for consumers and tests.
+ */
+
+export { type ParsedCommand, parseArgs } from "./args.js";
+export { formatCatalog } from "./catalog.js";
+export { fetchModels, streamChat } from "./http.js";
+export { buildChatRequest, composeMessage } from "./message.js";
+export { type SplitResult, splitNdjsonLines } from "./ndjson.js";
+export { renderEvent } from "./render.js";
diff --git a/packages/cli/src/main.ts b/packages/cli/src/main.ts
new file mode 100644
index 0000000..fc70c0c
--- /dev/null
+++ b/packages/cli/src/main.ts
@@ -0,0 +1,74 @@
+/**
+ * Composition root — the thin, untested shell that wires everything together.
+ *
+ * Reads process.argv, reads files, writes to stdout/stderr.
+ * This is the ONLY file that touches I/O.
+ */
+
+import { readFile } from "node:fs/promises";
+import { parseArgs } from "./args.js";
+import { formatCatalog } from "./catalog.js";
+import { fetchModels, streamChat } from "./http.js";
+import { buildChatRequest, composeMessage } from "./message.js";
+import { renderEvent } from "./render.js";
+
+const USAGE = `Usage:
+  dispatch models [--server <url>]
+  dispatch <modelName> --text "..." [--file <path>] [--cwd <dir>] [--conversation <id>] [--server <url>] [--show-reasoning]
+  dispatch --help`;
+
+async function main(): Promise<void> {
+	const defaultServer = `http://localhost:${process.env.BACKEND_PORT ?? "24203"}`;
+	const parsed = parseArgs(process.argv.slice(2), { defaultServer });
+
+	switch (parsed.kind) {
+		case "help":
+			process.stdout.write(`${USAGE}\n`);
+			process.exit(0);
+			break;
+		case "error":
+			process.stderr.write(`Error: ${parsed.message}\n`);
+			process.exit(1);
+			break;
+		case "models": {
+			const result = await fetchModels({ fetchImpl: globalThis.fetch }, { server: parsed.server });
+			process.stdout.write(`${formatCatalog(result)}\n`);
+			break;
+		}
+		case "chat": {
+			let fileContent: string | undefined;
+			if (parsed.file) {
+				fileContent = await readFile(parsed.file, "utf-8");
+			}
+
+			const cwd = parsed.cwd ?? process.cwd();
+			const message = composeMessage({
+				...(parsed.text !== undefined && { text: parsed.text }),
+				...(parsed.file !== undefined && { file: parsed.file }),
+				...(fileContent !== undefined && { fileContent }),
+			});
+			const request = buildChatRequest(parsed, { cwd, message });
+
+			const { conversationId, events } = await streamChat(
+				{ fetchImpl: globalThis.fetch },
+				{ server: parsed.server, request },
+			);
+
+			for await (const event of events) {
+				const rendered = renderEvent(event, { showReasoning: parsed.showReasoning });
+				if (rendered?.stdout) process.stdout.write(rendered.stdout);
+				if (rendered?.stderr) process.stderr.write(rendered.stderr);
+			}
+
+			if (conversationId) {
+				process.stdout.write(`\n[conversation] ${conversationId}\n`);
+			}
+			break;
+		}
+	}
+}
+
+main().catch((err: unknown) => {
+	process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}\n`);
+	process.exit(1);
+});
diff --git a/packages/cli/src/message.test.ts b/packages/cli/src/message.test.ts
new file mode 100644
index 0000000..8d6d9e1
--- /dev/null
+++ b/packages/cli/src/message.test.ts
@@ -0,0 +1,81 @@
+import { describe, expect, it } from "vitest";
+import { buildChatRequest, composeMessage } from "./message.js";
+
+describe("composeMessage", () => {
+	it("returns text only", () => {
+		expect(composeMessage({ text: "hello" })).toBe("hello");
+	});
+
+	it("returns file only with neutral label", () => {
+		expect(composeMessage({ file: "foo.txt", fileContent: "contents" })).toBe(
+			"Attached file (foo.txt):\ncontents",
+		);
+	});
+
+	it("returns text + labeled file block", () => {
+		expect(composeMessage({ text: "check this", file: "a.ts", fileContent: "const x = 1;" })).toBe(
+			"check this\n\nAttached file (a.ts):\nconst x = 1;",
+		);
+	});
+
+	it("handles missing fileContent gracefully", () => {
+		expect(composeMessage({ file: "f.txt" })).toBe("Attached file (f.txt):\n");
+	});
+
+	it("uses basename for absolute paths", () => {
+		expect(composeMessage({ file: "/tmp/opencode/demo/note.txt", fileContent: "hello" })).toBe(
+			"Attached file (note.txt):\nhello",
+		);
+	});
+
+	it("handles empty input", () => {
+		expect(composeMessage({})).toBe("");
+	});
+});
+
+describe("buildChatRequest", () => {
+	it("maps fields correctly", () => {
+		const req = buildChatRequest(
+			{
+				modelName: "cred/model",
+				text: "hi",
+				showReasoning: false,
+			},
+			{ cwd: "/work", message: "hi" },
+		);
+		expect(req).toEqual({
+			message: "hi",
+			model: "cred/model",
+			cwd: "/work",
+		});
+	});
+
+	it("includes conversationId when provided", () => {
+		const req = buildChatRequest(
+			{
+				modelName: "m",
+				text: "x",
+				conversationId: "conv-123",
+				showReasoning: false,
+			},
+			{ cwd: "/work", message: "x" },
+		);
+		expect(req.conversationId).toBe("conv-123");
+	});
+
+	it("omits conversationId when not provided", () => {
+		const req = buildChatRequest(
+			{ modelName: "m", text: "x", showReasoning: false },
+			{ cwd: "/work", message: "x" },
+		);
+		expect(req).not.toHaveProperty("conversationId");
+	});
+
+	it("uses explicit cwd over context cwd", () => {
+		const req = buildChatRequest(
+			{ modelName: "m", text: "x", cwd: "/explicit", showReasoning: false },
+			{ cwd: "/default", message: "x" },
+		);
+		expect(req.cwd).toBe("/explicit");
+	});
+});
diff --git a/packages/cli/src/message.ts b/packages/cli/src/message.ts
new file mode 100644
index 0000000..0c3f538
--- /dev/null
+++ b/packages/cli/src/message.ts
@@ -0,0 +1,55 @@
+/**
+ * Pure message composition — zero I/O.
+ *
+ * Combines text and file content into a single message string,
+ * and builds a ChatRequest from a parsed command.
+ */
+
+import type { ChatRequest } from "@dispatch/transport-contract";
+
+interface ComposeInput {
+	readonly text?: string;
+	readonly file?: string;
+	readonly fileContent?: string;
+}
+
+function basename(filePath: string): string {
+	const segments = filePath.split("/");
+	return segments[segments.length - 1] ?? filePath;
+}
+
+export function composeMessage(input: ComposeInput): string {
+	const { text, fileContent } = input;
+	const file = input.file;
+
+	if (text && file) {
+		return `${text}\n\nAttached file (${basename(file)}):\n${fileContent ?? ""}`;
+	}
+	if (file) {
+		return `Attached file (${basename(file)}):\n${fileContent ?? ""}`;
+	}
+	return text ?? "";
+}
+
+interface ChatCmd {
+	readonly modelName: string;
+	readonly text?: string | undefined;
+	readonly file?: string | undefined;
+	readonly cwd?: string | undefined;
+	readonly conversationId?: string | undefined;
+	readonly showReasoning: boolean;
+}
+
+interface BuildCtx {
+	readonly cwd: string;
+	readonly message: string;
+}
+
+export function buildChatRequest(cmd: ChatCmd, ctx: BuildCtx): ChatRequest {
+	return {
+		message: ctx.message,
+		model: cmd.modelName,
+		...(cmd.conversationId !== undefined && { conversationId: cmd.conversationId }),
+		...(cmd.cwd !== undefined ? { cwd: cmd.cwd } : { cwd: ctx.cwd }),
+	};
+}
diff --git a/packages/cli/src/ndjson.test.ts b/packages/cli/src/ndjson.test.ts
new file mode 100644
index 0000000..8ed3bff
--- /dev/null
+++ b/packages/cli/src/ndjson.test.ts
@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import { splitNdjsonLines } from "./ndjson.js";
+
+describe("splitNdjsonLines", () => {
+	it("splits complete lines", () => {
+		const result = splitNdjsonLines('{"a":1}\n{"b":2}\n');
+		expect(result.lines).toEqual(['{"a":1}', '{"b":2}']);
+		expect(result.rest).toBe("");
+	});
+
+	it("keeps incomplete trailing line in rest", () => {
+		const result = splitNdjsonLines('{"a":1}\n{"b":2');
+		expect(result.lines).toEqual(['{"a":1}']);
+		expect(result.rest).toBe('{"b":2');
+	});
+
+	it("returns empty lines array for single incomplete line", () => {
+		const result = splitNdjsonLines('{"a":1');
+		expect(result.lines).toEqual([]);
+		expect(result.rest).toBe('{"a":1');
+	});
+
+	it("filters out empty lines", () => {
+		const result = splitNdjsonLines('{"a":1}\n\n{"b":2}\n');
+		expect(result.lines).toEqual(['{"a":1}', '{"b":2}']);
+		expect(result.rest).toBe("");
+	});
+
+	it("handles a line split across two buffers", () => {
+		const buf1 = '{"a":1}\n{"b":';
+		const buf2 = '2}\n{"c":3}\n';
+
+		const r1 = splitNdjsonLines(buf1);
+		expect(r1.lines).toEqual(['{"a":1}']);
+		expect(r1.rest).toBe('{"b":');
+
+		const combined = r1.rest + buf2;
+		const r2 = splitNdjsonLines(combined);
+		expect(r2.lines).toEqual(['{"b":2}', '{"c":3}']);
+		expect(r2.rest).toBe("");
+	});
+
+	it("handles empty buffer", () => {
+		const result = splitNdjsonLines("");
+		expect(result.lines).toEqual([]);
+		expect(result.rest).toBe("");
+	});
+});
diff --git a/packages/cli/src/ndjson.ts b/packages/cli/src/ndjson.ts
new file mode 100644
index 0000000..57093c1
--- /dev/null
+++ b/packages/cli/src/ndjson.ts
@@ -0,0 +1,18 @@
+/**
+ * Pure NDJSON line splitter — zero I/O.
+ *
+ * Splits a buffer on newlines, keeping an incomplete trailing line in `rest`.
+ * Does NOT parse JSON — that is the caller's job.
+ */
+
+export interface SplitResult {
+	readonly lines: readonly string[];
+	readonly rest: string;
+}
+
+export function splitNdjsonLines(buffer: string): SplitResult {
+	const parts = buffer.split("\n");
+	const rest = parts[parts.length - 1] ?? "";
+	const lines = parts.slice(0, -1).filter((l) => l.length > 0);
+	return { lines, rest };
+}
diff --git a/packages/cli/src/render.test.ts b/packages/cli/src/render.test.ts
new file mode 100644
index 0000000..bfdb791
--- /dev/null
+++ b/packages/cli/src/render.test.ts
@@ -0,0 +1,147 @@
+import type { AgentEvent } from "@dispatch/transport-contract";
+import { describe, expect, it } from "vitest";
+import { renderEvent } from "./render.js";
+
+describe("renderEvent", () => {
+	const opts = { showReasoning: false };
+	const optsReasoning = { showReasoning: true };
+
+	it("renders text-delta as stdout", () => {
+		const e: AgentEvent = {
+			type: "text-delta",
+			conversationId: "c",
+			turnId: "t",
+			delta: "hello",
+		};
+		expect(renderEvent(e, opts)).toEqual({ stdout: "hello" });
+	});
+
+	it("hides reasoning-delta by default", () => {
+		const e: AgentEvent = {
+			type: "reasoning-delta",
+			conversationId: "c",
+			turnId: "t",
+			delta: "thinking...",
+		};
+		expect(renderEvent(e, opts)).toBeUndefined();
+	});
+
+	it("shows reasoning-delta when showReasoning is true", () => {
+		const e: AgentEvent = {
+			type: "reasoning-delta",
+			conversationId: "c",
+			turnId: "t",
+			delta: "thinking...",
+		};
+		expect(renderEvent(e, optsReasoning)).toEqual({ stdout: "thinking..." });
+	});
+
+	it("renders tool-call with name and JSON input", () => {
+		const e: AgentEvent = {
+			type: "tool-call",
+			conversationId: "c",
+			turnId: "t",
+			toolCallId: "tc1",
+			toolName: "read_file",
+			input: { path: "/foo" },
+		};
+		const result = renderEvent(e, opts);
+		expect(result?.stdout).toContain("[tool] read_file");
+		expect(result?.stdout).toContain('"/foo"');
+	});
+
+	it("renders tool-output data as stdout", () => {
+		const e: AgentEvent = {
+			type: "tool-output",
+			conversationId: "c",
+			turnId: "t",
+			toolCallId: "tc1",
+			data: "some output",
+			stream: "stdout",
+		};
+		expect(renderEvent(e, opts)).toEqual({ stdout: "some output" });
+	});
+
+	it("renders tool-result without error", () => {
+		const e: AgentEvent = {
+			type: "tool-result",
+			conversationId: "c",
+			turnId: "t",
+			toolCallId: "tc1",
+			toolName: "read_file",
+			content: "file contents",
+			isError: false,
+		};
+		expect(renderEvent(e, opts)).toEqual({
+			stdout: "[tool:read_file] file contents\n",
+		});
+	});
+
+	it("renders tool-result with error flag", () => {
+		const e: AgentEvent = {
+			type: "tool-result",
+			conversationId: "c",
+			turnId: "t",
+			toolCallId: "tc1",
+			toolName: "read_file",
+			content: "not found",
+			isError: true,
+		};
+		expect(renderEvent(e, opts)).toEqual({
+			stdout: "[tool:read_file] ERROR not found\n",
+		});
+	});
+
+	it("renders usage event", () => {
+		const e: AgentEvent = {
+			type: "usage",
+			conversationId: "c",
+			turnId: "t",
+			usage: { inputTokens: 100, outputTokens: 50 },
+		};
+		expect(renderEvent(e, opts)).toEqual({
+			stdout: "\n[usage] in=100 out=50\n",
+		});
+	});
+
+	it("renders error event to stderr", () => {
+		const e: AgentEvent = {
+			type: "error",
+			conversationId: "c",
+			turnId: "t",
+			message: "something went wrong",
+		};
+		expect(renderEvent(e, opts)).toEqual({
+			stderr: "[error] something went wrong\n",
+		});
+	});
+
+	it("returns undefined for status", () => {
+		const e: AgentEvent = {
+			type: "status",
+			conversationId: "c",
+			status: "running",
+		};
+		expect(renderEvent(e, opts)).toBeUndefined();
+	});
+
+	it("returns undefined for turn-start", () => {
+		const e: AgentEvent = { type: "turn-start", conversationId: "c", turnId: "t" };
+		expect(renderEvent(e, opts)).toBeUndefined();
+	});
+
+	it("returns undefined for turn-sealed", () => {
+		const e: AgentEvent = { type: "turn-sealed", conversationId: "c", turnId: "t" };
+		expect(renderEvent(e, opts)).toBeUndefined();
+	});
+
+	it("returns undefined for done", () => {
+		const e: AgentEvent = {
+			type: "done",
+			conversationId: "c",
+			turnId: "t",
+			reason: "completed",
+		};
+		expect(renderEvent(e, opts)).toBeUndefined();
+	});
+});
diff --git a/packages/cli/src/render.ts b/packages/cli/src/render.ts
new file mode 100644
index 0000000..1853963
--- /dev/null
+++ b/packages/cli/src/render.ts
@@ -0,0 +1,45 @@
+/**
+ * Pure event renderer — zero I/O.
+ *
+ * Maps an AgentEvent to optional stdout/stderr strings.
+ * Consumers write these to process.stdout / process.stderr.
+ */
+
+import type { AgentEvent } from "@dispatch/transport-contract";
+
+interface RenderOpts {
+	readonly showReasoning: boolean;
+}
+
+interface RenderOutput {
+	readonly stdout?: string;
+	readonly stderr?: string;
+}
+
+export function renderEvent(e: AgentEvent, opts: RenderOpts): RenderOutput | undefined {
+	switch (e.type) {
+		case "text-delta":
+			return { stdout: e.delta };
+		case "reasoning-delta":
+			return opts.showReasoning ? { stdout: e.delta } : undefined;
+		case "tool-call":
+			return { stdout: `\n[tool] ${e.toolName} ${JSON.stringify(e.input)}\n` };
+		case "tool-output":
+			return { stdout: e.data };
+		case "tool-result":
+			return {
+				stdout: `[tool:${e.toolName}]${e.isError ? " ERROR" : ""} ${e.content}\n`,
+			};
+		case "usage":
+			return {
+				stdout: `\n[usage] in=${e.usage.inputTokens} out=${e.usage.outputTokens}\n`,
+			};
+		case "error":
+			return { stderr: `[error] ${e.message}\n` };
+		case "status":
+		case "turn-start":
+		case "turn-sealed":
+		case "done":
+			return undefined;
+	}
+}