fix(git): render untracked file contents as diff additions

The body of an untracked file was inlined under a `--- /dev/null` header with no
`+` prefixes, so it was not a hunk - it was the file's own syntax sitting where
diff syntax was expected. A new markdown file's `- item` read back as a deleted
line, front matter as a header, and the generated message described changes
nobody made.

Each content line is prefixed now. A trailing newline is not turned into a bare
`+`, and the binary and unreadable markers stay unprefixed: they annotate the
block rather than claiming to be its content.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: Rafael-Silva-Oliveira

src/utils/__tests__/git.spec.ts

@@ -547,7 +547,31 @@ describe("git utils", () => {
 
 			expect(context.files).toEqual([{ status: "untracked", path: "src/added.ts" }])
 			expect(context.diff).toContain("+++ b/src/added.ts")
-			expect(context.diff).toContain("export const answer = 42")
+			// Prefixed, so the body reads as an addition rather than as pasted text.
+			expect(context.diff).toContain("+export const answer = 42")
+			// The file's trailing newline is not a line of its own.
+			expect(context.diff.split("\n")).not.toContain("+")
+		})
+
+		// An unprefixed body is not a diff, it is the file's own syntax: `- item` reads as a
+		// deletion and `---` as a header, so the model reports changes that were never made.
+		it("should render untracked contents as additions rather than diff syntax", async () => {
+			mockProbes()
+			mockGit(workingTree(`?? notes.md${NUL}`, ""))
+			mockUntrackedFile(Buffer.from("---\ntitle: Notes\n---\n\n- first item\n+++ b/not-a-header\n"))
+
+			const lines = (await expectContext()).diff.split("\n")
+
+			expect(lines).toEqual([
+				"--- /dev/null",
+				"+++ b/notes.md",
+				"+---",
+				"+title: Notes",
+				"+---",
+				"+",
+				"+- first item",
+				"++++ b/not-a-header",
+			])
 		})
 
 		it("should mark binary untracked files instead of inlining them", async () => {

src/utils/git.ts

@@ -588,7 +588,9 @@ async function readUntrackedFiles(cwd: string, files: GitFileChange[]): Promise<
 	const blocks: string[] = []
 
 	for (const file of untracked.slice(0, UNTRACKED_FILE_LIMIT)) {
-		blocks.push(`--- /dev/null\n+++ b/${file.path}\n${await readUntrackedFile(cwd, file.path)}`)
+		const body = await readUntrackedFile(cwd, file.path)
+
+		blocks.push([`--- /dev/null`, `+++ b/${file.path}`, body].filter(Boolean).join("\n"))
 	}
 
 	// The rest are still worth naming - that files were added is part of the change even when there
@@ -602,6 +604,23 @@ async function readUntrackedFiles(cwd: string, files: GitFileChange[]): Promise<
 	return blocks.join("\n\n")
 }
 
+/**
+ * Marks each line as an addition, which is what makes the block a diff rather than pasted text.
+ * Unprefixed, a new file's own content is read as diff syntax: a markdown bullet becomes a deleted
+ * line, front matter becomes a header, and the message describes changes nobody made.
+ */
+function asAddedLines(text: string): string {
+	const lines = text.split("\n")
+
+	// A file ending in a newline splits into a trailing empty segment. Prefixing it would add a
+	// bare `+` for a line the file does not have.
+	if (lines[lines.length - 1] === "") {
+		lines.pop()
+	}
+
+	return lines.map((line) => `+${line}`).join("\n")
+}
+
 /** Reads at most `UNTRACKED_FILE_BYTE_LIMIT` bytes, so a huge file costs one bounded read. */
 async function readUntrackedFile(cwd: string, filePath: string): Promise<string> {
 	let handle
@@ -618,7 +637,7 @@ async function readUntrackedFile(cwd: string, filePath: string): Promise<string>
 			return "(binary file)"
 		}
 
-		const text = contents.toString("utf8")
+		const text = asAddedLines(contents.toString("utf8"))
 
 		return bytesRead < UNTRACKED_FILE_BYTE_LIMIT ? text : `${text}\n(truncated)`
 	} catch {