@gajae-code/coding-agent 0.15.2 → 0.15.4

package/src/session/fallback-chain-controller.ts

@@ -155,6 +155,23 @@ export class FallbackChainController {
 		return this.advance() ? "advance" : "exhausted";
 	}
 
+	/**
+	 * Record one bounded escaped-argument exhaustion for the active model and
+	 * advance immediately. The discarded wire attempts are intentionally not
+	 * provider charges; this single policy charge prevents the same model from
+	 * being retried forever while still allowing every eligible fallback model
+	 * its own literal-UTF-8 recovery budget.
+	 */
+	recordEscapedArgumentsFailure(reason: string, advance = true): boolean {
+		const selector = this.currentSelector();
+		if (!selector || this.exhaustedForTurn) return false;
+		this.#attemptStarted = false;
+		this.attemptsUsed = this.maxAttempts;
+		this.#totalAttemptsUsed += 1;
+		this.tried.push({ selector, triggerClass: "unknown", reason });
+		return advance ? this.advance() : this.activeIndex + 1 < this.chain.entries.length;
+	}
+
 	advance(): boolean {
 		if (this.exhaustedForTurn) return false;
 		this.activeIndex += 1;

package/src/setup/frictionless-onboarding.ts

@@ -196,10 +196,10 @@ function scriptScores(text: string): Map<string, number> {
 	const kana = counts.get("ja") ?? 0;
 	const han = counts.get("zh") ?? 0;
 	const scores = new Map<string, number>();
-	// Korean hangul is decisive when it is at least as strong as kana; Japanese
-	// kana claims mixed han so Chinese does not win on kanji alone. A claimant
-	// below the evidence minimum is stray-glyph noise and must not erase
-	// dominant han evidence.
+	// Korean Hangul is decisive only once it reaches the evidence minimum and is
+	// at least as strong as kana; an equal sub-threshold Hangul/kana pair leaves
+	// dominant Han evidence intact. Japanese kana claims mixed Han whenever it
+	// exceeds Hangul, including the lone-kana boundary below that minimum.
 	const koreanClaims = hangul >= kana && hangul >= LANGUAGE_EVIDENCE_MINIMUM;
 	const japaneseClaims = kana > hangul && kana >= LANGUAGE_EVIDENCE_MINIMUM;
 	if (hangul > 0 && hangul >= kana) addLanguageScore(scores, "ko", hangul);

package/src/slash-commands/aside-command.test.ts

@@ -0,0 +1,366 @@
+import { describe, expect, test } from "bun:test";
+import {
+	ASIDE_INSTALL_COMMAND,
+	ASIDE_USAGE,
+	asideCliCandidates,
+	createAsideHandler,
+	formatAsideMcpRegistration,
+	parseAsideArgv,
+	posixQuote,
+	probeAsideCli,
+	resolveAsideCliPath,
+	windowsPowerShellQuote,
+} from "./helpers/aside";
+
+function runtimeHarness() {
+	const output: string[] = [];
+	return {
+		runtime: {
+			session: {},
+			settings: {},
+			cwd: "/tmp",
+			output: async (message: string) => {
+				output.push(message);
+			},
+		} as never,
+		output,
+	};
+}
+
+describe("Aside CLI probe", () => {
+	test("lists installer symlink then the macOS app bundle", () => {
+		expect(asideCliCandidates("/Users/demo")).toEqual([
+			"/Users/demo/.local/bin/aside",
+			"/Users/demo/.aside/cli/Aside CLI.app/Contents/MacOS/aside",
+		]);
+	});
+
+	test("prefers the installer symlink over PATH", () => {
+		const path = resolveAsideCliPath("/Users/demo", {
+			isExecutable: filePath => filePath === "/Users/demo/.local/bin/aside",
+			which: () => "/opt/homebrew/bin/aside",
+		});
+		expect(path).toBe("/Users/demo/.local/bin/aside");
+	});
+
+	test("falls back to PATH when local candidates are missing", () => {
+		const probe = probeAsideCli("/Users/demo", {
+			isExecutable: filePath => filePath === "/opt/homebrew/bin/aside",
+			which: command => (command === "aside" ? "/opt/homebrew/bin/aside" : null),
+		});
+		expect(probe).toEqual({ ok: true, path: "/opt/homebrew/bin/aside" });
+	});
+
+	test("reports searched locations when nothing is executable", () => {
+		const probe = probeAsideCli("/Users/demo", {
+			isExecutable: () => false,
+			which: () => null,
+		});
+		expect(probe.ok).toBe(false);
+		if (probe.ok) throw new Error("expected a miss");
+		expect(probe.searched).toContain("/Users/demo/.local/bin/aside");
+		expect(probe.searched).toContain("PATH (aside)");
+		expect(probe.manualInstallCommand).toBe(ASIDE_INSTALL_COMMAND);
+	});
+});
+
+describe("posixQuote", () => {
+	test("quotes paths that contain spaces", () => {
+		expect(posixQuote("/Users/demo/.aside/cli/Aside CLI.app/Contents/MacOS/aside")).toBe(
+			"'/Users/demo/.aside/cli/Aside CLI.app/Contents/MacOS/aside'",
+		);
+	});
+
+	test("leaves simple paths unquoted", () => {
+		expect(posixQuote("/Users/demo/.local/bin/aside")).toBe("/Users/demo/.local/bin/aside");
+	});
+
+	test("quotes native Windows paths for PowerShell", () => {
+		expect(windowsPowerShellQuote("C:\\Users\\demo\\Aside CLI\\aside.exe")).toBe(
+			"'C:\\Users\\demo\\Aside CLI\\aside.exe'",
+		);
+		expect(windowsPowerShellQuote("C:\\Users\\O'Brien\\aside.exe")).toBe("'C:\\Users\\O''Brien\\aside.exe'");
+	});
+
+	test("selects PowerShell quoting for native Windows MCP commands", () => {
+		const cliPath = "C:\\Users\\demo\\Aside CLI\\aside.exe";
+		expect(formatAsideMcpRegistration(cliPath, "win32")).toContain(
+			`gjc mcp add aside ${windowsPowerShellQuote(cliPath)} mcp --project`,
+		);
+	});
+});
+
+describe("parseAsideArgv", () => {
+	test("preserves empty quoted arguments and escaped quotes", () => {
+		expect(parseAsideArgv('exec --message "" it\\\'s')).toEqual({
+			ok: true,
+			args: ["exec", "--message", "", "it's"],
+		});
+		expect(parseAsideArgv('exec "say \\"hello\\""')).toEqual({
+			ok: true,
+			args: ["exec", 'say "hello"'],
+		});
+	});
+
+	test("rejects unterminated quotes and escapes", () => {
+		expect(parseAsideArgv('exec "unterminated')).toEqual({ ok: false, error: "unterminated quote" });
+		expect(parseAsideArgv("exec trailing\\")).toEqual({ ok: false, error: "unfinished escape" });
+	});
+});
+
+describe("/aside slash command", () => {
+	test("prints usage for help verbs without probing", async () => {
+		const handle = createAsideHandler({
+			homedir: () => "/missing",
+			isExecutable: () => false,
+			which: () => null,
+			exec: async () => {
+				throw new Error("exec should not run for /aside help");
+			},
+		});
+		const { runtime, output } = runtimeHarness();
+		expect(await handle({ name: "aside", args: "help", text: "/aside help" }, runtime)).toEqual({ consumed: true });
+		expect(output).toEqual([ASIDE_USAGE]);
+	});
+
+	test("guides installation when the CLI is missing", async () => {
+		const handle = createAsideHandler({
+			homedir: () => "/Users/demo",
+			isExecutable: () => false,
+			which: () => null,
+			exec: async () => {
+				throw new Error("exec should not run when CLI is missing");
+			},
+		});
+		const { runtime, output } = runtimeHarness();
+		expect(await handle({ name: "aside", args: "", text: "/aside" }, runtime)).toEqual({ consumed: true });
+		expect(output[0]).toContain("Aside CLI was not found.");
+		expect(output[0]).toContain(ASIDE_INSTALL_COMMAND);
+		expect(output[0]).toContain(ASIDE_USAGE);
+	});
+
+	test("status prints the resolved path and version", async () => {
+		const execCalls: string[][] = [];
+		const handle = createAsideHandler({
+			homedir: () => "/Users/demo",
+			isExecutable: filePath => filePath === "/Users/demo/.local/bin/aside",
+			which: () => null,
+			exec: async (_command, args) => {
+				execCalls.push(args);
+				return { stdout: "1.26.810\n", stderr: "", code: 0, killed: false };
+			},
+		});
+		const { runtime, output } = runtimeHarness();
+		expect(await handle({ name: "aside", args: "", text: "/aside" }, runtime)).toEqual({ consumed: true });
+		expect(execCalls).toEqual([["--version"]]);
+		expect(output[0]).toContain("Aside CLI: /Users/demo/.local/bin/aside");
+		expect(output[0]).toContain("Version: 1.26.810");
+		expect(output[0]).toContain(ASIDE_USAGE);
+	});
+
+	test("sanitizes version output before rendering status", async () => {
+		const handle = createAsideHandler({
+			homedir: () => "/Users/demo",
+			isExecutable: filePath => filePath === "/Users/demo/.local/bin/aside",
+			which: () => null,
+			exec: async () => ({ stdout: "\x1b]0;pwned\x071.26.810\n", stderr: "", code: 0, killed: false }),
+		});
+		const { runtime, output } = runtimeHarness();
+		await handle({ name: "aside", args: "", text: "/aside" }, runtime);
+		expect(output[0]).toContain("Version: 1.26.810");
+		expect(output[0]).not.toContain("pwned");
+	});
+
+	test("freeform prompts run aside exec with a single prompt argument", async () => {
+		const execCalls: Array<{ command: string; args: string[] }> = [];
+		const handle = createAsideHandler({
+			homedir: () => "/Users/demo",
+			isExecutable: filePath => filePath === "/Users/demo/.local/bin/aside",
+			which: () => null,
+			exec: async (command, args) => {
+				execCalls.push({ command, args });
+				return { stdout: "ok", stderr: "", code: 0, killed: false };
+			},
+		});
+		const { runtime, output } = runtimeHarness();
+		expect(
+			await handle(
+				{ name: "aside", args: "Summarize the current page", text: "/aside Summarize the current page" },
+				runtime,
+			),
+		).toEqual({ consumed: true });
+		expect(execCalls).toEqual([
+			{ command: "/Users/demo/.local/bin/aside", args: ["exec", "Summarize the current page"] },
+		]);
+		expect(output).toEqual(["ok"]);
+	});
+
+	test("exec passes quoted argv through without a shell", async () => {
+		const execCalls: string[][] = [];
+		const handle = createAsideHandler({
+			homedir: () => "/Users/demo",
+			isExecutable: filePath => filePath === "/Users/demo/.local/bin/aside",
+			which: () => null,
+			exec: async (_command, args) => {
+				execCalls.push(args);
+				return { stdout: "", stderr: "", code: 0, killed: false };
+			},
+		});
+		const { runtime, output } = runtimeHarness();
+		expect(
+			await handle(
+				{
+					name: "aside",
+					args: 'exec --session abc "Continue later"',
+					text: '/aside exec --session abc "Continue later"',
+				},
+				runtime,
+			),
+		).toEqual({ consumed: true });
+		expect(execCalls).toEqual([["exec", "--session", "abc", "Continue later"]]);
+		expect(output).toEqual(["Aside CLI exited 0 with no output."]);
+	});
+
+	test("leading flags are forwarded to aside exec", async () => {
+		const execCalls: string[][] = [];
+		const handle = createAsideHandler({
+			homedir: () => "/Users/demo",
+			isExecutable: filePath => filePath === "/Users/demo/.local/bin/aside",
+			which: () => null,
+			exec: async (_command, args) => {
+				execCalls.push(args);
+				return { stdout: "continued", stderr: "", code: 0, killed: false };
+			},
+		});
+		const { runtime } = runtimeHarness();
+		await handle({ name: "aside", args: "--session abc Continue", text: "/aside --session abc Continue" }, runtime);
+		expect(execCalls).toEqual([["exec", "--session", "abc", "Continue"]]);
+	});
+
+	test("mcp prints a quoted registration command and does not spawn stdio", async () => {
+		const handle = createAsideHandler({
+			homedir: () => "/Users/demo",
+			isExecutable: filePath => filePath.includes("Aside CLI.app"),
+			which: () => null,
+			exec: async () => {
+				throw new Error("mcp must not spawn aside mcp");
+			},
+		});
+		const { runtime, output } = runtimeHarness();
+		const cliPath = "/Users/demo/.aside/cli/Aside CLI.app/Contents/MacOS/aside";
+		expect(await handle({ name: "aside", args: "mcp", text: "/aside mcp" }, runtime)).toEqual({ consumed: true });
+		expect(output).toEqual([formatAsideMcpRegistration(cliPath)]);
+		expect(output[0]).toContain(`gjc mcp add aside ${posixQuote(cliPath)} mcp --project`);
+		expect(output[0]).not.toContain("aside mcp\n");
+	});
+
+	test("rejects unexpected MCP arguments without probing or spawning", async () => {
+		const handle = createAsideHandler({
+			homedir: () => "/missing",
+			isExecutable: () => false,
+			which: () => null,
+			exec: async () => {
+				throw new Error("mcp must not spawn");
+			},
+		});
+		const { runtime, output } = runtimeHarness();
+		expect(await handle({ name: "aside", args: "mcp unexpected", text: "/aside mcp unexpected" }, runtime)).toEqual({
+			consumed: true,
+		});
+		expect(output).toEqual(["Usage: /aside mcp"]);
+	});
+
+	test("repl refuses to run inside GJC", async () => {
+		const handle = createAsideHandler({
+			homedir: () => "/Users/demo",
+			isExecutable: filePath => filePath === "/Users/demo/.local/bin/aside",
+			which: () => null,
+			exec: async () => {
+				throw new Error("repl must not spawn");
+			},
+		});
+		const { runtime, output } = runtimeHarness();
+		expect(await handle({ name: "aside", args: "repl", text: "/aside repl" }, runtime)).toEqual({ consumed: true });
+		expect(output[0]).toContain("needs a real terminal TTY");
+		expect(output[0]).toContain("/Users/demo/.local/bin/aside repl");
+	});
+
+	test("rejects unexpected REPL arguments without probing or spawning", async () => {
+		const handle = createAsideHandler({
+			homedir: () => "/missing",
+			isExecutable: () => false,
+			which: () => null,
+			exec: async () => {
+				throw new Error("repl must not spawn");
+			},
+		});
+		const { runtime, output } = runtimeHarness();
+		expect(await handle({ name: "aside", args: "repl unexpected", text: "/aside repl unexpected" }, runtime)).toEqual(
+			{
+				consumed: true,
+			},
+		);
+		expect(output).toEqual(["Usage: /aside repl"]);
+	});
+
+	test("account forwards subcommands", async () => {
+		const execCalls: string[][] = [];
+		const handle = createAsideHandler({
+			homedir: () => "/Users/demo",
+			isExecutable: filePath => filePath === "/Users/demo/.local/bin/aside",
+			which: () => null,
+			exec: async (_command, args) => {
+				execCalls.push(args);
+				return { stdout: "u0", stderr: "", code: 0, killed: false };
+			},
+		});
+		const { runtime, output } = runtimeHarness();
+		expect(await handle({ name: "aside", args: "account list", text: "/aside account list" }, runtime)).toEqual({
+			consumed: true,
+		});
+		expect(execCalls).toEqual([["account", "list"]]);
+		expect(output).toEqual(["u0"]);
+	});
+
+	test("nonzero CLI exit is consumed with a non-zero status", async () => {
+		const handle = createAsideHandler({
+			homedir: () => "/Users/demo",
+			isExecutable: filePath => filePath === "/Users/demo/.local/bin/aside",
+			which: () => null,
+			exec: async () => ({ stdout: "no daemon", stderr: "", code: 1, killed: false }),
+		});
+		const { runtime, output } = runtimeHarness();
+		expect(await handle({ name: "aside", args: "account status", text: "/aside account status" }, runtime)).toEqual({
+			consumed: true,
+			exitCode: 1,
+		});
+		expect(output).toEqual(["no daemon\n(exit 1)"]);
+	});
+
+	test("timeout results are consumed with a non-zero status", async () => {
+		const handle = createAsideHandler({
+			homedir: () => "/Users/demo",
+			isExecutable: filePath => filePath === "/Users/demo/.local/bin/aside",
+			which: () => null,
+			exec: async () => ({ stdout: "partial", stderr: "", code: 0, killed: true }),
+		});
+		const { runtime, output } = runtimeHarness();
+		expect(await handle({ name: "aside", args: "exec Continue", text: "/aside exec Continue" }, runtime)).toEqual({
+			consumed: true,
+			exitCode: 1,
+		});
+		expect(output).toEqual(["partial\nAside CLI timed out or was cancelled."]);
+	});
+
+	test("sanitizes CLI control sequences before rendering output", async () => {
+		const handle = createAsideHandler({
+			homedir: () => "/Users/demo",
+			isExecutable: filePath => filePath === "/Users/demo/.local/bin/aside",
+			which: () => null,
+			exec: async () => ({ stdout: "\x1b]0;pwned\x07safe", stderr: "", code: 0, killed: false }),
+		});
+		const { runtime, output } = runtimeHarness();
+		await handle({ name: "aside", args: "account status", text: "/aside account status" }, runtime);
+		expect(output).toEqual(["safe"]);
+	});
+});

package/src/slash-commands/builtin-registry.ts

@@ -45,6 +45,7 @@ import {
 } from "../setup/provider-onboarding";
 import { parseThinkingLevel } from "../thinking";
 import { getDisplayChangelogEntries } from "../utils/changelog";
+import { handleAsideAcp } from "./helpers/aside";
 import { buildAutoroutingStatusReport } from "./helpers/autorouting-status";
 import { buildContextReportText } from "./helpers/context-report";
 import { switchSessionCredentialCommand } from "./helpers/credential-switch";
@@ -609,6 +610,24 @@ const shutdownHandlerTui = (_command: ParsedSlashCommand, runtime: TuiSlashComma
 const IMPORT_SESSION_RETAINED_DESCRIPTOR_AUTHORITY_AVAILABLE = process.platform === "linux";
 
 const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
+	{
+		name: "aside",
+		priority: 32,
+		description: "Run the Aside CLI from the composer",
+		acpDescription: "Run the Aside CLI",
+		subcommands: [
+			{ name: "exec", description: "Run Aside with a prompt", usage: "[args] <prompt>" },
+			{ name: "repl", description: "Aside REPL is terminal-only; prints the outside command" },
+			{ name: "mcp", description: "Print MCP registration using the resolved CLI path" },
+			{ name: "account", description: "Inspect or select Aside CLI accounts", usage: "[list|status|use]" },
+			{ name: "help", description: "Show /aside usage" },
+		],
+		inlineHint: "[exec|repl|mcp|account|help|<prompt>]",
+		acpInputHint: "[exec|repl|mcp|account|help|<prompt>]",
+		allowArgs: true,
+		localHeadless: true,
+		handle: handleAsideAcp,
+	},
 	{
 		name: "import-session",
 		priority: 29,