@gajae-code/coding-agent 0.15.4 → 0.15.5

package/src/modes/prompt-action-autocomplete.ts

@@ -1,9 +1,12 @@
 import {
 	type AutocompleteItem,
 	type AutocompleteProvider,
+	autocompleteFuzzyMatch,
+	autocompleteFuzzyScore,
 	CombinedAutocompleteProvider,
 	extractSlashCommandTokenPrefix,
 	getSlashCommandMatchRank,
+	normalizeFuzzyText,
 	type SlashCommand,
 } from "@gajae-code/tui";
 import type { KeybindingsManager } from "../config/keybindings";
@@ -50,43 +53,6 @@ interface PromptActionAutocompleteOptions {
 	getPromptSuggestion?: () => string | null;
 }
 
-function fuzzyMatch(query: string, target: string): boolean {
-	if (query.length === 0) return true;
-	if (query.length > target.length) return false;
-
-	let queryIndex = 0;
-	for (let targetIndex = 0; targetIndex < target.length && queryIndex < query.length; targetIndex += 1) {
-		if (query[queryIndex] === target[targetIndex]) {
-			queryIndex += 1;
-		}
-	}
-
-	return queryIndex === query.length;
-}
-
-function fuzzyScore(query: string, target: string): number {
-	if (query.length === 0) return 1;
-	if (target === query) return 100;
-	if (target.startsWith(query)) return 80;
-	if (target.includes(query)) return 60;
-
-	let queryIndex = 0;
-	let gaps = 0;
-	let lastMatchIndex = -1;
-	for (let targetIndex = 0; targetIndex < target.length && queryIndex < query.length; targetIndex += 1) {
-		if (query[queryIndex] === target[targetIndex]) {
-			if (lastMatchIndex >= 0 && targetIndex - lastMatchIndex > 1) {
-				gaps += 1;
-			}
-			lastMatchIndex = targetIndex;
-			queryIndex += 1;
-		}
-	}
-
-	if (queryIndex !== query.length) return 0;
-	return Math.max(1, 40 - gaps * 5);
-}
-
 function isPromptActionItem(item: AutocompleteItem): item is PromptActionAutocompleteItem {
 	return "actionId" in item && "execute" in item && typeof item.execute === "function";
 }
@@ -127,6 +93,7 @@ function sortSlashCommandSuggestions(
 ): { items: AutocompleteItem[]; prefix: string } | null {
 	if (!suggestions) return null;
 	const query = suggestions.prefix.slice(1).toLowerCase();
+	const normalizedQuery = normalizeFuzzyText(query);
 	const commandIndexes = new Map(commands.map((command, index) => [command.name, index]));
 	const commandByName = new Map(commands.map(command => [command.name, command]));
 	const items = suggestions.items
@@ -135,13 +102,20 @@ function sortSlashCommandSuggestions(
 			const commandIndex = commandIndexes.get(item.value) ?? index;
 			const lowerName = item.value.toLowerCase();
 			const lowerDesc = command?.description?.toLowerCase() ?? item.description?.toLowerCase() ?? "";
-			const nameScore = fuzzyMatch(query, lowerName) ? fuzzyScore(query, lowerName) : 0;
-			const descScore = fuzzyMatch(query, lowerDesc) ? fuzzyScore(query, lowerDesc) * 0.5 : 0;
+			const normalizedName = normalizeFuzzyText(item.value);
+			const normalizedDesc = normalizeFuzzyText(lowerDesc);
+			const nameScore = autocompleteFuzzyMatch(normalizedQuery, normalizedName)
+				? autocompleteFuzzyScore(normalizedQuery, normalizedName)
+				: 0;
+			const descScore = autocompleteFuzzyMatch(normalizedQuery, normalizedDesc)
+				? autocompleteFuzzyScore(normalizedQuery, normalizedDesc) * 0.5
+				: 0;
+			const isAscii = /^[\x00-\x7F]*$/.test(`${query}${item.value}`);
 			return {
 				item,
 				index,
 				commandIndex,
-				matchRank: getSlashCommandMatchRank(query, lowerName),
+				matchRank: isAscii ? getSlashCommandMatchRank(query, lowerName) : 4,
 				priority: getSlashCommandPriority(command, item),
 				score: Math.max(nameScore, descScore),
 			};
@@ -219,14 +193,14 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 					const searchable = [action.id, action.label, action.description, ...action.keywords]
 						.join(" ")
 						.toLowerCase();
-					if (!fuzzyMatch(query, searchable)) return null;
+					if (!autocompleteFuzzyMatch(query, searchable)) return null;
 					return {
 						value: action.label,
 						label: action.label,
 						description: action.description,
 						actionId: action.id,
 						execute: action.execute,
-						score: fuzzyScore(query, searchable),
+						score: autocompleteFuzzyScore(query, searchable),
 					} satisfies PromptActionAutocompleteItem & { score: number };
 				})
 				.filter(item => item !== null)
