refactor(glue): drop "chat" from the Intent classifier

Removes the dead "chat" intent value, the isGreeting regex shortcut,
and the GREETING_PATTERNS table. classifyIntent now decides only
between agent | plan | clarify, and the rewritten system prompt
tells the classifier that greetings, gratitude, and meta-questions
all belong to the agent.

parseIntent returns null on the legacy "chat" string so an old
classifier model that still emits "chat" from training data
defaults to "agent" via the existing fallback path — no silent
stranding of real requests.

Author: halfaipg

src/agent/router.test.ts

@@ -4,7 +4,9 @@ import { routeUserInput } from "./router.js";
 
 function mockGlue(replies: { intent?: string }): GlueClient {
 	const fast = vi.fn(async (_prompt: string, system?: string) => {
-		if (system?.includes("classify")) return replies.intent ?? "agent";
+		// Match the intent-classifier system prompt case-insensitively so
+		// this mock keeps working if the prompt's capitalisation drifts.
+		if (system && /classif/i.test(system)) return replies.intent ?? "agent";
 		return "agent";
 	});
 	return { fast, smart: fast } as unknown as GlueClient;

src/glue/intent.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from "vitest";
-import { classifyIntent, isGreeting, parseIntent } from "./intent.js";
+import { classifyIntent, parseIntent } from "./intent.js";
 
 function fakeGlue(reply: string) {
 	return {
@@ -19,35 +19,20 @@ function failingGlue() {
 	} as unknown as Parameters<typeof classifyIntent>[0];
 }
 
-describe("isGreeting", () => {
-	it("matches short greetings and acknowledgements", () => {
-		expect(isGreeting("hi")).toBe(true);
-		expect(isGreeting("hey")).toBe(true);
-		expect(isGreeting("thanks")).toBe(true);
-		expect(isGreeting("ty")).toBe(true);
-		expect(isGreeting("ok")).toBe(true);
-		expect(isGreeting("good morning")).toBe(true);
-	});
-
-	it("rejects content that just starts with a greeting word", () => {
-		expect(isGreeting("hi can you help me write a parser for json")).toBe(false);
-		expect(isGreeting("thanks for your help with the auth refactor please review")).toBe(false);
-	});
-
-	it("rejects unrelated short messages", () => {
-		expect(isGreeting("debug the build")).toBe(false);
-		expect(isGreeting("read main.go")).toBe(false);
-	});
-});
-
 describe("parseIntent", () => {
 	it("parses bare words", () => {
 		expect(parseIntent("agent")).toBe("agent");
 		expect(parseIntent("plan")).toBe("plan");
-		expect(parseIntent("chat")).toBe("chat");
 		expect(parseIntent("clarify")).toBe("clarify");
 	});
 
+	it("no longer recognizes the dead 'chat' intent", () => {
+		// Chat was removed when we ripped out the glue intercept. A model
+		// that still says "chat" gets null here so the caller defaults to
+		// "agent" — which is what we want.
+		expect(parseIntent("chat")).toBeNull();
+	});
+
 	it("strips trailing punctuation", () => {
 		expect(parseIntent("agent.")).toBe("agent");
 		expect(parseIntent("plan!")).toBe("plan");
@@ -70,15 +55,12 @@ describe("classifyIntent", () => {
 		await expect(classifyIntent(glue, "  ", { hasHistory: true })).resolves.toBe("clarify");
 	});
 
-	it("short-circuits greetings to 'chat' on continuation", async () => {
+	it("routes greetings to the agent (the glue chat shortcut is gone)", async () => {
+		// Previously "thanks!" would have skipped the LLM and shortcut to
+		// "chat". Now the classifier is asked, and the prompt explicitly
+		// tells it small talk is the agent's job — so we expect "agent".
 		const glue = fakeGlue("agent");
-		await expect(classifyIntent(glue, "thanks!", { hasHistory: true })).resolves.toBe("chat");
-		expect(glue.fast).not.toHaveBeenCalled();
-	});
-
-	it("does NOT short-circuit greetings on first message (no history)", async () => {
-		const glue = fakeGlue("agent");
-		await classifyIntent(glue, "hi", { hasHistory: false });
+		await expect(classifyIntent(glue, "thanks!", { hasHistory: true })).resolves.toBe("agent");
 		expect(glue.fast).toHaveBeenCalled();
 	});
 
@@ -98,4 +80,11 @@ describe("classifyIntent", () => {
 		const glue = fakeGlue("idk lol");
 		await expect(classifyIntent(glue, "do something", { hasHistory: true })).resolves.toBe("agent");
 	});
+
+	it("falls back to 'agent' when a stale model returns the removed 'chat' intent", async () => {
+		// Belt-and-braces: if a cheap classifier still emits "chat" from
+		// training data, we don't want to silently strand the request.
+		const glue = fakeGlue("chat");
+		await expect(classifyIntent(glue, "what's up", { hasHistory: true })).resolves.toBe("agent");
+	});
 });

src/glue/intent.ts

@@ -1,57 +1,42 @@
 import type { GlueClient } from "./client.js";
 
-export type Intent = "agent" | "plan" | "chat" | "clarify";
-
-const INTENT_SYSTEM_PROMPT = `You classify the user's message into ONE of these intents:
+/**
+ * Intent classifications the router actually acts on. "chat" used to
+ * be in this set but was removed when we ripped out the
+ * cheap-model chat intercept — small talk now goes to the main agent.
+ * "clarify" remains so we can wire an ask-back path later, but for
+ * now it routes the same as "agent".
+ */
+export type Intent = "agent" | "plan" | "clarify";
 
-- agent: a coding/automation/build/fix request. Run-the-tools work. (Default for anything actionable.)
-- plan: a complex multi-step ask that benefits from upfront planning before code is written ("add auth to my Next app", "rewrite the worker as a state machine").
-- chat: small talk, gratitude, greetings, meta-questions about the agent itself.
-- clarify: ambiguous request where the agent couldn't act productively without more info.
+const INTENT_SYSTEM_PROMPT = `Classify the user's message into ONE of these intents. Output exactly one word, no prose.
 
-Output exactly one word: agent | plan | chat | clarify. No prose.`;
+- agent: a coding, automation, build, fix, or run-the-tools request. Default for anything actionable, including small talk, greetings, gratitude, and meta-questions about the agent itself — the main agent handles those directly now.
+- plan: a complex multi-step ask that benefits from upfront planning before any code is written (e.g. "add auth to my Next app", "rewrite the worker as a state machine"). Reserve this for genuinely multi-file architectural work.
+- clarify: ambiguous or contradictory request where acting without more information would be a mistake.
 
-const GREETING_PATTERNS = [
-	/^h(i|ello|ey)\b/i,
-	/^howdy\b/i,
-	/^thanks?\b/i,
-	/^thank you\b/i,
-	/^ty\b/i,
-	/^ok\b/i,
-	/^okay\b/i,
-	/^nice\b/i,
-	/^cool\b/i,
-	/^great\b/i,
-	/^good (morning|afternoon|evening|night)\b/i,
-];
+Reply with exactly one of: agent | plan | clarify.`;
 
 export interface ClassifyOptions {
 	hasHistory: boolean;
 	signal?: AbortSignal;
 }
 
 /**
- * Decide whether the user's message should run the main agent (tool
- * work), enter plan mode (Q&A → reviewable plan), be answered as chat
- * (no agent run), or trigger a clarifying question.
- *
- * Fast-tracks:
- *   - First message in a session: default to "agent" for anything
- *     non-trivial (history-less context biases toward action).
- *   - Continuations starting with greetings/thanks: short-circuit to
- *     "chat" without an LLM call.
+ * Decide whether the user's message should auto-trigger plan mode
+ * (Q&A → reviewable plan → agent execution) or just fall through to
+ * the main agent. Greetings and meta-questions used to get a
+ * "chat" short-circuit; that's gone — the main agent answers those
+ * itself now.
  *
- * On LLM error or unparseable output, defaults to "agent" — failing
- * open is preferable to silently dropping a real request.
+ * On LLM error or unparseable output, defaults to "agent". Failing
+ * open is preferable to silently swallowing a real request because a
+ * cheap classifier model hiccuped.
  */
 export async function classifyIntent(glue: GlueClient, message: string, opts: ClassifyOptions): Promise<Intent> {
 	const trimmed = message.trim();
 	if (!trimmed) return "clarify";
 
-	if (opts.hasHistory && isGreeting(trimmed)) {
-		return "chat";
-	}
-
 	let raw: string;
 	try {
 		raw = await glue.fast(trimmed, INTENT_SYSTEM_PROMPT, opts.signal);
@@ -62,24 +47,20 @@ export async function classifyIntent(glue: GlueClient, message: string, opts: Cl
 	return parseIntent(raw) ?? "agent";
 }
 
-export function isGreeting(message: string): boolean {
-	if (message.split(/\s+/).length > 4) return false;
-	return GREETING_PATTERNS.some((re) => re.test(message));
-}
-
 export function parseIntent(raw: string): Intent | null {
 	const word = raw
 		.trim()
 		.toLowerCase()
 		.replace(/[^a-z]/g, "");
 	if (word === "agent") return "agent";
 	if (word === "plan") return "plan";
-	if (word === "chat") return "chat";
 	if (word === "clarify") return "clarify";
-	// Be lenient: take the first matching token from a longer reply.
+	// Lenient pass: pick the first matching token from a longer reply so a
+	// chatty cheap model that ignores the "one word" instruction doesn't
+	// silently fall through to the "agent" default.
 	for (const candidate of raw.toLowerCase().split(/[^a-z]+/)) {
-		if (candidate === "agent" || candidate === "plan" || candidate === "chat" || candidate === "clarify") {
-			return candidate as Intent;
+		if (candidate === "agent" || candidate === "plan" || candidate === "clarify") {
+			return candidate;
 		}
 	}
 	return null;