refactor(router): remove the glue chat intercept path

The chat path routed any "meta-question about the agent itself" to
a cheap glue model with a "warm, no tools" system prompt. That model
hallucinated identity and capability — claiming to remember things
it couldn't, refusing to name its underlying model — without ever
involving the real agent. Greetings and small talk now go to the
main agent like every other turn.

routeUserInput returns only { kind: "agent" | "plan" }; the chat
variant, chatReply helper, and CHAT_SYSTEM_PROMPT are deleted. App
loses its route.kind === "chat" branch. classifyIntent still
returns "chat" today (cleaned up in a follow-up) — when it does, the
router falls through to "agent".

Author: halfaipg

src/agent/router.test.ts

@@ -2,10 +2,9 @@ import { describe, expect, it, vi } from "vitest";
 import type { GlueClient } from "../glue/client.js";
 import { routeUserInput } from "./router.js";
 
-function mockGlue(replies: { intent?: string; chat?: string }): GlueClient {
+function mockGlue(replies: { intent?: string }): GlueClient {
 	const fast = vi.fn(async (_prompt: string, system?: string) => {
 		if (system?.includes("classify")) return replies.intent ?? "agent";
-		if (system?.includes("chatting casually")) return replies.chat ?? "ok";
 		return "agent";
 	});
 	return { fast, smart: fast } as unknown as GlueClient;
@@ -17,42 +16,26 @@ describe("routeUserInput", () => {
 		await expect(routeUserInput(glue, "fix the build", { hasHistory: true })).resolves.toEqual({ kind: "agent" });
 	});
 
-	it("returns 'chat' with a glue reply when intent classifies to chat", async () => {
-		const glue = mockGlue({ intent: "chat", chat: "you're welcome!" });
-		const out = await routeUserInput(glue, "thanks", { hasHistory: true });
-		expect(out.kind).toBe("chat");
-		if (out.kind === "chat") expect(out.reply).toBe("you're welcome!");
-	});
-
-	it("short-circuits greetings to chat without an LLM intent call", async () => {
-		const glue = mockGlue({ chat: "hello there" });
-		const out = await routeUserInput(glue, "hi", { hasHistory: true });
-		expect(out.kind).toBe("chat");
-		// greeting fast-track in classifyIntent skips the intent call entirely;
-		// only the chat-reply call to glue.fast should fire.
-		expect(glue.fast).toHaveBeenCalledTimes(1);
-	});
-
-	it("returns 'plan' when intent is plan", async () => {
+	it("returns 'plan' when intent classifies to plan", async () => {
 		const glue = mockGlue({ intent: "plan" });
 		await expect(
 			routeUserInput(glue, "rewrite the worker as a state machine", { hasHistory: false }),
-		).resolves.toEqual({
-			kind: "plan",
-		});
+		).resolves.toEqual({ kind: "plan" });
 	});
 
-	it("falls back to 'chat' with a placeholder when chat reply fails", async () => {
-		const failingGlue = {
-			fast: vi.fn(async (_p: string, system?: string) => {
-				if (system?.includes("classify")) return "chat";
-				throw new Error("network");
-			}),
-			smart: vi.fn(),
-		} as unknown as GlueClient;
-		const out = await routeUserInput(failingGlue, "thanks", { hasHistory: true });
-		expect(out.kind).toBe("chat");
-		if (out.kind === "chat") expect(out.reply).toBe("👍");
+	it("routes greetings to the agent (the chat-intercept path is gone)", async () => {
+		// Greetings used to be hijacked into a glue chat reply with no tools
+		// or context. They now go straight to the main agent like any other
+		// turn — the system prompt teaches it to handle small talk briefly.
+		const glue = mockGlue({ intent: "agent" });
+		await expect(routeUserInput(glue, "hi", { hasHistory: true })).resolves.toEqual({ kind: "agent" });
+	});
+
+	it("treats an unexpected intent as agent (failing open)", async () => {
+		const glue = mockGlue({ intent: "clarify" });
+		await expect(routeUserInput(glue, "what should I do next?", { hasHistory: true })).resolves.toEqual({
+			kind: "agent",
+		});
 	});
 
 	it("falls back to 'agent' when intent classification errors", async () => {
@@ -62,8 +45,6 @@ describe("routeUserInput", () => {
 			}),
 			smart: vi.fn(),
 		} as unknown as GlueClient;
-		// Use a non-greeting input — greetings short-circuit to chat before the
-		// LLM is consulted, which would change the test premise.
 		await expect(routeUserInput(failingGlue, "fix the build", { hasHistory: true })).resolves.toEqual({
 			kind: "agent",
 		});

src/agent/router.ts

@@ -1,45 +1,34 @@
 import type { GlueClient } from "../glue/client.js";
 import { classifyIntent } from "../glue/intent.js";
 
-const CHAT_SYSTEM_PROMPT =
-	"You're chatting casually with the user — small talk, gratitude, greetings, meta-questions. Reply briefly (one or two sentences), warm tone, no code unless explicitly asked.";
-
-export type RouteOutcome = { kind: "agent" } | { kind: "chat"; reply: string } | { kind: "plan" };
+/**
+ * Routing decision returned to App.tsx. We only ever return two real
+ * destinations now — the main agent or the plan flow. The chat path
+ * (intercepting small-talk/meta-questions with a cheap glue model) was
+ * removed because it made the CLI confidently hallucinate identity and
+ * capability when the user asked the obvious meta questions. All
+ * conversation now goes through the agent, which has tools and the
+ * actual system prompt.
+ */
+export type RouteOutcome = { kind: "agent" } | { kind: "plan" };
 
 export interface RouteOptions {
 	hasHistory: boolean;
 	signal?: AbortSignal;
 }
 
 /**
- * Decide what to do with a user input before involving the main agent:
- *   - "chat" → glue reply, no agent run (greetings, thanks, meta)
- *   - "plan" → caller enters the plan flow (Q&A → reviewable plan → agent)
- *   - "agent" → fall through to agent.prompt as before
- *
- * Glue failures degrade to "agent" so a flaky cheap model never silently
- * eats a real request — same fallback policy classifyIntent already uses.
+ * Decide whether the user's input should auto-trigger plan mode (the
+ * Q&A → reviewable-plan → agent-execution flow) or just hit the main
+ * agent. Glue is consulted only for the plan/agent split — if it
+ * returns any other intent, or the call fails, we default to the
+ * agent. Failing-open keeps a flaky cheap model from silently eating
+ * real requests.
  */
 export async function routeUserInput(glue: GlueClient, text: string, options: RouteOptions): Promise<RouteOutcome> {
 	const intent = await classifyIntent(glue, text, options);
-	if (intent === "chat") {
-		const reply = await chatReply(glue, text, options.signal);
-		return { kind: "chat", reply };
-	}
 	if (intent === "plan") {
 		return { kind: "plan" };
 	}
-	// agent + clarify both go through the main agent. A future "clarify" mode
-	// could surface a system reminder via agent.steer() before running the turn.
 	return { kind: "agent" };
 }
-
-async function chatReply(glue: GlueClient, text: string, signal?: AbortSignal): Promise<string> {
-	try {
-		const out = await glue.fast(text, CHAT_SYSTEM_PROMPT, signal);
-		return out.trim() || "👍";
-	} catch {
-		// Glue down — at least acknowledge so the input row isn't dead silent.
-		return "👍";
-	}
-}

src/ui/App.tsx

@@ -309,10 +309,6 @@ function ChatApp({ initialBundle, onExit }: ChatAppProps) {
 
 		try {
 			const route = await routeUserInput(bundle.glue, text, { hasHistory: hadHistory });
-			if (route.kind === "chat") {
-				dispatch({ type: "chat-reply", text: route.reply });
-				return;
-			}
 			if (route.kind === "plan") {
 				await runPlanFlow(bundle, text, {
 					onReply: (replyText) => dispatch({ type: "chat-reply", text: replyText }),