feat(prompt): teach the agent what glue used to hide

Three new sections in the static system prompt to absorb the work
the chat-intercept used to do:

- "# Answering questions about yourself" — tells the model to name
  its underlying provider/model honestly when asked, and to never
  promise to "remember" things across turns. Fixes the "I'm Codebase,
  no need to dig deeper" / "I'll keep that in mind" hallucinations.

- "# Using your tools" — issue independent tool calls in parallel,
  and prefer dispatch_agent fan-out for multi-file audits / reviews
  so each stream runs concurrently with its context isolated.

The prompt stays byte-stable across calls for the prompt cache.

Author: halfaipg

src/agent/system-prompt.test.ts

@@ -10,6 +10,30 @@ describe("buildSystemPrompt", () => {
 		expect(out.startsWith("You are codebase")).toBe(true);
 	});
 
+	it("tells the model to answer the underlying-model question honestly", () => {
+		// Regression: a previous chat-intercept path made the CLI claim
+		// to be an opaque "Codebase" persona that wouldn't name its
+		// underlying LLM. Now the agent owns this turn and must answer
+		// honestly — and must not promise to "remember" things across
+		// turns since transcript state is the user-visible source of truth.
+		const out = buildSystemPrompt();
+		expect(out).toContain("# Answering questions about yourself");
+		expect(out).toMatch(/answer honestly/i);
+		expect(out).toMatch(/never promise to "remember"/i);
+	});
+
+	it("tells the model to issue independent tool calls in parallel", () => {
+		const out = buildSystemPrompt();
+		expect(out).toContain("# Using your tools");
+		expect(out).toMatch(/Issue independent tool calls together/);
+	});
+
+	it("teaches subagent dispatch for fan-out work", () => {
+		const out = buildSystemPrompt();
+		expect(out).toMatch(/dispatch_agent/);
+		expect(out).toMatch(/parallel/i);
+	});
+
 	it("includes a 'What NOT to do' anti-pattern section", () => {
 		const out = buildSystemPrompt();
 		expect(out).toContain("# What NOT to do");

src/agent/system-prompt.ts

@@ -40,6 +40,22 @@ export function buildSystemPrompt(opts: BuildSystemPromptOptions = {}): string {
 		"- Match the response shape to the task: a simple question gets a direct answer, not headers and sections.",
 	);
 	lines.push("");
+	lines.push("# Answering questions about yourself");
+	lines.push(
+		"You are a thin shell around an underlying LLM that the user picked. When asked what model powers you, answer honestly: name the provider and model id from the environment if it's been surfaced to you, and say you don't know if it hasn't. Do not refuse the question, dodge it, or invent a brand persona — the user already knows they're using codebase, they want to know what's underneath.",
+	);
+	lines.push(
+		"For small talk, greetings, and meta-questions about what you can do: answer briefly in one or two sentences. Never promise to \"remember\" or \"keep in mind\" something — turn-to-turn state lives in the transcript the user can already see, not in your memory.",
+	);
+	lines.push("");
+	lines.push("# Using your tools");
+	lines.push(
+		"Issue independent tool calls together in a single response. If you need to read three files whose contents don't depend on each other, request all three reads at once instead of one per turn — sequential reads are the slow path and should only happen when a later call genuinely needs an earlier call's result. The same applies to greps, glob queries, and any read-only investigation.",
+	);
+	lines.push(
+		"When a task fans out cleanly — multi-file audits, security reviews, broad codebase exploration — prefer dispatching subagents via dispatch_agent so each stream runs in parallel and their context stays out of your main loop. Don't also do the same searches yourself; that wastes turns and doubles the noise.",
+	);
+	lines.push("");
 	lines.push("# What NOT to do");
 	lines.push(
 		"- Don't add features, refactor, or invent abstractions beyond what was asked. A bug fix doesn't need surrounding cleanup; a one-shot operation doesn't need a helper. Three similar lines is better than a premature abstraction.",