@@ -350,7 +324,10 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 		if (!prefix) return null;
 		const query = prefix.slice(1).toLowerCase();
 		if (query.length === 0 && !options.includeEmpty) return null;
-		const normalizedQuery = query.startsWith("skill-") ? `skill:${query.slice("skill-".length)}` : query;
+		const normalizedQuery = normalizeFuzzyText(
+			query.startsWith("skill-") ? `skill:${query.slice("skill-".length)}` : query,
+		);
+		if (query.length > 0 && normalizedQuery.length === 0) return null;
 		const exactNonSkillCommand = this.#commands.some(
 			command => command.name === query && !command.name.startsWith("skill:"),
 		);
@@ -364,16 +341,18 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 					`skill-${skillName}`,
 					...(exactNonSkillCommand ? [] : [skillName]),
 					command.description ?? "",
-				].map(target => target.toLowerCase());
+				].map(target => normalizeFuzzyText(target));
 				if (
-					!searchTargets.some(target => fuzzyMatch(normalizedQuery, target) || target.includes(normalizedQuery))
+					!searchTargets.some(
+						target => autocompleteFuzzyMatch(normalizedQuery, target) || target.includes(normalizedQuery),
+					)
 				) {
 					return null;
 				}
 				const bestScore = Math.max(
 					...searchTargets.map(target =>
-						fuzzyMatch(normalizedQuery, target)
-							? fuzzyScore(normalizedQuery, target)
+						autocompleteFuzzyMatch(normalizedQuery, target)
+							? autocompleteFuzzyScore(normalizedQuery, target)
 							: target.includes(normalizedQuery)
 								? 60
 								: 0,

package/src/sdk/bus/chat-daemon-control.ts

@@ -132,8 +132,8 @@ export type ChatDaemonAction = "stop" | "reload";
  * would retain the old hot polling loop, so replacement is required.
  */
 export const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>> = {
-	discord: 69,
-	slack: 72,
+	discord: 70,
+	slack: 73,
 };
 
 export function chatDaemonGeneration(kind: ChatDaemonKind): number {

package/src/sdk/bus/kind-aware-reconciliation.ts

@@ -355,7 +355,13 @@ export function createKindAwareReconciliation(
 				// as-is (cleanupRecords is intentionally not re-run). First reason wins: a
 				// late generic frame never overwrites a specific one. Persisted so the reason
 				// survives reconnect/restart reconciliation.
-				if (frame.type === "agent_failed" && record.error === undefined) {
+				if (frame.type === "agent_failed") {
+					const failure = sanitizePromptFailure(frame.error);
+					if (
+						record.error !== undefined &&
+						!(record.error.code === "agent_failed" && failure.code !== "agent_failed")
+					)
+						return { value: undefined, changed: false };
 					record.error = sanitizePromptFailure(frame.error);
 					return { value: undefined, changed: true };
 				}
@@ -373,7 +379,9 @@ export function createKindAwareReconciliation(
 			if (frame.type === "agent_failed") {
 				// agent_failed is additive diagnostics; agent_end remains the sole
 				// terminal lifecycle boundary for the correlated invocation.
-				record.error ??= sanitizePromptFailure(frame.error);
+				const failure = sanitizePromptFailure(frame.error);
+				if (record.error === undefined || (record.error.code === "agent_failed" && failure.code !== "agent_failed"))
+					record.error = failure;
 				delete record.deadlineRecoveryPending;
 				delete record.deadlineMaxAt;
 				return { value: undefined, changed: true };

package/src/sdk/bus/prompt-reconciliation.ts

@@ -202,8 +202,11 @@ export function createPromptReconciliation(options: { now?: () => number } = {})
 			// the settled record instead of being dropped; it must not resurrect it,
 			// so status, terminalAt, retention order, and clientRefIndex stay as-is.
 			// First reason wins: a late generic frame never overwrites a specific one.
-			if (frame.type === "agent_failed" && record.error === undefined)
-				record.error = sanitizePromptFailure(frame.error);
+			if (frame.type === "agent_failed") {
+				const failure = sanitizePromptFailure(frame.error);
+				if (record.error === undefined || (record.error.code === "agent_failed" && failure.code !== "agent_failed"))
+					record.error = failure;
+			}
 			return;
 		}
 		if (frame.type === "agent_start") {

package/src/sdk/bus/telegram-daemon-contract.ts

@@ -283,8 +283,15 @@ export const SDK_LIFECYCLE_ROUTER_PROTOCOL_VERSION = 1;
  * Generation 177 consumes an exact same-window lean settlement receipt only
  * after its autonomous ask lead-in publishes successfully, preventing idle
  * replay without changing the serving protocol.
+ * Generation 178: idle publication waits for positioned identity delivery to
+ * cross the native writer barrier before the independent broadcast lane.
+ * Generation 179 tolerates a bounded consecutive run of refused notification
+ * publications in the router instead of cancelling the subscription on the
+ * first refusal, so an owner still running the generation-178 router keeps
+ * killing a session's mirroring after one transient rejection and must be
+ * replaced across this upgrade.
  */
-export const DAEMON_GENERATION = 178;
+export const DAEMON_GENERATION = 179;
 
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 7

package/src/sdk/cli/session-cli.ts

@@ -1,7 +1,9 @@
 import { randomBytes } from "node:crypto";
 import * as fsSync from "node:fs";
 import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { getAgentDir } from "@gajae-code/utils";
+import { repo as resolveGitRepository } from "../../utils/git";
 import { ensureBroker } from "../broker/ensure";
 import { lifecycleRequestTimeoutMs } from "../broker/startup-budget";
 import { SdkClientError } from "../client";
@@ -38,10 +40,12 @@ export type SdkSessionCliAction =
 	| "status"
 	| "tail"
 	| "retire"
+	| "global"
 	| "raw"
 	| "control"
 	| "query"
 	| "global";
+export type SdkSessionListScope = "repo" | "cwd" | "worktree" | "all";
 export type SdkSessionCliRawKind = "control" | "query" | "global";
 
 export interface SdkSessionCliArgs {
@@ -56,6 +60,7 @@ export interface SdkSessionCliArgs {
 	jsonInputFile?: string;
 	jsonInputStdin?: boolean;
 	idempotencyKey?: string;
+	scope?: string;
 	confirm?: boolean;
 	cursor?: string;
 	wait?: boolean;
@@ -358,16 +363,156 @@ async function sessionRows(agentDir: string): Promise<SessionRows> {
 	});
 }
 
-async function runList(agentDir: string): Promise<unknown> {
+const SESSION_LIST_SCOPES: readonly SdkSessionListScope[] = ["repo", "cwd", "worktree", "all"];
+/** Row workspaces whose locator cannot be canonicalized still get one deterministic identity. */
+const WORKSPACE_IDENTITY_CACHE_LIMIT = 4096;
+
+interface WorkspaceIdentity {
+	/** Canonical workspace path (realpath when it exists, lexical resolve otherwise). */
+	canonicalPath: string;
+	/** Canonical containing worktree root; null outside a Git checkout. */
+	repoRoot: string | null;
+	/** Canonical Git common dir; shared by the main checkout and linked worktrees. */
+	commonDir: string | null;
+}
+
+export interface SdkSessionListSelection {
+	scope: SdkSessionListScope;
+	selection: WorkspaceIdentity;
+	/** Bounded, credential-free descriptor included in list output. */
+	descriptor: {
+		scope: SdkSessionListScope;
+		path: string;
+		worktreeRoot?: string;
+		commonDir?: string;
+	};
+}
+
+/** Parses `--scope`; missing means `repo`, anything else invalid is a usage error. */
+export function parseSessionListScope(value: string | undefined): SdkSessionListScope {
+	if (value === undefined) return "repo";
+	if ((SESSION_LIST_SCOPES as readonly string[]).includes(value)) return value as SdkSessionListScope;
+	throw new SdkSessionCliError(
+		"usage",
+		`Invalid scope "${value}". Expected one of: ${SESSION_LIST_SCOPES.join(", ")}.`,
+		2,
+	);
+}
+
+async function canonicalWorkspacePath(target: string): Promise<string> {
+	try {
+		return await fs.realpath(target);
+	} catch {
+		// A removed or unreadable workspace keeps a deterministic lexical identity
+		// instead of guessing a broader or narrower one.
+		return path.resolve(target);
+	}
+}
+
+const workspaceIdentityCache = new Map<string, WorkspaceIdentity>();
+
+/** Resolves (and caches) the Git identity of one workspace locator. */
+async function workspaceIdentity(target: string): Promise<WorkspaceIdentity> {
+	const canonicalPath = await canonicalWorkspacePath(target);
+	const cached = workspaceIdentityCache.get(canonicalPath);
+	if (cached) return cached;
+	if (target === "unknown") {
+		const unavailable = { canonicalPath, repoRoot: null, commonDir: null };
+		workspaceIdentityCache.set(canonicalPath, unavailable);
+		return unavailable;
+	}
+	try {
+		if (!(await fs.stat(target)).isDirectory()) throw new Error("workspace is not a directory");
+	} catch {
+		// A removed or unreadable locator cannot prove Git membership. Keeping it
+		// outside every identity is the narrowest safe result for row filtering.
+		const unavailable = { canonicalPath, repoRoot: null, commonDir: null };
+		workspaceIdentityCache.set(canonicalPath, unavailable);
+		return unavailable;
+	}
+	const repository = await resolveGitRepository.resolve(canonicalPath);
+	const identity: WorkspaceIdentity = repository
+		? {
+				canonicalPath,
+				repoRoot: await canonicalWorkspacePath(repository.repoRoot),
+				commonDir: await canonicalWorkspacePath(repository.commonDir),
+			}
+		: { canonicalPath, repoRoot: null, commonDir: null };
+	if (workspaceIdentityCache.size >= WORKSPACE_IDENTITY_CACHE_LIMIT) workspaceIdentityCache.clear();
+	workspaceIdentityCache.set(canonicalPath, identity);
+	return identity;
+}
+
+/**
+ * Resolves the list selection from `--repo` (default: process cwd) under the
+ * effective scope. Outside Git, `repo`/`worktree` fail typed and actionable —
+ * they never broaden to `all`; `cwd` remains an exact canonical match.
+ */
+export async function resolveSessionListSelection(
+	scope: SdkSessionListScope,
+	repoArg: string | undefined,
+): Promise<SdkSessionListSelection> {
+	const selection = await workspaceIdentity(repoArg ?? process.cwd());
+	if (scope !== "cwd" && !selection.repoRoot)
+		throw new SdkSessionCliError(
+			"not_a_repository",
+			`--scope ${scope} requires a Git repository, but "${selection.canonicalPath}" is outside any Git checkout. ` +
+				"Use --scope cwd for an exact workspace match or --scope all for the full broker listing.",
+			1,
+		);
+	const descriptor: SdkSessionListSelection["descriptor"] = {
+		scope,
+		path: selection.canonicalPath,
+		...(selection.repoRoot ? { worktreeRoot: selection.repoRoot, commonDir: selection.commonDir! } : {}),
+	};
+	return { scope, selection, descriptor };
+}
+
+/**
+ * Filters fully traversed broker rows by the selection scope. Row workspaces
+ * are canonicalized and cached per distinct locator; `repo` matches the shared
+ * common dir across the main checkout and linked worktrees, `worktree` the
+ * containing worktree only, and `cwd` the exact canonical workspace.
+ */
+export async function filterSessionRowsByScope(
+	rows: readonly SdkSessionRowV1[],
+	scope: SdkSessionListScope,
+	selection: SdkSessionListSelection,
+): Promise<{ sessions: SdkSessionRowV1[]; warnings: string[] }> {
+	if (scope === "all") return { sessions: [...rows], warnings: [] };
+	const warnings: string[] = [];
+	const sessions: SdkSessionRowV1[] = [];
+	for (const row of rows) {
+		const identity = await workspaceIdentity(row.locator.repo);
+		let keep: boolean;
+		if (scope === "cwd") keep = identity.canonicalPath === selection.selection.canonicalPath;
+		else if (scope === "worktree")
+			keep = identity.repoRoot !== null && identity.repoRoot === selection.selection.repoRoot;
+		else keep = identity.commonDir !== null && identity.commonDir === selection.selection.commonDir;
+		if (keep) sessions.push(row);
+		else if (identity.repoRoot === null && identity.commonDir === null)
+			warnings.push(
+				`Session ${row.sessionId} workspace "${row.locator.repo}" is outside Git; excluded by scope ${scope}.`,
+			);
+	}
+	return { sessions, warnings };
+}
+
+async function runList(agentDir: string, args: SdkSessionCliArgs): Promise<unknown> {
+	const scope = parseSessionListScope(args.scope);
+	const { selection, descriptor } = await resolveSessionListSelection(scope, args.repo);
 	const listing = await sessionRows(agentDir);
+	const filtered = await filterSessionRowsByScope(listing.sessions, scope, { scope, selection, descriptor });
 	return {
 		ok: true,
 		result: {
 			version: SESSION_ROWS_VERSION,
 			source: "broker",
+			scope,
+			selection: descriptor,
 			...(listing.indexSeq === undefined ? {} : { indexSeq: listing.indexSeq }),
-			sessions: listing.sessions,
-			warnings: listing.warnings,
+			sessions: filtered.sessions,
+			warnings: [...listing.warnings, ...filtered.warnings],
 		},
 	};
 }
@@ -1367,7 +1512,7 @@ export async function runSdkSessionCli(
 			);
 		const agentDir = args.agentDir ?? getAgentDir();
 		if (action === "list") {
-			writeOutput(stripSecretFields(await runList(agentDir)));
+			writeOutput(stripSecretFields(await runList(agentDir, args)));
 			return;
 		}
 		if (action === "inspect") {

package/src/sdk/host/host.ts

@@ -49,6 +49,8 @@ export interface SessionSdkHostOptions extends HostEndpointAdapters {
 	query?: (connectionId: string, frame: SdkFrame) => unknown | Promise<unknown>;
 	/** Test/lifecycle seam invoked synchronously before fire-and-forget dispatch. */
 	onFrameAdmitted?: (connectionId: string, frame: SdkFrame) => void;
+	/** Synchronously rejects external input while a runtime is being replaced. */
+	onFrameAdmission?: (connectionId: string, frame: SdkFrame) => SdkFrame | undefined;
 	/** Best-effort diagnostic observation of accepted control/query frames. */
 	onRequest?: SdkRequestObserver;
 	/** Runs before a control response is sent; identity transitions use sendTerminal. */
@@ -408,6 +410,11 @@ export class SessionSdkHost {
 
 	async #onFrame(connectionId: string, frame: SdkFrame): Promise<void> {
 		try {
+			const admissionRejection = this.#options.onFrameAdmission?.(connectionId, frame);
+			if (admissionRejection !== undefined) {
+				await this.#send(connectionId, admissionRejection);
+				return;
+			}
 			switch (frame.type) {
 				case "control_request": {
 					this.#observeRequest("control", connectionId, frame);