@gajae-code/coding-agent 0.4.2 → 0.4.3

package/src/tools/monitor.ts

@@ -47,6 +47,7 @@ export interface MonitorToolDetails {
 }
 
 const MONITOR_LABEL_MAX = 120;
+const MAX_PENDING_MONITOR_NOTIFICATIONS = 3;
 
 function buildMonitorLabel(params: MonitorParams): string {
 	const base = `[monitor:${params.kind}] ${params.description}`;
@@ -89,36 +90,116 @@ export class MonitorTool implements AgentTool<typeof monitorSchema, MonitorToolD
 		const ownerId = this.session.getAgentId?.() ?? undefined;
 		const bash = new BashTool(this.session);
 		let deliveredFirstLine = false;
+		const controller = { closed: false };
+		let currentJobId = "";
+		let sequence = 0;
+		let latestLine: string | undefined;
+		let coalescedCount = 0;
+		let flushScheduled = false;
+		// Count of notification *sends* (not live queue depth): once it exceeds the
+		// cap, each new send first purges older queued notifications for this task,
+		// keeping the queue bounded and latest-biased.
+		let pendingNotifications = 0;
+		const isMonitorMessage = (message: { customType?: string; details?: unknown }) =>
+			message.customType === "task-notification" &&
+			(message.details as { taskId?: string } | undefined)?.taskId === currentJobId;
+		const flushLatest = () => {
+			if (!persistent || latestLine === undefined) return;
+			const line = latestLine;
+			const count = coalescedCount;
+			latestLine = undefined;
+			coalescedCount = 0;
+			flushScheduled = false;
+			sendNotification(line, currentJobId, count);
+		};
+		const closeMonitor = (mode: "purge" | "flush") => {
+			// "flush" (natural process exit): deliver the newest pending line so the
+			// final state is never lost, then stop. "purge" (explicit cancel / registry
+			// eviction): drop the queued backlog. Non-persistent monitors keep their one
+			// notification, so they never purge.
+			if (mode === "flush") {
+				flushLatest();
+				controller.closed = true;
+				return;
+			}
+			controller.closed = true;
+			if (!persistent) return;
+			return this.session.purgeQueuedCustomMessages?.(isMonitorMessage);
+		};
+		const sendNotification = (line: string, jobId: string, count: number) => {
+			if (controller.closed) return;
+			const notificationId = `${jobId}:${sequence}`;
+			const suffix = count > 0 ? `\n(+${count} earlier lines)` : "";
+			const content = `<task-notification>\nMonitor task ${jobId} (${params.kind}: ${params.description}) emitted latest state:\n${line}${suffix}\n</task-notification>`;
+			const details = {
+				taskId: jobId,
+				kind: params.kind,
+				description: params.description,
+				monitor: true,
+				notificationId,
+				sequence,
+				coalescedCount: count,
+			};
+			pendingNotifications += 1;
+			if (pendingNotifications > MAX_PENDING_MONITOR_NOTIFICATIONS) {
+				this.session.purgeQueuedCustomMessages?.(
+					m =>
+						m.customType === "task-notification" &&
+						(m.details as { taskId?: string; notificationId?: string } | undefined)?.taskId === jobId &&
+						(m.details as { notificationId?: string } | undefined)?.notificationId !== notificationId,
+				);
+				pendingNotifications = MAX_PENDING_MONITOR_NOTIFICATIONS;
+			}
+			const sendPromise = this.session.sendCustomMessage?.(
+				{ customType: "task-notification", content, display: false, attribution: "agent", details },
+				{ triggerTurn: true, deliverAs: "followUp" },
+			);
+			if (sendPromise) {
+				void sendPromise.catch(error => {
+					logger.warn("Monitor task-notification delivery failed", {
+						error: error instanceof Error ? error.message : String(error),
+					});
+				});
+			} else {
+				this.session.steer?.({ customType: "task-notification", content, details });
+			}
+		};
+		const schedulePersistentNotification = (line: string) => {
+			latestLine = line;
+			sequence += 1;
+			coalescedCount += flushScheduled ? 1 : 0;
+			if (flushScheduled) return;
+			flushScheduled = true;
+			queueMicrotask(flushLatest);
+		};
 		const monitorJob = await bash.startMonitorJob(
 			{ command: params.command, timeout: params.timeout },
 			{
 				ownerId,
 				label,
 				ctx: context,
+				shouldAcceptRawLine: () => !controller.closed,
+				lifecycle: {
+					onCancel: () => closeMonitor("purge"),
+					onTerminal: () => closeMonitor("flush"),
+					onEvict: () => closeMonitor("purge"),
+					onTombstonePurge: () => closeMonitor("purge"),
+				},
 				onRawLine: (line, jobId) => {
+					if (controller.closed) return;
+					currentJobId = jobId;
 					if (!persistent && deliveredFirstLine) return;
 					deliveredFirstLine = true;
-					const content = `<task-notification>\nMonitor task ${jobId} (${params.kind}: ${params.description}) emitted:\n${line}\n</task-notification>`;
-					const details = { taskId: jobId, kind: params.kind, description: params.description };
-					const sendPromise = this.session.sendCustomMessage?.(
-						{ customType: "task-notification", content, display: false, attribution: "agent", details },
-						{ triggerTurn: true, deliverAs: "followUp" },
-					);
-					if (sendPromise) {
-						void sendPromise.catch(error => {
-							logger.warn("Monitor task-notification delivery failed", {
-								error: error instanceof Error ? error.message : String(error),
-							});
-						});
-					} else {
-						this.session.steer?.({ customType: "task-notification", content, details });
-					}
-					if (!persistent) {
-						manager.cancel(jobId, ownerId ? { ownerId } : undefined);
+					if (persistent) {
+						schedulePersistentNotification(line);
+						return;
 					}
+					sendNotification(line, jobId, 0);
+					manager.cancel(jobId, ownerId ? { ownerId } : undefined);
 				},
 			},
 		);
+		currentJobId = monitorJob.jobId;
 
 		const startedText = `Monitor started · task ${monitorJob.jobId} · persistent: ${persistent}`;
 

package/src/utils/commit-message-generator.ts

@@ -1,5 +1,5 @@
 /**
- * Generate commit messages from diffs using a smol, fast model.
+ * Generate commit messages from diffs using the default model.
  * Follows the same pattern as title-generator.ts.
  */
 import type { ThinkingLevel } from "@gajae-code/agent-core";
@@ -9,7 +9,6 @@ import { logger, prompt } from "@gajae-code/utils";
 import type { ModelRegistry } from "../config/model-registry";
 import { resolveModelRoleValue } from "../config/model-resolver";
 import type { Settings } from "../config/settings";
-import MODEL_PRIO from "../priority.json" with { type: "json" };
 import commitSystemPrompt from "../prompts/system/commit-message-system.md" with { type: "text" };
 import { toReasoningEffort } from "../thinking";
 
@@ -36,7 +35,7 @@ function filterDiffNoise(diff: string): string {
 	return filtered.join("\n");
 }
 
-function getSmolModelCandidates(
+function getModelCandidates(
 	registry: ModelRegistry,
 	settings: Settings,
 ): Array<{ model: Model<Api>; thinkingLevel?: ThinkingLevel }> {
@@ -51,18 +50,12 @@ function getSmolModelCandidates(
 	};
 
 	const matchPreferences = { usageOrder: settings.getStorage()?.getModelUsageOrder() };
-	const configuredSmol = resolveModelRoleValue(settings.getModelRole("smol"), availableModels, {
+	const configured = resolveModelRoleValue(settings.getModelRole("default"), availableModels, {
 		settings,
 		matchPreferences,
 		modelRegistry: registry,
 	});
-	addCandidate(configuredSmol.model, configuredSmol.thinkingLevel);
-
-	for (const pattern of MODEL_PRIO.smol) {
-		const needle = pattern.toLowerCase();
-		addCandidate(availableModels.find(m => m.id.toLowerCase() === needle));
-		addCandidate(availableModels.find(m => m.id.toLowerCase().includes(needle)));
-	}
+	addCandidate(configured.model, configured.thinkingLevel);
 
 	for (const model of availableModels) {
 		addCandidate(model);
@@ -81,9 +74,9 @@ export async function generateCommitMessage(
 	settings: Settings,
 	sessionId?: string,
 ): Promise<string | null> {
-	const candidates = getSmolModelCandidates(registry, settings);
+	const candidates = getModelCandidates(registry, settings);
 	if (candidates.length === 0) {
-		logger.debug("commit-msg-generator: no smol model found");
+		logger.debug("commit-msg-generator: no model found");
 		return null;
 	}
 

package/src/utils/title-generator.ts

@@ -40,7 +40,7 @@ function getTitleModel(registry: ModelRegistry, settings: Settings, currentModel
 	const availableModels = registry.getAvailable();
 	if (availableModels.length === 0) return undefined;
 
-	const titleModel = resolveRoleSelection(["commit", "smol"], settings, availableModels, registry)?.model;
+	const titleModel = resolveRoleSelection(["default"], settings, availableModels, registry)?.model;
 	if (titleModel) return titleModel;
 
 	if (currentModel) return currentModel;

package/dist/types/harness-control-plane/frame-mapper.d.ts

@@ -1,29 +0,0 @@
-/**
- * Pure mapping from `gjc --mode rpc` event frames (docs/rpc.md) to bounded owner event kinds
- * and {@link ObservedSignal}s. The owner feeds raw frames through this mapper and emits the
- * result via its single-writer #emit — the mapper itself performs NO IO and NO appends.
- *
- * Hard rule: evidence is BOUNDED — only ids, names, categories, statuses, cursors, timestamps,
- * and short codes/messages. Never assistant text, message deltas, command output, or raw args.
- */
-import type { ObservedSignal } from "./types";
-export interface MappedFrame {
-    /** Owner event kind (rpc_*). */
-    kind: string;
-    /** Bounded observed signal, or null when the frame carries no user-facing signal. */
-    signal: ObservedSignal | null;
-    /** Bounded evidence — ids/names/statuses/cursors/timestamps/short codes only. */
-    evidence: Record<string, unknown>;
-    /** Severity for the emitted event. */
-    severity: "info" | "warn" | "critical";
-    /** Never-drop frames (must be enqueued in order, never coalesced away). */
-    semantic: boolean;
-    /** Coalescing key for high-frequency non-semantic frames (message id / tool id); null otherwise. */
-    coalesceKey: string | null;
-}
-export declare function isTestRunnerTool(toolName?: unknown, command?: unknown): boolean;
-/**
- * Map a single RPC frame. Returns null for frames that carry no observability value
- * (or that the adapter handles itself: `ready`, `response`).
- */
-export declare function mapRpcFrame(frame: Record<string, unknown>): MappedFrame | null;

package/src/harness-control-plane/frame-mapper.ts

@@ -1,286 +0,0 @@
-/**
- * Pure mapping from `gjc --mode rpc` event frames (docs/rpc.md) to bounded owner event kinds
- * and {@link ObservedSignal}s. The owner feeds raw frames through this mapper and emits the
- * result via its single-writer #emit — the mapper itself performs NO IO and NO appends.
- *
- * Hard rule: evidence is BOUNDED — only ids, names, categories, statuses, cursors, timestamps,
- * and short codes/messages. Never assistant text, message deltas, command output, or raw args.
- */
-import type { ObservedSignal } from "./types";
-
-export interface MappedFrame {
-	/** Owner event kind (rpc_*). */
-	kind: string;
-	/** Bounded observed signal, or null when the frame carries no user-facing signal. */
-	signal: ObservedSignal | null;
-	/** Bounded evidence — ids/names/statuses/cursors/timestamps/short codes only. */
-	evidence: Record<string, unknown>;
-	/** Severity for the emitted event. */
-	severity: "info" | "warn" | "critical";
-	/** Never-drop frames (must be enqueued in order, never coalesced away). */
-	semantic: boolean;
-	/** Coalescing key for high-frequency non-semantic frames (message id / tool id); null otherwise. */
-	coalesceKey: string | null;
-}
-
-const TEST_RE = /\b(bun test|npm test|yarn test|pnpm test|jest|vitest|pytest|go test|cargo test|mocha|ava)\b/i;
-const TOOL_STATUS_CODES = new Set([
-	"aborted",
-	"blocked",
-	"cancelled",
-	"complete",
-	"completed",
-	"error",
-	"failed",
-	"ok",
-	"pending",
-	"running",
-	"skipped",
-	"success",
-	"timeout",
-]);
-
-export function isTestRunnerTool(toolName?: unknown, command?: unknown): boolean {
-	const name = typeof toolName === "string" ? toolName : "";
-	const cmd = typeof command === "string" ? command : "";
-	if (/test/i.test(name) && name !== "edit" && name !== "read") return true;
-	return TEST_RE.test(cmd);
-}
-
-function str(v: unknown): string | undefined {
-	return typeof v === "string" ? v : undefined;
-}
-function num(v: unknown): number | undefined {
-	return typeof v === "number" ? v : undefined;
-}
-function boundedMessage(v: unknown): string | undefined {
-	const s = typeof v === "string" ? v : undefined;
-	return s === undefined ? undefined : s.slice(0, 200);
-}
-function boundedStatus(v: unknown): string | undefined {
-	if (typeof v !== "string") return undefined;
-	const status = v.trim().toLowerCase();
-	return TOOL_STATUS_CODES.has(status) ? status : undefined;
-}
-function recordObject(v: unknown): Record<string, unknown> | undefined {
-	return v && typeof v === "object" && !Array.isArray(v) ? (v as Record<string, unknown>) : undefined;
-}
-/** Extract a tool command from real AgentSessionEvent `args` or a flat fixture frame. Bounded use only — never persisted. */
-function toolCommand(frame: Record<string, unknown>): string | undefined {
-	const args = recordObject(frame.args);
-	const c = args?.command ?? args?.cmd ?? args?.commandLine;
-	if (typeof c === "string") return c;
-	return str(frame.command) ?? str(frame.commandLine);
-}
-/** Derive a tool status, honoring real `isError` booleans as well as bounded status strings. */
-function toolStatus(frame: Record<string, unknown>): string | undefined {
-	if (frame.isError === true) return "error";
-	const flatStatus = boundedStatus(frame.status);
-	if (flatStatus) return flatStatus;
-	for (const candidate of [frame.result, frame.partialResult]) {
-		const result = recordObject(candidate);
-		if (!result) continue;
-		if (result.isError === true) return "error";
-		const status = boundedStatus(result.status) ?? boundedStatus(recordObject(result.details)?.status);
-		if (status) return status;
-	}
-	return undefined;
-}
-
-/**
- * Map a single RPC frame. Returns null for frames that carry no observability value
- * (or that the adapter handles itself: `ready`, `response`).
- */
-export function mapRpcFrame(frame: Record<string, unknown>): MappedFrame | null {
-	const type = str(frame.type);
-	if (!type || type === "ready" || type === "response") return null;
-
-	switch (type) {
-		case "agent_start":
-			return {
-				kind: "rpc_agent_started",
-				signal: "SessionStart",
-				evidence: {},
-				severity: "info",
-				semantic: true,
-				coalesceKey: null,
-			};
-		case "turn_start":
-			return {
-				kind: "rpc_turn_started",
-				signal: "prompt-accepted",
-				evidence: {},
-				severity: "info",
-				semantic: true,
-				coalesceKey: null,
-			};
-		case "turn_end":
-			return {
-				kind: "rpc_turn_ended",
-				signal: null,
-				evidence: {},
-				severity: "info",
-				semantic: false,
-				coalesceKey: null,
-			};
-		case "message_start":
-		case "message_update":
-		case "message_end":
-			return {
-				kind: "rpc_message_activity",
-				signal: null,
-				evidence: { phase: type, messageId: str(frame.messageId) ?? null },
-				severity: "info",
-				semantic: false,
-				coalesceKey: `message:${str(frame.messageId) ?? "msg"}`,
-			};
-		case "tool_execution_start": {
-			const toolName = str(frame.toolName);
-			const test = isTestRunnerTool(toolName, toolCommand(frame));
-			return {
-				kind: "rpc_tool_started",
-				signal: test ? "test-running" : "tool-call",
-				evidence: { toolId: str(frame.toolCallId) ?? null, toolName: toolName ?? null },
-				severity: "info",
-				semantic: true,
-				coalesceKey: null,
-			};
-		}
-		case "tool_execution_update": {
-			const toolName = str(frame.toolName);
-			const test = isTestRunnerTool(toolName, toolCommand(frame));
-			return {
-				kind: "rpc_tool_updated",
-				signal: test ? "test-running" : null,
-				evidence: { toolId: str(frame.toolCallId) ?? null, status: toolStatus(frame) ?? null },
-				severity: "info",
-				semantic: false,
-				coalesceKey: `tool:${str(frame.toolCallId) ?? "tool"}`,
-			};
-		}
-		case "tool_execution_end": {
-			const toolName = str(frame.toolName);
-			const test = isTestRunnerTool(toolName, toolCommand(frame));
-			const status = toolStatus(frame);
-			return {
-				kind: "rpc_tool_ended",
-				signal: test ? "test-running" : "tool-call",
-				evidence: {
-					toolId: str(frame.toolCallId) ?? null,
-					toolName: toolName ?? null,
-					status: status ?? null,
-					exitCode: num(frame.exitCode) ?? null,
-				},
-				severity: status === "error" ? "warn" : "info",
-				semantic: true,
-				coalesceKey: null,
-			};
-		}
-		case "host_tool_call":
-		case "host_tool_cancel":
-			return {
-				kind: "rpc_host_tool",
-				signal: "tool-call",
-				evidence: { toolName: str(frame.toolName) ?? null },
-				severity: "info",
-				semantic: false,
-				coalesceKey: null,
-			};
-		case "host_uri_request":
-		case "host_uri_cancel":
-			return {
-				kind: "rpc_host_uri",
-				signal: "tool-call",
-				evidence: { operation: str(frame.operation) ?? null },
-				severity: "info",
-				semantic: false,
-				coalesceKey: null,
-			};
-		case "auto_compaction_start":
-		case "auto_compaction_end":
-			return {
-				kind: "rpc_compaction",
-				signal: null,
-				evidence: { phase: type },
-				severity: "info",
-				semantic: false,
-				coalesceKey: null,
-			};
-		case "auto_retry_start":
-		case "auto_retry_end":
-			return {
-				kind: "rpc_retry",
-				signal: null,
-				evidence: { phase: type, reason: boundedMessage(frame.reason) ?? null },
-				severity: "warn",
-				semantic: false,
-				coalesceKey: null,
-			};
-		case "ttsr_triggered":
-			return {
-				kind: "rpc_ttsr",
-				signal: "error",
-				evidence: { reason: boundedMessage(frame.reason) ?? null },
-				severity: "warn",
-				semantic: true,
-				coalesceKey: null,
-			};
-		case "todo_reminder":
-		case "todo_auto_clear":
-			return {
-				kind: "rpc_todo",
-				signal: null,
-				evidence: { phase: type },
-				severity: "info",
-				semantic: false,
-				coalesceKey: null,
-			};
-		case "extension_ui_request":
-			return {
-				kind: "rpc_extension_request",
-				signal: "tool-call",
-				evidence: { method: str(frame.method) ?? null },
-				severity: "info",
-				semantic: false,
-				coalesceKey: null,
-			};
-		case "extension_error":
-			return {
-				kind: "rpc_extension_error",
-				signal: "error",
-				evidence: {
-					code: str(frame.error) ? boundedMessage(frame.error) : null,
-					extensionPath: str(frame.extensionPath) ?? null,
-				},
-				severity: "critical",
-				semantic: true,
-				coalesceKey: null,
-			};
-		case "agent_end": {
-			const failed =
-				Boolean(frame.error) ||
-				frame.aborted === true ||
-				str(frame.outcome) === "failed" ||
-				str(frame.outcome) === "aborted";
-			return failed
-				? {
-						kind: "rpc_agent_failed",
-						signal: "error",
-						evidence: { outcome: str(frame.outcome) ?? "failed" },
-						severity: "critical",
-						semantic: true,
-						coalesceKey: null,
-					}
-				: {
-						kind: "rpc_agent_completed",
-						signal: "completed",
-						evidence: { outcome: "completed" },
-						severity: "info",
-						semantic: true,
-						coalesceKey: null,
-					};
-		}
-		default:
-			return null;
-	}
-}

package/src/priority.json

@@ -1,37 +0,0 @@
-{
-	"smol": [
-		"cerebras/zai-glm-4.7",
-		"cerebras/zai-glm-4.6",
-		"cerebras/zai-glm",
-		"haiku-4-5",
-		"haiku-4.5",
-		"haiku",
-		"flash",
-		"mini"
-	],
-	"slow": [
-		"gpt-5.4",
-		"gpt-5.3-codex",
-		"gpt-5.3",
-		"gpt-5.2-codex",
-		"gpt-5.2",
-		"gpt-5.1-codex",
-		"gpt-5.1",
-		"codex",
-		"opus-4.6",
-		"opus-4-6",
-		"opus-4.5",
-		"opus-4-5",
-		"opus-4.1",
-		"opus-4-1",
-		"pro"
-	],
-	"designer": [
-		"google-gemini-cli/gemini-3.1-pro",
-		"google-gemini-cli/gemini-3-pro",
-		"gemini-3.1-pro",
-		"gemini-3-1-pro",
-		"gemini-3-pro",
-		"gemini-3"
-	]
-}