topchester-ai 0.9.0 → 0.10.0

package/dist/cli.mjs

@@ -28,13 +28,20 @@ function toAiSdkToolSet(definitions) {
 //#region src/knowledge/session-overlay.ts
 const overlays = /* @__PURE__ */ new Map();
 function recordAgentFileEdit(workspaceRoot, event) {
+	return recordAgentFileMutation(workspaceRoot, event);
+}
+function recordAgentFileCreate(workspaceRoot, event) {
+	return recordAgentFileMutation(workspaceRoot, event);
+}
+function recordAgentFileMutation(workspaceRoot, event) {
 	const overlay = getOrCreateOverlay(resolve(workspaceRoot));
 	const previous = overlay.dirtyFiles.get(event.path);
 	overlay.drift = "dirty_known";
 	overlay.kbState = "needs_sync";
 	overlay.needsSync = true;
 	overlay.updatedAt = event.timestamp;
-	overlay.editEvents.push(event);
+	overlay.mutationEvents.push(event);
+	if (event.kind === "file_edit") overlay.editEvents.push(event);
 	overlay.dirtyFiles.set(event.path, {
 		path: event.path,
 		source: "agent",
@@ -42,7 +49,7 @@ function recordAgentFileEdit(workspaceRoot, event) {
 		kbState: "needs_sync",
 		l1State: "stale",
 		derivedState: "suspect",
-		beforeHash: previous?.beforeHash ?? event.beforeHash,
+		beforeHash: previous?.beforeHash ?? (event.kind === "file_create" ? void 0 : event.beforeHash),
 		afterHash: event.afterHash,
 		firstChangedLine: event.firstChangedLine,
 		lastEditedAt: event.timestamp,
@@ -59,7 +66,8 @@ function getOrCreateOverlay(workspaceRoot) {
 		kbState: "current",
 		needsSync: false,
 		dirtyFiles: /* @__PURE__ */ new Map(),
-		editEvents: []
+		editEvents: [],
+		mutationEvents: []
 	};
 	overlays.set(workspaceRoot, overlay);
 	return overlay;
@@ -72,6 +80,7 @@ function snapshotOverlay(overlay) {
 		needsSync: overlay.needsSync,
 		dirtyFiles: [...overlay.dirtyFiles.values()].map((file) => ({ ...file })),
 		editEvents: overlay.editEvents.map((event) => ({ ...event })),
+		mutationEvents: overlay.mutationEvents.map((event) => ({ ...event })),
 		updatedAt: overlay.updatedAt
 	};
 }
@@ -109,16 +118,16 @@ const editFileTool = defineTool({
 	execute: (context, args) => editWorkspaceFile(context.workspaceRoot, args, { logger: context.logger })
 });
 async function editWorkspaceFile(workspaceRoot, args, options = {}) {
-	const scopedPath = resolveWorkspaceScopedPath$3(workspaceRoot, args.path);
+	const scopedPath = resolveWorkspaceScopedPath$4(workspaceRoot, args.path);
 	return enqueueFileMutation(scopedPath.path, async () => {
 		const fileStat = await statExistingFile(scopedPath.path, args.path);
 		const beforeBytes = await readFile(scopedPath.path);
-		const beforeHash = hashBytes(beforeBytes);
+		const beforeHash = hashBytes$1(beforeBytes);
 		if (args.expected_hash && args.expected_hash !== beforeHash) throw new Error(`edit_file expected_hash did not match ${scopedPath.relativePath}.`);
-		const result = applyExactEdits(decodeUtf8(scopedPath.relativePath, beforeBytes), args.edits, scopedPath.relativePath);
+		const result = applyExactEdits(decodeUtf8$1(scopedPath.relativePath, beforeBytes), args.edits, scopedPath.relativePath);
 		const afterBytes = Buffer.from(result.newContent, "utf8");
-		const afterHash = hashBytes(afterBytes);
-		await writeFileAtomically(scopedPath.path, afterBytes, fileStat.mode);
+		const afterHash = hashBytes$1(afterBytes);
+		await writeFileAtomically$1(scopedPath.path, afterBytes, fileStat.mode);
 		const editEvent = {
 			kind: "file_edit",
 			source: "agent",
@@ -172,7 +181,7 @@ function applyExactEdits(content, edits, path = "file") {
 		firstChangedLine: getFirstChangedLine(document.body, newBody)
 	};
 }
-function resolveWorkspaceScopedPath$3(workspaceRoot, path) {
+function resolveWorkspaceScopedPath$4(workspaceRoot, path) {
 	if (path.includes("\0")) throw new Error("edit_file path is invalid.");
 	const resolvedWorkspace = resolve(workspaceRoot);
 	const resolvedPath = isAbsolute(path) ? resolve(path) : resolve(resolvedWorkspace, path);
@@ -189,13 +198,13 @@ async function statExistingFile(resolvedPath, originalPath) {
 	try {
 		fileStat = await stat(resolvedPath);
 	} catch (error) {
-		if (isNodeError$2(error) && error.code === "ENOENT") throw new Error(`edit_file can only edit existing files: ${originalPath}`);
+		if (isNodeError$3(error) && error.code === "ENOENT") throw new Error(`edit_file can only edit existing files: ${originalPath}`);
 		throw error;
 	}
 	if (!fileStat.isFile()) throw new Error(`edit_file can only edit regular files: ${originalPath}`);
 	return fileStat;
 }
-function decodeUtf8(path, bytes) {
+function decodeUtf8$1(path, bytes) {
 	try {
 		return new TextDecoder("utf-8", {
 			fatal: true,
@@ -205,7 +214,7 @@ function decodeUtf8(path, bytes) {
 		throw new Error(`edit_file can only edit UTF-8 text files: ${path}`);
 	}
 }
-async function writeFileAtomically(path, content, mode) {
+async function writeFileAtomically$1(path, content, mode) {
 	const temporaryPath = resolve(dirname(path), `.${basename(path)}.topchester-${process.pid}-${randomUUID()}.tmp`);
 	try {
 		await writeFile(temporaryPath, content, {
@@ -218,7 +227,7 @@ async function writeFileAtomically(path, content, mode) {
 		throw error;
 	}
 }
-function hashBytes(bytes) {
+function hashBytes$1(bytes) {
 	return `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
 }
 function summarizeDiff(diff) {
@@ -231,7 +240,7 @@ function summarizeDiff(diff) {
 	}
 	return `+${added}/-${removed}`;
 }
-function isNodeError$2(error) {
+function isNodeError$3(error) {
 	return error instanceof Error && "code" in error;
 }
 function normalizeEdits(edits) {
@@ -376,7 +385,7 @@ const findFileTool = defineTool({
 	})
 });
 async function findWorkspaceFilesByName(workspaceRoot, args, options = {}) {
-	const scopedPath = resolveWorkspaceScopedPath$2(workspaceRoot, args.path);
+	const scopedPath = resolveWorkspaceScopedPath$3(workspaceRoot, args.path);
 	const matches = (await collectWorkspaceFiles(scopedPath.workspaceRoot, scopedPath.path, scopedPath.relativePath, options)).map((path) => {
 		const score = scoreFileMatch(args.query, path);
 		return score > 0 ? {
@@ -574,7 +583,7 @@ function scoreSubsequenceMatch(query, value) {
 function normalize(value) {
 	return value.trim().toLowerCase().replaceAll("\\", "/");
 }
-function resolveWorkspaceScopedPath$2(workspaceRoot, path) {
+function resolveWorkspaceScopedPath$3(workspaceRoot, path) {
 	const resolvedWorkspace = resolve(workspaceRoot);
 	const resolvedPath = isAbsolute(path) ? resolve(path) : resolve(resolvedWorkspace, path);
 	const relativePath = relative(resolvedWorkspace, resolvedPath);
@@ -618,6 +627,714 @@ function getExitCode$1(error) {
 function isRecord$3(value) {
 	return typeof value === "object" && value !== null;
 }
+//#endregion
+//#region src/agent/tools/git-runner.ts
+const DEFAULT_TIMEOUT_MS = 1e4;
+const DEFAULT_MAX_OUTPUT_BYTES = 4e4;
+const GIT_FIELD_SEPARATOR = "";
+async function runGit(options) {
+	const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+	const args = [
+		"--no-optional-locks",
+		"-c",
+		"core.quotepath=false",
+		"-c",
+		"core.fsmonitor=false",
+		...options.args
+	];
+	return new Promise((resolveCommand) => {
+		const child = spawn("git", args, {
+			cwd: options.cwd,
+			env: {
+				...process.env,
+				PATH: options.pathEnv ?? process.env.PATH ?? "",
+				GIT_OPTIONAL_LOCKS: "0",
+				GIT_PAGER: "cat",
+				PAGER: "cat",
+				LESS: "-F -X"
+			},
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		const stdoutChunks = [];
+		const stderrChunks = [];
+		let stdoutBytes = 0;
+		let stderrBytes = 0;
+		let truncated = false;
+		let timedOut = false;
+		let settled = false;
+		const timer = setTimeout(() => {
+			timedOut = true;
+			child.kill("SIGTERM");
+			setTimeout(() => {
+				if (!settled) child.kill("SIGKILL");
+			}, 500).unref();
+		}, timeoutMs);
+		child.stdout.on("data", (chunk) => {
+			const appended = appendBoundedChunk(stdoutChunks, stdoutBytes, chunk, maxOutputBytes);
+			stdoutBytes = appended.bytes;
+			truncated = truncated || appended.truncated;
+		});
+		child.stderr.on("data", (chunk) => {
+			const appended = appendBoundedChunk(stderrChunks, stderrBytes, chunk, Math.min(8e3, maxOutputBytes));
+			stderrBytes = appended.bytes;
+			truncated = truncated || appended.truncated;
+		});
+		child.once("error", (error) => {
+			clearTimeout(timer);
+			settled = true;
+			resolveCommand({
+				stdout: "",
+				stderr: error.code === "ENOENT" ? "git is not available on PATH.\n" : `${error.message}\n`,
+				exitCode: 127,
+				timedOut: false,
+				truncated: false,
+				binary: false,
+				missingGit: error.code === "ENOENT"
+			});
+		});
+		child.once("close", (code) => {
+			clearTimeout(timer);
+			settled = true;
+			const stdout = Buffer.concat(stdoutChunks);
+			const stderr = Buffer.concat(stderrChunks);
+			const binary = !options.allowNulOutput && (containsNul(stdout) || containsNul(stderr));
+			resolveCommand({
+				stdout: binary ? "" : stdout.toString("utf8"),
+				stderr: binary ? "git output contained binary data.\n" : stderr.toString("utf8"),
+				exitCode: code ?? (timedOut ? 124 : 1),
+				timedOut,
+				truncated,
+				binary,
+				missingGit: false
+			});
+		});
+	});
+}
+function ensureInsideWorkspace(workspaceRoot, path) {
+	if (path.length === 0 || path.includes("\0")) throw new Error("Git path is invalid.");
+	const resolvedWorkspace = resolve(workspaceRoot);
+	const absolutePath = isAbsolute(path) ? resolve(path) : resolve(resolvedWorkspace, path);
+	const relativePath = relative(resolvedWorkspace, absolutePath);
+	if (relativePath.startsWith("..") || isAbsolute(relativePath)) throw new Error(`Git path must stay inside the workspace: ${path}`);
+	return {
+		workspaceRoot: resolvedWorkspace,
+		absolutePath,
+		relativePath: relativePath || "."
+	};
+}
+async function getRepoInfo(workspaceRoot, pathEnv) {
+	const workspace = await realpath(resolve(workspaceRoot));
+	const root = await runGit({
+		cwd: workspace,
+		pathEnv,
+		args: ["rev-parse", "--show-toplevel"],
+		maxOutputBytes: 8e3
+	});
+	if (root.missingGit) return {
+		available: false,
+		missingGit: true,
+		repoRoot: null,
+		repoRootAbsolute: null,
+		branch: null,
+		head: null,
+		hasHead: false,
+		message: "git is not available on PATH."
+	};
+	if (root.exitCode !== 0) return {
+		available: false,
+		missingGit: false,
+		repoRoot: null,
+		repoRootAbsolute: null,
+		branch: null,
+		head: null,
+		hasHead: false,
+		message: "This workspace is not inside a Git repository."
+	};
+	const repoRootAbsolute = root.stdout.trim();
+	const repoRoot = relative(workspace, repoRootAbsolute) || ".";
+	const hasHead = (await runGit({
+		cwd: workspace,
+		pathEnv,
+		args: [
+			"rev-parse",
+			"--verify",
+			"HEAD"
+		],
+		maxOutputBytes: 8e3
+	})).exitCode === 0;
+	const branchResult = await runGit({
+		cwd: workspace,
+		pathEnv,
+		args: [
+			"symbolic-ref",
+			"--quiet",
+			"--short",
+			"HEAD"
+		],
+		maxOutputBytes: 8e3
+	});
+	const headResult = hasHead ? await runGit({
+		cwd: workspace,
+		pathEnv,
+		args: [
+			"rev-parse",
+			"--short",
+			"HEAD"
+		],
+		maxOutputBytes: 8e3
+	}) : void 0;
+	return {
+		available: true,
+		missingGit: false,
+		repoRoot,
+		repoRootAbsolute,
+		branch: branchResult.exitCode === 0 ? branchResult.stdout.trim() : null,
+		head: headResult?.exitCode === 0 ? headResult.stdout.trim() : null,
+		hasHead
+	};
+}
+function parsePorcelainStatus(output) {
+	return output.split("\0").filter(Boolean).map((entry) => {
+		const indexStatus = entry[0] ?? " ";
+		const worktreeStatus = entry[1] ?? " ";
+		const path = entry.slice(3);
+		const untracked = indexStatus === "?" && worktreeStatus === "?";
+		const staged = !untracked && indexStatus !== " ";
+		const unstaged = !untracked && worktreeStatus !== " ";
+		return {
+			path,
+			indexStatus,
+			worktreeStatus,
+			status: classifyStatus(indexStatus, worktreeStatus),
+			staged,
+			unstaged,
+			untracked
+		};
+	});
+}
+function parseGitLog(output) {
+	return output.split("\n").filter(Boolean).map((line) => {
+		const [sha = "", shortSha = "", timestamp = "0", authorName = "", subject = ""] = line.split(GIT_FIELD_SEPARATOR);
+		return {
+			sha,
+			shortSha,
+			timestamp: Number(timestamp),
+			authorName,
+			subject
+		};
+	});
+}
+function truncateText(content, maxBytes) {
+	if (Buffer.byteLength(content) <= maxBytes) return {
+		content,
+		truncated: false
+	};
+	return {
+		content: Buffer.from(content, "utf8").subarray(0, maxBytes).toString("utf8"),
+		truncated: true
+	};
+}
+function gitLogPrettyFormat() {
+	return `%H%x1f%h%x1f%ct%x1f%an%x1f%s`;
+}
+function classifyStatus(indexStatus, worktreeStatus) {
+	if (indexStatus === "?" && worktreeStatus === "?") return "untracked";
+	if (indexStatus === "U" || worktreeStatus === "U" || indexStatus === "A" && worktreeStatus === "A") return "conflicted";
+	if (indexStatus === "R") return "renamed";
+	if (indexStatus === "C") return "copied";
+	if (indexStatus === "D" || worktreeStatus === "D") return "deleted";
+	if (indexStatus === "A") return "added";
+	if (indexStatus === "M" || worktreeStatus === "M") return "modified";
+	return "unknown";
+}
+function appendBoundedChunk(chunks, currentBytes, chunk, maxBytes) {
+	if (currentBytes >= maxBytes) return {
+		bytes: currentBytes,
+		truncated: true
+	};
+	const remaining = maxBytes - currentBytes;
+	const slice = chunk.length > remaining ? chunk.subarray(0, remaining) : chunk;
+	chunks.push(slice);
+	return {
+		bytes: currentBytes + slice.length,
+		truncated: chunk.length > remaining
+	};
+}
+function containsNul(buffer) {
+	return buffer.includes(0);
+}
+//#endregion
+//#region src/agent/tools/git.ts
+const gitStatusValueSchema = z.enum([
+	"added",
+	"modified",
+	"deleted",
+	"renamed",
+	"copied",
+	"untracked",
+	"conflicted",
+	"unknown"
+]);
+const gitStatusArgsSchema = z.object({
+	path: z.string().optional().default("."),
+	include_untracked: z.boolean().optional().default(true)
+});
+const gitDiffArgsSchema = z.object({
+	scope: z.enum([
+		"all",
+		"unstaged",
+		"staged"
+	]).optional().default("all"),
+	path: z.string().optional(),
+	include_untracked: z.boolean().optional().default(false),
+	context_lines: z.number().int().min(0).max(20).optional().default(3),
+	max_bytes: z.number().int().min(1e3).max(2e5).optional().default(4e4)
+});
+const gitLogArgsSchema = z.object({
+	limit: z.number().int().min(1).max(50).optional().default(10),
+	path: z.string().optional()
+});
+const gitAddArgsSchema = z.object({
+	paths: z.array(z.string().min(1)).min(1),
+	expected_status: z.array(z.object({
+		path: z.string().min(1),
+		status: gitStatusValueSchema
+	})).min(1)
+});
+const gitCommitArgsSchema = z.object({
+	message: z.string().trim().min(1).max(500),
+	expected_staged_paths: z.array(z.string().min(1)).min(1)
+});
+const gitStatusTool = defineTool({
+	name: "git_status",
+	description: "Inspect structured Git branch and changed-file status inside the workspace.",
+	prompt: "git_status: inspect branch, head, clean state, staged, unstaged, and untracked files without parsing shell output. To use it, reply with only JSON: {\"tool\":\"git_status\",\"args\":{\"path\":\".\",\"include_untracked\":true}}",
+	argsSchema: gitStatusArgsSchema,
+	execute: (context, args) => inspectGitStatus(context, args)
+});
+const gitDiffTool = defineTool({
+	name: "git_diff",
+	description: "Inspect bounded Git diffs for staged, unstaged, and optionally untracked files.",
+	prompt: "git_diff: inspect a bounded Git diff; use scope \"all\", \"unstaged\", or \"staged\", and include_untracked:true only when untracked file patches are needed. To use it, reply with only JSON: {\"tool\":\"git_diff\",\"args\":{\"scope\":\"all\",\"include_untracked\":true}}",
+	argsSchema: gitDiffArgsSchema,
+	execute: (context, args) => inspectGitDiff(context, args)
+});
+const gitLogTool = defineTool({
+	name: "git_log",
+	description: "Inspect recent Git commits as bounded structured summaries.",
+	prompt: "git_log: inspect recent commits without parsing shell output. To use it, reply with only JSON: {\"tool\":\"git_log\",\"args\":{\"limit\":10,\"path\":\"src/agent/runtime.ts\"}}",
+	argsSchema: gitLogArgsSchema,
+	execute: (context, args) => inspectGitLog(context, args)
+});
+const gitAddTool = defineTool({
+	name: "git_add",
+	description: "Stage explicit changed paths after current Git status has been inspected.",
+	prompt: "git_add: stage only explicit paths the user asked to stage; first inspect git_status, reject broad paths, and pass expected_status for each path. To use it, reply with only JSON: {\"tool\":\"git_add\",\"args\":{\"paths\":[\"src/example.ts\"],\"expected_status\":[{\"path\":\"src/example.ts\",\"status\":\"modified\"}]}}",
+	argsSchema: gitAddArgsSchema,
+	execute: (context, args) => stageGitPaths(context, args)
+});
+const gitCommitTool = defineTool({
+	name: "git_commit",
+	description: "Create a Git commit from exactly the expected staged paths.",
+	prompt: "git_commit: commit only after the user explicitly asks and staged paths exactly match expected_staged_paths. To use it, reply with only JSON: {\"tool\":\"git_commit\",\"args\":{\"message\":\"Add feature\",\"expected_staged_paths\":[\"src/example.ts\"]}}",
+	argsSchema: gitCommitArgsSchema,
+	execute: (context, args) => commitGitPaths(context, args)
+});
+async function inspectGitStatus(context, args) {
+	const repo = await getRepoInfo(context.workspaceRoot, context.pathEnv);
+	const unavailable = formatUnavailable("git_status", repo);
+	if (unavailable) return {
+		...unavailable,
+		branch: null,
+		head: null,
+		hasHead: false,
+		clean: true,
+		files: [],
+		truncated: false
+	};
+	const scopedPath = ensureInsideWorkspace(context.workspaceRoot, args.path);
+	const result = await runGit({
+		cwd: requireRepoRoot(repo),
+		pathEnv: context.pathEnv,
+		allowNulOutput: true,
+		args: [
+			"status",
+			"--porcelain=v1",
+			"-z",
+			"--no-renames",
+			args.include_untracked ? "--untracked-files=all" : "--untracked-files=no",
+			"--",
+			scopedPath.relativePath
+		]
+	});
+	const files = parsePorcelainStatus(result.stdout);
+	return {
+		tool: "git_status",
+		path: scopedPath.relativePath,
+		content: formatGitStatusContent(repo, files),
+		repoRoot: repo.repoRoot,
+		branch: repo.branch,
+		head: repo.head,
+		hasHead: repo.hasHead,
+		clean: files.length === 0,
+		files,
+		truncated: result.truncated,
+		warning: result.truncated ? "git_status output was truncated." : void 0
+	};
+}
+async function inspectGitDiff(context, args) {
+	const repo = await getRepoInfo(context.workspaceRoot, context.pathEnv);
+	const unavailable = formatUnavailable("git_diff", repo);
+	if (unavailable) return {
+		...unavailable,
+		scope: args.scope,
+		path: args.path,
+		fileCount: 0,
+		truncated: false
+	};
+	const repoRoot = requireRepoRoot(repo);
+	const path = args.path ? ensureInsideWorkspace(context.workspaceRoot, args.path).relativePath : void 0;
+	const sections = [];
+	let truncated = false;
+	const changedFiles = /* @__PURE__ */ new Set();
+	if (args.scope === "all" || args.scope === "staged") {
+		const diff = await runDiff(repoRoot, [
+			"diff",
+			"--cached",
+			"--no-ext-diff",
+			"--no-textconv",
+			"--no-renames"
+		], {
+			context,
+			path,
+			contextLines: args.context_lines,
+			maxBytes: args.max_bytes
+		});
+		appendSection(sections, "staged", diff.content);
+		truncated = truncated || diff.truncated;
+		for (const file of await diffNameOnly(repoRoot, true, context, path)) changedFiles.add(file);
+	}
+	if (args.scope === "all" || args.scope === "unstaged") {
+		const diff = await runDiff(repoRoot, [
+			"diff",
+			"--no-ext-diff",
+			"--no-textconv",
+			"--no-renames"
+		], {
+			context,
+			path,
+			contextLines: args.context_lines,
+			maxBytes: args.max_bytes
+		});
+		appendSection(sections, "unstaged", diff.content);
+		truncated = truncated || diff.truncated;
+		for (const file of await diffNameOnly(repoRoot, false, context, path)) changedFiles.add(file);
+	}
+	if (args.include_untracked && args.scope !== "staged") {
+		const untracked = await getUntrackedFiles(repoRoot, context, path);
+		for (const file of untracked) {
+			const diff = await runDiff(repoRoot, [
+				"diff",
+				"--no-index",
+				"--no-ext-diff",
+				"--no-textconv",
+				"--no-renames"
+			], {
+				context,
+				path: void 0,
+				extraPathspecs: ["/dev/null", file],
+				contextLines: args.context_lines,
+				maxBytes: args.max_bytes
+			});
+			appendSection(sections, `untracked ${file}`, diff.content);
+			truncated = truncated || diff.truncated;
+			changedFiles.add(file);
+		}
+	}
+	const bounded = truncateText(sections.join("\n").trimEnd() || "No diff.", args.max_bytes);
+	return {
+		tool: "git_diff",
+		path: path ?? void 0,
+		content: bounded.content,
+		repoRoot: repo.repoRoot,
+		scope: args.scope,
+		fileCount: changedFiles.size,
+		truncated: truncated || bounded.truncated,
+		warning: truncated || bounded.truncated ? "git_diff output was truncated." : void 0
+	};
+}
+async function inspectGitLog(context, args) {
+	const repo = await getRepoInfo(context.workspaceRoot, context.pathEnv);
+	const unavailable = formatUnavailable("git_log", repo);
+	if (unavailable) return {
+		...unavailable,
+		commits: [],
+		truncated: false
+	};
+	if (!repo.hasHead) return {
+		tool: "git_log",
+		path: args.path,
+		content: "This Git repository has no commits yet.",
+		repoRoot: repo.repoRoot,
+		commits: [],
+		truncated: false,
+		warning: "Git repository has no commits."
+	};
+	const repoRoot = requireRepoRoot(repo);
+	const path = args.path ? ensureInsideWorkspace(context.workspaceRoot, args.path).relativePath : void 0;
+	const result = await runGit({
+		cwd: repoRoot,
+		pathEnv: context.pathEnv,
+		args: [
+			"log",
+			"-n",
+			String(args.limit),
+			`--pretty=format:${gitLogPrettyFormat()}`,
+			"--",
+			...path ? [path] : []
+		]
+	});
+	const commits = parseGitLog(result.stdout);
+	return {
+		tool: "git_log",
+		path,
+		content: commits.length === 0 ? "No commits matched." : commits.map(formatCommitSummary).join("\n"),
+		repoRoot: repo.repoRoot,
+		commits,
+		truncated: result.truncated,
+		warning: result.truncated ? "git_log output was truncated." : void 0
+	};
+}
+async function stageGitPaths(context, args) {
+	const repo = await requireAvailableRepo(context);
+	const repoRoot = requireRepoRoot(repo);
+	const paths = normalizeExplicitPaths(context.workspaceRoot, args.paths);
+	const expected = new Map(args.expected_status.map((entry) => [entry.path, entry.status]));
+	const status = await currentStatus(repoRoot, context, true);
+	const statusByPath = new Map(status.map((file) => [file.path, file]));
+	for (const path of paths) {
+		const file = statusByPath.get(path);
+		const expectedStatus = expected.get(path);
+		if (!expectedStatus) throw new Error(`git_add expected_status is required for ${path}.`);
+		if (!file) throw new Error(`git_add can only stage paths present in git_status: ${path}`);
+		if (file.status !== expectedStatus) throw new Error(`git_add expected ${path} to be ${expectedStatus}, but it is ${file.status}.`);
+	}
+	const result = await runGit({
+		cwd: repoRoot,
+		pathEnv: context.pathEnv,
+		args: [
+			"add",
+			"--",
+			...paths
+		]
+	});
+	if (result.exitCode !== 0) throw new Error(`git_add failed: ${result.stderr || result.stdout}`.trim());
+	const files = await currentStatus(repoRoot, context, true);
+	const stagedPaths = files.filter((file) => file.staged).map((file) => file.path);
+	return {
+		tool: "git_add",
+		content: [
+			`staged_paths: ${paths.join(", ")}`,
+			"",
+			formatGitStatusFileList(files)
+		].join("\n").trimEnd(),
+		repoRoot: repo.repoRoot,
+		stagedPaths: paths,
+		files,
+		warning: paths.every((path) => stagedPaths.includes(path)) ? void 0 : "Some requested paths were not staged."
+	};
+}
+async function commitGitPaths(context, args) {
+	const repo = await requireAvailableRepo(context);
+	const repoRoot = requireRepoRoot(repo);
+	const expectedPaths = normalizeExplicitPaths(context.workspaceRoot, args.expected_staged_paths);
+	const stagedFiles = (await currentStatus(repoRoot, context, true)).filter((file) => file.staged);
+	const stagedPaths = stagedFiles.map((file) => file.path).sort();
+	if (stagedPaths.length === 0) throw new Error("git_commit requires staged changes.");
+	if (!sameStringSet(stagedPaths, [...expectedPaths].sort())) throw new Error(`git_commit staged paths did not match expected_staged_paths. staged=${stagedPaths.join(", ")} expected=${expectedPaths.join(", ")}`);
+	const stagedWithUnstagedChanges = stagedFiles.filter((file) => file.unstaged).map((file) => file.path);
+	if (stagedWithUnstagedChanges.length > 0) throw new Error(`git_commit refuses paths with both staged and unstaged changes: ${stagedWithUnstagedChanges.join(", ")}`);
+	const stat = await runGit({
+		cwd: repoRoot,
+		pathEnv: context.pathEnv,
+		args: [
+			"diff",
+			"--cached",
+			"--stat",
+			"--"
+		]
+	});
+	const nameStatus = await runGit({
+		cwd: repoRoot,
+		pathEnv: context.pathEnv,
+		args: [
+			"diff",
+			"--cached",
+			"--name-status",
+			"--"
+		]
+	});
+	const commit = await runGit({
+		cwd: repoRoot,
+		pathEnv: context.pathEnv,
+		args: [
+			"commit",
+			"--no-gpg-sign",
+			"-m",
+			args.message
+		],
+		timeoutMs: 3e4
+	});
+	if (commit.exitCode !== 0) throw new Error(`git_commit failed: ${commit.stderr || commit.stdout}`.trim());
+	const commitSummary = parseGitLog((await runGit({
+		cwd: repoRoot,
+		pathEnv: context.pathEnv,
+		args: [
+			"log",
+			"-n",
+			"1",
+			`--pretty=format:${gitLogPrettyFormat()}`
+		]
+	})).stdout)[0];
+	if (!commitSummary) throw new Error("git_commit succeeded but the new commit could not be read.");
+	const remainingFiles = await currentStatus(repoRoot, context, true);
+	return {
+		tool: "git_commit",
+		content: [
+			`commit: ${commitSummary.shortSha} ${commitSummary.subject}`,
+			`staged_paths: ${stagedPaths.join(", ")}`,
+			"",
+			"stat:",
+			stat.stdout.trim() || "(none)",
+			"",
+			"remaining:",
+			formatGitStatusFileList(remainingFiles) || "clean"
+		].join("\n"),
+		repoRoot: repo.repoRoot,
+		commit: commitSummary,
+		stagedPaths,
+		remainingFiles,
+		stat: stat.stdout,
+		nameStatus: nameStatus.stdout
+	};
+}
+async function requireAvailableRepo(context) {
+	const repo = await getRepoInfo(context.workspaceRoot, context.pathEnv);
+	if (!repo.available) throw new Error(repo.message ?? "Git repository is unavailable.");
+	return repo;
+}
+async function currentStatus(repoRoot, context, includeUntracked) {
+	return parsePorcelainStatus((await runGit({
+		cwd: repoRoot,
+		pathEnv: context.pathEnv,
+		allowNulOutput: true,
+		args: [
+			"status",
+			"--porcelain=v1",
+			"-z",
+			"--no-renames",
+			includeUntracked ? "--untracked-files=all" : "--untracked-files=no",
+			"--"
+		]
+	})).stdout);
+}
+async function runDiff(repoRoot, baseArgs, options) {
+	const result = await runGit({
+		cwd: repoRoot,
+		pathEnv: options.context.pathEnv,
+		args: [
+			...baseArgs,
+			`--unified=${options.contextLines}`,
+			"--",
+			...options.extraPathspecs ?? (options.path ? [options.path] : [])
+		],
+		maxOutputBytes: options.maxBytes,
+		allowExitCodeOne: true
+	});
+	if (result.binary) return {
+		content: "Binary diff omitted.",
+		truncated: result.truncated
+	};
+	return {
+		content: result.stdout,
+		truncated: result.truncated
+	};
+}
+async function diffNameOnly(repoRoot, staged, context, path) {
+	return (await runGit({
+		cwd: repoRoot,
+		pathEnv: context.pathEnv,
+		args: [
+			"diff",
+			staged ? "--cached" : "--no-ext-diff",
+			"--name-only",
+			"--",
+			...path ? [path] : []
+		]
+	})).stdout.split("\n").filter(Boolean);
+}
+async function getUntrackedFiles(repoRoot, context, path) {
+	return (await runGit({
+		cwd: repoRoot,
+		pathEnv: context.pathEnv,
+		args: [
+			"ls-files",
+			"--others",
+			"--exclude-standard",
+			"--",
+			...path ? [path] : []
+		]
+	})).stdout.split("\n").filter(Boolean);
+}
+function appendSection(sections, label, content) {
+	if (content.trim().length === 0) return;
+	sections.push(`## ${label}\n${content.trimEnd()}\n`);
+}
+function formatUnavailable(tool, repo) {
+	if (repo.available) return;
+	return {
+		tool,
+		repoRoot: null,
+		content: repo.message ?? "Git repository is unavailable.",
+		warning: repo.message
+	};
+}
+function formatGitStatusContent(repo, files) {
+	return [
+		`branch: ${repo.branch ?? "(detached)"}`,
+		`head: ${repo.head ?? "(none)"}`,
+		`clean: ${files.length === 0}`,
+		"",
+		formatGitStatusFileList(files) || "No changed files."
+	].join("\n");
+}
+function formatGitStatusFileList(files) {
+	return files.map((file) => `${file.indexStatus}${file.worktreeStatus} ${file.path}`).sort((left, right) => left.localeCompare(right)).join("\n");
+}
+function formatCommitSummary(commit) {
+	return `${commit.shortSha} ${commit.subject} (${commit.authorName}, ${(/* @__PURE__ */ new Date(commit.timestamp * 1e3)).toISOString()})`;
+}
+function requireRepoRoot(repo) {
+	if (!repo.repoRootAbsolute) throw new Error("Git repository root is unavailable.");
+	return repo.repoRootAbsolute;
+}
+function normalizeExplicitPaths(workspaceRoot, paths) {
+	const normalized = paths.map((path) => {
+		if (path === "." || path.includes("*") || path.includes("?") || path.includes("[") || path.includes("]")) throw new Error(`Git mutation tools require explicit file paths, not broad pathspecs: ${path}`);
+		const scoped = ensureInsideWorkspace(workspaceRoot, path);
+		if (scoped.relativePath === ".") throw new Error("Git mutation tools require explicit file paths.");
+		return scoped.relativePath;
+	});
+	return [...new Set(normalized)];
+}
+function sameStringSet(left, right) {
+	return left.length === right.length && left.every((value, index) => value === right[index]);
+}
 const grepTool = defineTool({
 	name: "grep",
 	description: "Search text inside the workspace.",
@@ -632,7 +1349,7 @@ const grepTool = defineTool({
 	})
 });
 async function grepWorkspace(workspaceRoot, args, options = {}) {
-	const scopedPath = resolveWorkspaceScopedPath$1(workspaceRoot, args.path ?? ".");
+	const scopedPath = resolveWorkspaceScopedPath$2(workspaceRoot, args.path ?? ".");
 	const executable = await findSearchExecutable(options.pathEnv);
 	if (!executable) {
 		const warning = "grep could not run because neither rg nor grep is available on PATH.";
@@ -696,7 +1413,7 @@ async function grepWorkspace(workspaceRoot, args, options = {}) {
 		content: truncateToolOutput(result.stdout.trimEnd() || "No matches.")
 	};
 }
-function resolveWorkspaceScopedPath$1(workspaceRoot, path) {
+function resolveWorkspaceScopedPath$2(workspaceRoot, path) {
 	const resolvedWorkspace = resolve(workspaceRoot);
 	const resolvedPath = isAbsolute(path) ? resolve(path) : resolve(resolvedWorkspace, path);
 	const relativePath = relative(resolvedWorkspace, resolvedPath);
@@ -1518,7 +2235,7 @@ const listFilesTool = defineTool({
 	execute: (context, args) => listWorkspaceFiles(context.workspaceRoot, args)
 });
 async function listWorkspaceFiles(workspaceRoot, args) {
-	const scopedPath = resolveWorkspaceScopedPath(workspaceRoot, args.path);
+	const scopedPath = resolveWorkspaceScopedPath$1(workspaceRoot, args.path);
 	if (!(await stat(scopedPath.path)).isDirectory()) throw new Error(`list_files can only list directories inside the workspace: ${args.path}`);
 	const entries = args.recursive ? await collectRecursiveEntries(scopedPath.workspaceRoot, scopedPath.path, args.limit) : await collectTopLevelEntries(scopedPath.workspaceRoot, scopedPath.path, args.limit);
 	const truncated = entries.truncated;
@@ -1582,7 +2299,7 @@ async function sortedDirectoryEntries(path) {
 function formatEntryPath(path, isDirectory) {
 	return isDirectory ? `${path}/` : path;
 }
-function resolveWorkspaceScopedPath(workspaceRoot, path) {
+function resolveWorkspaceScopedPath$1(workspaceRoot, path) {
 	const resolvedWorkspace = resolve(workspaceRoot);
 	const resolvedPath = isAbsolute(path) ? resolve(path) : resolve(resolvedWorkspace, path);
 	const relativePath = relative(resolvedWorkspace, resolvedPath);
@@ -1614,6 +2331,215 @@ async function readWorkspaceFile(workspaceRoot, path) {
 		hash: `sha256:${createHash("sha256").update(bytes).digest("hex")}`
 	};
 }
+const writeFileTool = defineTool({
+	name: "write_file",
+	description: "Create a new UTF-8 file inside the workspace, or explicitly replace one with an expected hash.",
+	prompt: "write_file: create a new UTF-8 file inside the workspace by default; use edit_file for targeted changes to existing files, pass create_parent_dirs:true only when creating the folder path is intended, and replace an existing whole file only with overwrite:true and expected_hash from read_file. To use it, reply with only JSON: {\"tool\":\"write_file\",\"args\":{\"path\":\"test/example.test.ts\",\"content\":\"import { it, expect } from \\\"vitest\\\";\\n\\nit(\\\"works\\\", () => {\\n  expect(true).toBe(true);\\n});\\n\",\"create_parent_dirs\":true}}",
+	argsSchema: z.object({
+		path: z.string(),
+		content: z.string(),
+		create_parent_dirs: z.boolean().optional(),
+		overwrite: z.boolean().optional(),
+		expected_hash: z.string().optional()
+	}),
+	execute: (context, args) => writeWorkspaceFile(context.workspaceRoot, args, { logger: context.logger })
+});
+async function writeWorkspaceFile(workspaceRoot, args, options = {}) {
+	const scopedPath = resolveWorkspaceScopedPath(workspaceRoot, args.path);
+	return enqueueFileMutation(scopedPath.path, async () => {
+		const existingTarget = await statTarget(scopedPath.path);
+		if (args.overwrite) return overwriteExistingFile(workspaceRoot, scopedPath, args, existingTarget, options);
+		if (existingTarget) throw new Error(`write_file can only create new files: ${scopedPath.relativePath}`);
+		const createdParentDirs = await ensureParentDirectory(scopedPath.workspaceRoot, scopedPath.path, scopedPath.relativePath, Boolean(args.create_parent_dirs));
+		const bytes = encodeUtf8Text(args.content);
+		const hash = hashBytes(bytes);
+		const lineCount = countLogicalLines$1(args.content);
+		await writeFileAtomically(scopedPath.path, bytes);
+		const writeEvent = {
+			kind: "file_create",
+			source: "agent",
+			path: scopedPath.relativePath,
+			afterHash: hash,
+			firstChangedLine: 1,
+			writeSummary: `created +${lineCount}`,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		const overlayState = recordAgentFileCreate(workspaceRoot, writeEvent);
+		options.logger?.debug({
+			event: "file_create",
+			...writeEvent,
+			bytesWritten: bytes.length,
+			lineCount,
+			createdParentDirs,
+			kbState: overlayState.kbState,
+			dirtyFileCount: overlayState.dirtyFiles.length
+		}, "file create");
+		const content = [
+			`Created ${scopedPath.relativePath}`,
+			`hash: ${hash}`,
+			`bytes_written: ${bytes.length}`,
+			`line_count: ${lineCount}`,
+			`kb_state: ${overlayState.kbState}`,
+			createdParentDirs.length > 0 ? `created_parent_dirs: ${createdParentDirs.join(", ")}` : void 0
+		].filter(Boolean).join("\n");
+		return {
+			tool: "write_file",
+			path: scopedPath.relativePath,
+			content,
+			hash,
+			bytesWritten: bytes.length,
+			lineCount,
+			createdParentDirs,
+			kbState: "needs_sync",
+			writeEvent
+		};
+	});
+}
+async function overwriteExistingFile(workspaceRoot, scopedPath, args, existingTarget, options) {
+	if (!args.expected_hash) throw new Error(`write_file overwrite requires expected_hash for ${scopedPath.relativePath}.`);
+	if (!existingTarget) throw new Error(`write_file overwrite requires an existing file: ${scopedPath.relativePath}`);
+	if (!existingTarget.isFile()) throw new Error(`write_file overwrite requires a regular file: ${scopedPath.relativePath}`);
+	const beforeBytes = await readFile(scopedPath.path);
+	const beforeHash = hashBytes(beforeBytes);
+	if (args.expected_hash !== beforeHash) throw new Error(`write_file expected_hash did not match ${scopedPath.relativePath}.`);
+	const beforeLineCount = countLogicalLines$1(decodeUtf8(scopedPath.relativePath, beforeBytes));
+	const afterBytes = encodeUtf8Text(args.content);
+	const afterHash = hashBytes(afterBytes);
+	const afterLineCount = countLogicalLines$1(args.content);
+	const bytesChanged = afterBytes.length - beforeBytes.length;
+	const lineDelta = afterLineCount - beforeLineCount;
+	await writeFileAtomically(scopedPath.path, afterBytes, Number(existingTarget.mode));
+	const writeEvent = {
+		kind: "file_overwrite",
+		source: "agent",
+		path: scopedPath.relativePath,
+		beforeHash,
+		afterHash,
+		firstChangedLine: 1,
+		writeSummary: `overwritten +${afterLineCount}/-${beforeLineCount}`,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	const overlayState = recordAgentFileMutation(workspaceRoot, writeEvent);
+	options.logger?.debug({
+		event: "file_overwrite",
+		...writeEvent,
+		bytesWritten: afterBytes.length,
+		bytesChanged,
+		lineCount: afterLineCount,
+		lineDelta,
+		kbState: overlayState.kbState,
+		dirtyFileCount: overlayState.dirtyFiles.length
+	}, "file overwrite");
+	const content = [
+		`Overwrote ${scopedPath.relativePath}`,
+		`before_hash: ${beforeHash}`,
+		`after_hash: ${afterHash}`,
+		`bytes_written: ${afterBytes.length}`,
+		`bytes_changed: ${bytesChanged}`,
+		`line_count: ${afterLineCount}`,
+		`line_delta: ${lineDelta}`,
+		`kb_state: ${overlayState.kbState}`
+	].join("\n");
+	return {
+		tool: "write_file",
+		path: scopedPath.relativePath,
+		content,
+		hash: afterHash,
+		beforeHash,
+		bytesWritten: afterBytes.length,
+		bytesChanged,
+		lineCount: afterLineCount,
+		lineDelta,
+		createdParentDirs: [],
+		kbState: "needs_sync",
+		writeEvent
+	};
+}
+function resolveWorkspaceScopedPath(workspaceRoot, path) {
+	if (path.includes("\0") || path.length === 0) throw new Error("write_file path is invalid.");
+	const resolvedWorkspace = resolve(workspaceRoot);
+	const resolvedPath = isAbsolute(path) ? resolve(path) : resolve(resolvedWorkspace, path);
+	const relativePath = relative(resolvedWorkspace, resolvedPath);
+	if (relativePath.startsWith("..") || isAbsolute(relativePath)) throw new Error(`write_file can only write files inside the workspace: ${path}`);
+	if (relativePath === "") throw new Error("write_file path must point to a file inside the workspace.");
+	return {
+		workspaceRoot: resolvedWorkspace,
+		path: resolvedPath,
+		relativePath
+	};
+}
+async function statTarget(path) {
+	try {
+		return await stat(path);
+	} catch (error) {
+		if (isNodeError$2(error) && error.code === "ENOENT") return;
+		throw error;
+	}
+}
+async function ensureParentDirectory(workspaceRoot, path, relativePath, createParentDirs) {
+	const parent = dirname(path);
+	try {
+		if (!(await stat(parent)).isDirectory()) throw new Error(`write_file parent path is not a directory: ${dirname(relativePath)}`);
+		return [];
+	} catch (error) {
+		if (!isNodeError$2(error) || error.code !== "ENOENT") throw error;
+	}
+	if (!createParentDirs) throw new Error(`write_file parent directory does not exist: ${dirname(relativePath)}`);
+	const createdParentDirs = await collectMissingParentDirs(workspaceRoot, parent);
+	await mkdir(parent, { recursive: true });
+	return createdParentDirs;
+}
+async function collectMissingParentDirs(workspaceRoot, parent) {
+	const missing = [];
+	let current = parent;
+	while (current !== workspaceRoot) try {
+		if (!(await stat(current)).isDirectory()) throw new Error(`write_file parent path is not a directory: ${relative(workspaceRoot, current)}`);
+		break;
+	} catch (error) {
+		if (!isNodeError$2(error) || error.code !== "ENOENT") throw error;
+		missing.push(relative(workspaceRoot, current));
+		current = dirname(current);
+	}
+	return missing.reverse();
+}
+function encodeUtf8Text(content) {
+	if (content.includes("\0")) throw new Error("write_file content must not contain NUL bytes.");
+	return Buffer.from(content, "utf8");
+}
+function decodeUtf8(path, bytes) {
+	try {
+		return new TextDecoder("utf-8", {
+			fatal: true,
+			ignoreBOM: true
+		}).decode(bytes);
+	} catch {
+		throw new Error(`write_file overwrite requires the existing file to be UTF-8 text: ${path}`);
+	}
+}
+async function writeFileAtomically(path, content, mode = 438) {
+	const temporaryPath = resolve(dirname(path), `.${basename(path)}.topchester-${process.pid}-${randomUUID()}.tmp`);
+	try {
+		await writeFile(temporaryPath, content, {
+			flag: "wx",
+			mode: mode & 511
+		});
+		await rename(temporaryPath, path);
+	} catch (error) {
+		await rm(temporaryPath, { force: true });
+		throw error;
+	}
+}
+function hashBytes(bytes) {
+	return `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+}
+function countLogicalLines$1(content) {
+	if (content.length === 0) return 0;
+	const withoutTrailingLineEnding = content.replace(/\r?\n$/u, "");
+	return withoutTrailingLineEnding.length === 0 ? 1 : withoutTrailingLineEnding.split(/\r?\n/u).length;
+}
+function isNodeError$2(error) {
+	return error instanceof Error && "code" in error;
+}
 //#endregion
 //#region src/agent/tools/registry.ts
 const toolRegistry = {
@@ -1622,6 +2548,12 @@ const toolRegistry = {
 	[grepTool.name]: grepTool,
 	[findFileTool.name]: findFileTool,
 	[editFileTool.name]: editFileTool,
+	[writeFileTool.name]: writeFileTool,
+	[gitStatusTool.name]: gitStatusTool,
+	[gitDiffTool.name]: gitDiffTool,
+	[gitLogTool.name]: gitLogTool,
+	[gitAddTool.name]: gitAddTool,
+	[gitCommitTool.name]: gitCommitTool,
 	[inspectCommandTool.name]: inspectCommandTool
 };
 function isToolName(name) {
@@ -3589,6 +4521,201 @@ function assertSafeResetPath(workspaceRoot, path) {
 function isNodeError(error) {
 	return error instanceof Error && "code" in error;
 }
+//#endregion
+//#region src/tui/markdown.ts
+const codeFenceSentinel = "topchester-code-fence";
+function renderMarkdown(text, width) {
+	const lines = new Markdown(unwrapMarkdownCodeFences(text), 0, 0, getMarkdownTheme()).render(width);
+	const rendered = [];
+	let inCodeBlock = false;
+	for (const line of lines) {
+		if (line.includes(codeFenceSentinel)) {
+			inCodeBlock = !inCodeBlock;
+			continue;
+		}
+		rendered.push(inCodeBlock ? applyCodeBlockBackground(line) : line);
+	}
+	return rendered;
+}
+function unwrapMarkdownCodeFences(text) {
+	return text.replace(/^```(?:markdown|md)\s*\n([\s\S]*?)\n```$/gim, "$1");
+}
+function getMarkdownTheme() {
+	return {
+		heading: ui.label,
+		link: ui.label,
+		linkUrl: ui.muted,
+		code: ui.ok,
+		codeBlock: (text) => text,
+		codeBlockBorder: (text) => `${codeFenceSentinel}${ui.muted(text)}`,
+		quote: ui.warn,
+		quoteBorder: ui.warn,
+		hr: ui.muted,
+		listBullet: ui.label,
+		bold: (text) => decorate(text, "\x1B[1m", "\x1B[22m"),
+		italic: (text) => decorate(text, "\x1B[3m", "\x1B[23m"),
+		strikethrough: (text) => decorate(text, "\x1B[9m", "\x1B[29m"),
+		underline: (text) => decorate(text, "\x1B[4m", "\x1B[24m"),
+		codeBlockIndent: "  ",
+		highlightCode(code, lang) {
+			const validLanguage = lang && supportsLanguage(lang) ? lang : void 0;
+			if (!validLanguage) return code.split("\n");
+			try {
+				return highlight(code, {
+					language: validLanguage,
+					ignoreIllegals: true
+				}).split("\n");
+			} catch {
+				return code.split("\n");
+			}
+		}
+	};
+}
+function decorate(text, open, close) {
+	if (!shouldUseAnsi()) return text;
+	return `${open}${text}${close}`;
+}
+function applyCodeBlockBackground(line) {
+	if (!shouldUseAnsi()) return line;
+	const background = "\x1B[48;5;235m";
+	const reset = "\x1B[0m";
+	return `${background}${line.split(reset).join(`${reset}${background}`)}${reset}`;
+}
+function shouldUseAnsi() {
+	if (process.env.NO_COLOR) return false;
+	if (process.env.FORCE_COLOR && process.env.FORCE_COLOR !== "0") return true;
+	return stdout.isTTY === true;
+}
+//#endregion
+//#region src/tui/messages.ts
+function systemMessage(text) {
+	return {
+		kind: "system",
+		text
+	};
+}
+function userMessage(text) {
+	return {
+		kind: "user",
+		text
+	};
+}
+function agentMessage(text, meta) {
+	return {
+		kind: "agent",
+		text,
+		meta
+	};
+}
+function toolCallMessage(call, label, resultSummary) {
+	return resultSummary === void 0 ? {
+		kind: "tool_call",
+		call,
+		label
+	} : {
+		kind: "tool_call",
+		call,
+		label,
+		resultSummary
+	};
+}
+function modalMessage(message) {
+	return {
+		kind: "modal",
+		...message
+	};
+}
+function renderChatMessage(message, options = {}) {
+	if (message.kind === "modal") return renderChatModal(message, options.selectedActionIndex);
+	if (message.kind === "tool_call") return renderToolCallMessage(message);
+	if (message.text.length === 0) return [""];
+	const lines = message.kind === "agent" && options.width !== void 0 ? renderMarkdown(message.text, Math.max(1, options.width - getPrefix(message.kind).length)) : message.text.split("\n");
+	if (message.kind === "user") return renderUserMessage(lines);
+	if (message.kind === "system") return renderSystemMessage(lines);
+	const prefix = getPrefix(message.kind);
+	const rendered = prefix.length === 0 ? lines : lines.map((line, index) => `${index === 0 ? prefix : " ".repeat(prefix.length)}${line}`);
+	if (message.meta) {
+		const metaText = `↳ ${message.meta}`;
+		rendered.push(` ${ui.label("─".repeat(metaText.length))}`, ` ${ui.label(metaText)}`);
+	}
+	return rendered;
+}
+function renderUserMessage(lines) {
+	const border = "▌";
+	const rendered = lines.map((line) => `${border} ${line}`);
+	return [
+		`${border} `,
+		...rendered,
+		`${border} `
+	];
+}
+function renderSystemMessage(lines) {
+	const bodyPrefix = "   ";
+	return [` ${ui.ok("✦")} ${ui.label("System")}:`, ...lines.map((line) => `${bodyPrefix}${formatSystemBodyLine(line)}`)];
+}
+function formatSystemBodyLine(line) {
+	return expandTabs(line).replace(/\(changed \+\d+\/-\d+\)$/u, (summary) => ui.muted(summary)).replace(/\(created \+\d+\)$/u, (summary) => ui.muted(summary));
+}
+function renderToolCallMessage(message) {
+	const visibleLabel = message.resultSummary && !message.label.includes(message.resultSummary) ? `${message.label} ${message.resultSummary}` : message.label;
+	return [`   ${ui.muted(expandTabs(visibleLabel))}`];
+}
+function expandTabs(line) {
+	let column = 0;
+	let expanded = "";
+	for (const char of line) {
+		if (char === "	") {
+			const spaces = 4 - column % 4;
+			expanded += " ".repeat(spaces);
+			column += spaces;
+			continue;
+		}
+		expanded += char;
+		column += 1;
+	}
+	return expanded;
+}
+function getPrefix(kind) {
+	switch (kind) {
+		case "agent": return " ";
+		case "user": return `${ui.label("You")}: `;
+		case "system": return `${ui.label("System")}: `;
+	}
+}
+function renderChatModal(message, selectedActionIndex) {
+	const icon = message.tone === "warning" ? "⚠️" : "ℹ️";
+	const title = message.tone === "warning" ? ui.warn(message.title) : ui.label(message.title);
+	const bodyLines = message.body ? ["", ...message.body.split("\n")] : [];
+	const actionLines = message.actions.map((action, index) => {
+		return `${selectedActionIndex === index ? ">" : " "} ${index + 1}) ${action.label}`;
+	});
+	const contentLines = [
+		`${icon}  ${title}:`,
+		...bodyLines,
+		"",
+		...actionLines
+	];
+	const contentWidth = Math.max(...contentLines.map(stripAnsi$1).map((line) => line.length), 1);
+	const top = `╭${"─".repeat(contentWidth + 2)}╮`;
+	const bottom = `╰${"─".repeat(contentWidth + 2)}╯`;
+	return [
+		top,
+		...contentLines.map((line) => `│ ${line}${" ".repeat(contentWidth - stripAnsi$1(line).length)} │`),
+		bottom
+	];
+}
+function stripAnsi$1(text) {
+	let plain = "";
+	for (let index = 0; index < text.length; index += 1) {
+		if (text.charCodeAt(index) === 27 && text[index + 1] === "[") {
+			index += 2;
+			while (index < text.length && text[index] !== "m") index += 1;
+			continue;
+		}
+		plain += text[index];
+	}
+	return plain;
+}
 const isoTimestampSchema = z.string().datetime({ offset: true });
 const jsonValueSchema = z.lazy(() => z.union([
 	z.string(),
@@ -3740,10 +4867,7 @@ function rehydrateSession(events) {
 			if (event.role === "user") visibleOnlyActionValues = /* @__PURE__ */ new Set();
 			break;
 		case "tool_call":
-			messages.push({
-				kind: "system",
-				text: event.label
-			});
+			messages.push(toolCallMessage(event.call, event.label));
 			break;
 		case "knowledge_status": break;
 		case "choice":
@@ -4140,189 +5264,6 @@ async function executeKbCommand(args, context) {
 	return { messages: ["Usage: /kb init, /kb compile, /kb sync, /kb reset, or /kb status"] };
 }
 //#endregion
-//#region src/tui/markdown.ts
-const codeFenceSentinel = "topchester-code-fence";
-function renderMarkdown(text, width) {
-	const lines = new Markdown(unwrapMarkdownCodeFences(text), 0, 0, getMarkdownTheme()).render(width);
-	const rendered = [];
-	let inCodeBlock = false;
-	for (const line of lines) {
-		if (line.includes(codeFenceSentinel)) {
-			inCodeBlock = !inCodeBlock;
-			continue;
-		}
-		rendered.push(inCodeBlock ? applyCodeBlockBackground(line) : line);
-	}
-	return rendered;
-}
-function unwrapMarkdownCodeFences(text) {
-	return text.replace(/^```(?:markdown|md)\s*\n([\s\S]*?)\n```$/gim, "$1");
-}
-function getMarkdownTheme() {
-	return {
-		heading: ui.label,
-		link: ui.label,
-		linkUrl: ui.muted,
-		code: ui.ok,
-		codeBlock: (text) => text,
-		codeBlockBorder: (text) => `${codeFenceSentinel}${ui.muted(text)}`,
-		quote: ui.warn,
-		quoteBorder: ui.warn,
-		hr: ui.muted,
-		listBullet: ui.label,
-		bold: (text) => decorate(text, "\x1B[1m", "\x1B[22m"),
-		italic: (text) => decorate(text, "\x1B[3m", "\x1B[23m"),
-		strikethrough: (text) => decorate(text, "\x1B[9m", "\x1B[29m"),
-		underline: (text) => decorate(text, "\x1B[4m", "\x1B[24m"),
-		codeBlockIndent: "  ",
-		highlightCode(code, lang) {
-			const validLanguage = lang && supportsLanguage(lang) ? lang : void 0;
-			if (!validLanguage) return code.split("\n");
-			try {
-				return highlight(code, {
-					language: validLanguage,
-					ignoreIllegals: true
-				}).split("\n");
-			} catch {
-				return code.split("\n");
-			}
-		}
-	};
-}
-function decorate(text, open, close) {
-	if (!shouldUseAnsi()) return text;
-	return `${open}${text}${close}`;
-}
-function applyCodeBlockBackground(line) {
-	if (!shouldUseAnsi()) return line;
-	const background = "\x1B[48;5;235m";
-	const reset = "\x1B[0m";
-	return `${background}${line.split(reset).join(`${reset}${background}`)}${reset}`;
-}
-function shouldUseAnsi() {
-	if (process.env.NO_COLOR) return false;
-	if (process.env.FORCE_COLOR && process.env.FORCE_COLOR !== "0") return true;
-	return stdout.isTTY === true;
-}
-//#endregion
-//#region src/tui/messages.ts
-function systemMessage(text) {
-	return {
-		kind: "system",
-		text
-	};
-}
-function userMessage(text) {
-	return {
-		kind: "user",
-		text
-	};
-}
-function agentMessage(text, meta) {
-	return {
-		kind: "agent",
-		text,
-		meta
-	};
-}
-function modalMessage(message) {
-	return {
-		kind: "modal",
-		...message
-	};
-}
-function renderChatMessage(message, options = {}) {
-	if (message.kind === "modal") return renderChatModal(message, options.selectedActionIndex);
-	if (message.text.length === 0) return [""];
-	const lines = message.kind === "agent" && options.width !== void 0 ? renderMarkdown(message.text, Math.max(1, options.width - getPrefix(message.kind).length)) : message.text.split("\n");
-	if (message.kind === "user") return renderUserMessage(lines);
-	if (message.kind === "system") return renderSystemMessage(lines);
-	const prefix = getPrefix(message.kind);
-	const rendered = prefix.length === 0 ? lines : lines.map((line, index) => `${index === 0 ? prefix : " ".repeat(prefix.length)}${line}`);
-	if (message.meta) {
-		const metaText = `↳ ${message.meta}`;
-		rendered.push(` ${ui.label("─".repeat(metaText.length))}`, ` ${ui.label(metaText)}`);
-	}
-	return rendered;
-}
-function renderUserMessage(lines) {
-	const border = "▌";
-	const rendered = lines.map((line) => `${border} ${line}`);
-	return [
-		`${border} `,
-		...rendered,
-		`${border} `
-	];
-}
-function renderSystemMessage(lines) {
-	const bodyPrefix = "   ";
-	return [` ${ui.ok("✦")} ${ui.label("System")}:`, ...lines.map((line) => `${bodyPrefix}${formatSystemBodyLine(line)}`)];
-}
-function formatSystemBodyLine(line) {
-	const expandedLine = expandTabs(line);
-	if (isToolCallLine(line)) return ui.muted(expandedLine);
-	return expandedLine.replace(/\(changed \+\d+\/-\d+\)$/u, (summary) => ui.muted(summary));
-}
-function isToolCallLine(line) {
-	return /^(read_file|list_files|grep|find_file|edit_file|inspect_command): /u.test(line);
-}
-function expandTabs(line) {
-	let column = 0;
-	let expanded = "";
-	for (const char of line) {
-		if (char === "	") {
-			const spaces = 4 - column % 4;
-			expanded += " ".repeat(spaces);
-			column += spaces;
-			continue;
-		}
-		expanded += char;
-		column += 1;
-	}
-	return expanded;
-}
-function getPrefix(kind) {
-	switch (kind) {
-		case "agent": return " ";
-		case "user": return `${ui.label("You")}: `;
-		case "system": return `${ui.label("System")}: `;
-	}
-}
-function renderChatModal(message, selectedActionIndex) {
-	const icon = message.tone === "warning" ? "⚠️" : "ℹ️";
-	const title = message.tone === "warning" ? ui.warn(message.title) : ui.label(message.title);
-	const bodyLines = message.body ? ["", ...message.body.split("\n")] : [];
-	const actionLines = message.actions.map((action, index) => {
-		return `${selectedActionIndex === index ? ">" : " "} ${index + 1}) ${action.label}`;
-	});
-	const contentLines = [
-		`${icon}  ${title}:`,
-		...bodyLines,
-		"",
-		...actionLines
-	];
-	const contentWidth = Math.max(...contentLines.map(stripAnsi$1).map((line) => line.length), 1);
-	const top = `╭${"─".repeat(contentWidth + 2)}╮`;
-	const bottom = `╰${"─".repeat(contentWidth + 2)}╯`;
-	return [
-		top,
-		...contentLines.map((line) => `│ ${line}${" ".repeat(contentWidth - stripAnsi$1(line).length)} │`),
-		bottom
-	];
-}
-function stripAnsi$1(text) {
-	let plain = "";
-	for (let index = 0; index < text.length; index += 1) {
-		if (text.charCodeAt(index) === 27 && text[index + 1] === "[") {
-			index += 2;
-			while (index < text.length && text[index] !== "m") index += 1;
-			continue;
-		}
-		plain += text[index];
-	}
-	return plain;
-}
-//#endregion
 //#region src/tui/keys.ts
 function isUpKey(data) {
 	return matchesKey(data, "up") || data === "\x1B[A";
@@ -4599,15 +5540,19 @@ var ChatLayout = class {
 	}
 	getConversationTurns() {
 		return this.messages.flatMap((message) => {
-			if (message.kind === "user" && message.modelContext !== false) return [{
-				role: "user",
-				text: message.text
-			}];
-			if (message.kind === "agent" && message.text !== "ready" && message.modelContext !== false) return [{
-				role: "assistant",
-				text: message.text
-			}];
-			return [];
+			switch (message.kind) {
+				case "user": return message.modelContext === false ? [] : [{
+					role: "user",
+					text: message.text
+				}];
+				case "agent": return message.text === "ready" || message.modelContext === false ? [] : [{
+					role: "assistant",
+					text: message.text
+				}];
+				case "system":
+				case "tool_call":
+				case "modal": return [];
+			}
 		});
 	}
 	get focused() {
@@ -4975,6 +5920,14 @@ async function executeToolCall(workspaceRoot, call, options = {}) {
 	}
 }
 function summarizeToolArgs(call) {
+	if (call.tool === "write_file") return {
+		path: call.args.path,
+		contentLength: call.args.content.length,
+		lineCount: countLogicalLines(call.args.content),
+		createParentDirs: Boolean(call.args.create_parent_dirs),
+		overwrite: Boolean(call.args.overwrite),
+		expectedHashProvided: Boolean(call.args.expected_hash)
+	};
 	if (call.tool !== "edit_file") return call.args;
 	return {
 		path: call.args.path,
@@ -4994,6 +5947,50 @@ function summarizeToolResult(result) {
 		stdoutLength: result.stdout.length,
 		stderrLength: result.stderr.length
 	};
+	if (result.tool === "git_status") return {
+		repoRoot: result.repoRoot,
+		branch: result.branch,
+		head: result.head,
+		hasHead: result.hasHead,
+		clean: result.clean,
+		fileCount: result.files.length,
+		truncated: result.truncated
+	};
+	if (result.tool === "git_diff") return {
+		repoRoot: result.repoRoot,
+		scope: result.scope,
+		path: result.path,
+		fileCount: result.fileCount,
+		truncated: result.truncated
+	};
+	if (result.tool === "git_log") return {
+		repoRoot: result.repoRoot,
+		commitCount: result.commits.length,
+		truncated: result.truncated
+	};
+	if (result.tool === "git_add") return {
+		repoRoot: result.repoRoot,
+		stagedPathCount: result.stagedPaths.length,
+		postStatusFileCount: result.files.length
+	};
+	if (result.tool === "git_commit") return {
+		repoRoot: result.repoRoot,
+		commit: result.commit.shortSha,
+		stagedPathCount: result.stagedPaths.length,
+		remainingFileCount: result.remainingFiles.length,
+		statLength: result.stat.length,
+		nameStatusLength: result.nameStatus.length
+	};
+	if (result.tool === "write_file") return {
+		hash: result.hash,
+		bytesWritten: result.bytesWritten,
+		lineCount: result.lineCount,
+		bytesChanged: result.bytesChanged,
+		lineDelta: result.lineDelta,
+		createdParentDirs: result.createdParentDirs,
+		kbState: result.kbState,
+		writeEvent: result.writeEvent
+	};
 	if (result.tool !== "edit_file") return {};
 	return {
 		beforeHash: result.beforeHash,
@@ -5004,6 +6001,11 @@ function summarizeToolResult(result) {
 		editEvent: result.editEvent
 	};
 }
+function countLogicalLines(content) {
+	if (content.length === 0) return 0;
+	const withoutTrailingLineEnding = content.replace(/\r?\n$/u, "");
+	return withoutTrailingLineEnding.length === 0 ? 1 : withoutTrailingLineEnding.split(/\r?\n/u).length;
+}
 //#endregion
 //#region src/agent/prompts.ts
 function getChatSystemPrompt() {
@@ -5030,10 +6032,15 @@ function getChatSystemPrompt() {
 		"- Use read/search tools when the user asks about files, code, symbols, usages, tests, or project behavior.",
 		"- Use find_file for path or filename lookup. Use grep for text inside files. If grep output mentions another path, treat that mentioned path as content until find_file or read_file confirms it exists.",
 		"- Use list_files, grep, find_file, and read_file for exact file listing, search, lookup, and reading tasks.",
+		"- Use git_status, git_diff, and git_log for Git state, diffs, and history. Prefer these over inspect_command for Git workflow inspection.",
+		"- Use git_add and git_commit only when the user explicitly asks to stage or commit. Never stage unrelated files, never stage '.', and never commit unless staged paths exactly match the user's request.",
 		"- Use inspect_command only for quick read-only repo orientation when a short familiar command chain is clearer than several dedicated tool calls.",
 		"- inspect_command is not a shell. Unsafe commands, shell expansion, scripts, installs, builds, tests, network access, and file mutation are not available through it.",
 		"- Use read_file before editing a file so your edit is based on current file content and hash metadata.",
 		"- Use edit_file for targeted edits to existing files. Make multiple disjoint edits for the same file in one call when possible.",
+		"- Use write_file to create new files by default. It fails when the file already exists unless you are replacing the whole file with overwrite:true and expected_hash from read_file.",
+		"- Pass write_file create_parent_dirs:true only when the user intent clearly includes creating that folder path.",
+		"- Do not use inspect_command for file creation or file mutation.",
 		"- Keep edit_file old_text small but unique. Do not include line labels or grep prefixes in old_text; use exact file text only.",
 		"- Use edit/write tools when they are available and the user asks you to implement, fix, add, update, or refactor code.",
 		"- Use command/test tools when they are available and you need to inspect the environment, run tests, format, lint, typecheck, or verify behavior.",
@@ -5226,6 +6233,18 @@ function formatToolResultForPrompt(result) {
 		result.diff,
 		"```"
 	].join("\n");
+	if (result.tool === "write_file") return [
+		`Tool result from ${result.tool}${path}:`,
+		result.beforeHash ? `before_hash: ${result.beforeHash}` : "",
+		`after_hash: ${result.hash}`,
+		`bytes_written: ${result.bytesWritten}`,
+		result.bytesChanged !== void 0 ? `bytes_changed: ${result.bytesChanged}` : "",
+		`line_count: ${result.lineCount}`,
+		result.lineDelta !== void 0 ? `line_delta: ${result.lineDelta}` : "",
+		`kb_state: ${result.kbState}`,
+		result.createdParentDirs.length > 0 ? `created_parent_dirs: ${result.createdParentDirs.join(", ")}` : "",
+		`summary: ${result.writeEvent.writeSummary}`
+	].filter(Boolean).join("\n");
 	if (result.tool === "inspect_command") return [
 		`Tool result from ${result.tool} via ${result.command}:`,
 		`cwd: ${result.cwd}`,
@@ -5238,6 +6257,61 @@ function formatToolResultForPrompt(result) {
 		result.content,
 		"```"
 	].filter(Boolean).join("\n");
+	if (result.tool === "git_status") return [
+		`Tool result from ${result.tool}${path}:`,
+		`repo_root: ${result.repoRoot ?? "(none)"}`,
+		`branch: ${result.branch ?? "(detached)"}`,
+		`head: ${result.head ?? "(none)"}`,
+		`has_head: ${result.hasHead}`,
+		`clean: ${result.clean}`,
+		`changed_file_count: ${result.files.length}`,
+		`truncated: ${result.truncated}`,
+		warning ? warning.trimStart() : "",
+		"```",
+		result.content,
+		"```"
+	].filter(Boolean).join("\n");
+	if (result.tool === "git_diff") return [
+		`Tool result from ${result.tool}${path}:`,
+		`repo_root: ${result.repoRoot ?? "(none)"}`,
+		`scope: ${result.scope}`,
+		`path: ${result.path ?? "(all)"}`,
+		`file_count: ${result.fileCount}`,
+		`truncated: ${result.truncated}`,
+		warning ? warning.trimStart() : "",
+		"```diff",
+		result.content,
+		"```"
+	].filter(Boolean).join("\n");
+	if (result.tool === "git_log") return [
+		`Tool result from ${result.tool}${path}:`,
+		`repo_root: ${result.repoRoot ?? "(none)"}`,
+		`commit_count: ${result.commits.length}`,
+		`truncated: ${result.truncated}`,
+		warning ? warning.trimStart() : "",
+		"```",
+		result.content,
+		"```"
+	].filter(Boolean).join("\n");
+	if (result.tool === "git_add") return [
+		`Tool result from ${result.tool}:`,
+		`repo_root: ${result.repoRoot ?? "(none)"}`,
+		`staged_paths: ${result.stagedPaths.join(", ")}`,
+		warning ? warning.trimStart() : "",
+		"```",
+		result.content,
+		"```"
+	].filter(Boolean).join("\n");
+	if (result.tool === "git_commit") return [
+		`Tool result from ${result.tool}:`,
+		`repo_root: ${result.repoRoot ?? "(none)"}`,
+		`commit: ${result.commit.shortSha} ${result.commit.subject}`,
+		`staged_paths: ${result.stagedPaths.join(", ")}`,
+		`remaining_changed_file_count: ${result.remainingFiles.length}`,
+		"```",
+		result.content,
+		"```"
+	].join("\n");
 	return [
 		`Tool result from ${result.tool}${path}${command}:${warning}`,
 		"```",
@@ -5255,13 +6329,27 @@ function formatToolCallMessage(call, result) {
 		case "grep": return `grep: ${call.args.pattern} in ${call.args.path ?? "."}`;
 		case "find_file": return `find_file: ${call.args.query} in ${call.args.path}`;
 		case "edit_file": return `edit_file: ${call.args.path}${formatEditFileChangeSummary(result)}`;
+		case "write_file": return `write_file: ${call.args.path}${formatWriteFileChangeSummary(result)}`;
+		case "git_status": return `git_status: ${result?.tool === "git_status" ? `${result.files.length} changed` : call.args.path}`;
+		case "git_diff": return `git_diff: ${formatGitDiffCallSummary(call, result)}`;
+		case "git_log": return `git_log: ${result?.tool === "git_log" ? `${result.commits.length} commits` : `${call.args.limit} commits`}`;
+		case "git_add": return `git_add: ${result?.tool === "git_add" ? `${result.stagedPaths.length} files staged` : `${call.args.paths.length} files`}`;
+		case "git_commit": return `git_commit: ${result?.tool === "git_commit" ? `${result.commit.shortSha} ${result.commit.subject}` : call.args.message}`;
 		case "inspect_command": return `inspect_command: ${call.args.command}`;
 	}
 }
+function formatGitDiffCallSummary(call, result) {
+	if (result?.tool === "git_diff") return `${result.scope} (${result.fileCount} files${result.truncated ? ", truncated" : ""})`;
+	return call.args.scope;
+}
 function formatEditFileChangeSummary(result) {
 	if (result?.tool !== "edit_file") return "";
 	return ` (changed ${result.editEvent.diffSummary})`;
 }
+function formatWriteFileChangeSummary(result) {
+	if (result?.tool !== "write_file") return "";
+	return ` (${result.writeEvent.writeSummary})`;
+}
 function formatAgentMessageMeta(model, durationMs) {
 	return `${model} · ${formatDuration$1(durationMs)}`;
 }
@@ -5285,7 +6373,7 @@ function formatNumber(value, fractionDigits) {
 function renderRuntimeEvent(event) {
 	switch (event.type) {
 		case "message": return [event.role === "assistant" ? agentMessage(event.text, event.meta) : systemMessage(event.text)];
-		case "tool_call": return [systemMessage(event.label)];
+		case "tool_call": return [toolCallMessage(event.call, event.label)];
 		case "knowledge_status": return [systemMessage([`KB status: ${formatKnowledgePathStatus(event.status)}${formatKbPathSource(event.status)}`, event.guidance].filter(Boolean).join("\n"))];
 		case "choice": return [modalMessage({
 			tone: event.tone,
@@ -5501,9 +6589,14 @@ async function persistMessagesWithWarning(session, messages, warningTarget = mes
 	}
 }
 function chatMessageToSessionPayload(message) {
-	if (message.kind === "system" || message.kind === "user" || message.kind === "agent") return {
+	if (message.kind === "system" || message.kind === "user") return {
+		kind: "message",
+		role: message.kind,
+		text: message.text
+	};
+	if (message.kind === "agent") return {
 		kind: "message",
-		role: message.kind === "agent" ? "assistant" : message.kind,
+		role: "assistant",
 		text: message.text,
 		...message.meta === void 0 ? {} : { meta: message.meta }
 	};
@@ -5514,6 +6607,11 @@ function chatMessageToSessionPayload(message) {
 		...message.body === void 0 ? {} : { body: message.body },
 		actions: message.actions
 	};
+	if (message.kind === "tool_call") return {
+		kind: "tool_call",
+		label: message.label,
+		call: message.call
+	};
 }
 function runtimeEventToSessionPayload(event) {
 	switch (event.type) {
@@ -5738,16 +6836,19 @@ async function resolveRunSession(workspaceRoot, resume) {
 }
 async function loadConversation(workspaceRoot, resume) {
 	return rehydrateSession((await loadSession(workspaceRoot, resume)).events).messages.flatMap((message) => {
-		if (message.kind === "modal" || message.modelContext === false) return [];
-		if (message.kind === "user") return [{
-			role: "user",
-			text: message.text
-		}];
-		if (message.kind === "agent") return [{
-			role: "assistant",
-			text: message.text
-		}];
-		return [];
+		switch (message.kind) {
+			case "user": return message.modelContext === false ? [] : [{
+				role: "user",
+				text: message.text
+			}];
+			case "agent": return message.modelContext === false ? [] : [{
+				role: "assistant",
+				text: message.text
+			}];
+			case "system":
+			case "tool_call":
+			case "modal": return [];
+		}
 	});
 }
 async function persistStartupMessages(session, context) {