@gajae-code/coding-agent 0.11.1 → 0.11.2

package/src/modes/controllers/goal-mode-controller.ts

@@ -0,0 +1,474 @@
+import { consumePendingGoalModeRequest } from "../../gjc-runtime/goal-mode-request";
+import {
+	canonicalArgsKey,
+	classifyToolOutcome,
+	decideTimeoutHold,
+	type TimeoutToolOutcome,
+	toResultText,
+	turnTimeoutFingerprint,
+} from "../../goals/continuation-timeout-guard";
+import { type Goal, type GoalModeState, normalizeGoal } from "../../goals/state";
+import type { AgentSession, AgentSessionEvent } from "../../session/agent-session";
+import type { SessionContext, SessionManager } from "../../session/session-manager";
+import { formatDuration } from "../../slash-commands/helpers/format";
+import type { SubmittedUserInput } from "../types";
+import type { ModeGate } from "./mode-gate";
+
+type GoalSubcommand = "set" | "show" | "pause" | "resume" | "drop";
+
+const GOAL_SUBCOMMANDS = new Set<GoalSubcommand>(["set", "show", "pause", "resume", "drop"]);
+
+interface GoalModeControllerContext {
+	readonly session: AgentSession;
+	readonly sessionManager: SessionManager;
+	readonly modeGate: ModeGate;
+	get planModeActive(): boolean;
+	get inputCallback(): ((input: SubmittedUserInput) => void) | undefined;
+	get hasPendingSubmission(): boolean;
+	get hasPendingImages(): boolean;
+	get editorText(): string;
+	startPendingSubmission(input: { text: string; customType?: string; display?: boolean }): SubmittedUserInput;
+	showStatus(message: string): void;
+	showWarning(message: string): void;
+	showError(message: string): void;
+	showHookConfirm(title: string, message: string): Promise<boolean>;
+	showHookSelector(title: string, options: string[]): Promise<string | undefined>;
+	showHookEditor(title: string, options?: { promptStyle?: boolean }): Promise<string | undefined>;
+	updateGoalModeStatus(status: { enabled: boolean; paused: boolean } | undefined): void;
+}
+
+function parseGoalSubcommand(args: string): { sub: GoalSubcommand | undefined; rest: string } {
+	const trimmed = args.trim();
+	if (!trimmed) return { sub: undefined, rest: "" };
+	const match = /^(\S+)(?:\s+([\s\S]*))?$/.exec(trimmed);
+	if (!match) return { sub: undefined, rest: trimmed };
+	const first = match[1].toLowerCase();
+	if (GOAL_SUBCOMMANDS.has(first as GoalSubcommand)) {
+		return { sub: first as GoalSubcommand, rest: match[2]?.trim() ?? "" };
+	}
+	return { sub: undefined, rest: trimmed };
+}
+
+/** Owns goal-mode state, continuation scheduling, commands, and session restoration. */
+export class GoalModeController {
+	#enabled = false;
+	#paused = false;
+	#previousTools: string[] | undefined;
+	#continuationTimer: NodeJS.Timeout | undefined;
+	#turnHadToolCalls = false;
+	#continuationTurnInFlight = false;
+	#suppressNextContinuation = false;
+	#goalTurnToolStarts = new Map<string, { toolName: string; argsKey: string }>();
+	#goalTurnOutcomes: TimeoutToolOutcome[] = [];
+	#goalTurnUnpaired = false;
+	#goalTurnSnapshotKey: string | undefined;
+	#goalHeldSnapshotKey: string | undefined;
+	#goalTimeoutFingerprint: string | undefined;
+	#goalIdenticalTimeoutStreak = 0;
+
+	constructor(private readonly ctx: GoalModeControllerContext) {}
+
+	get enabled(): boolean {
+		return this.#enabled;
+	}
+
+	get paused(): boolean {
+		return this.#paused;
+	}
+
+	setEnabledForCompatibility(enabled: boolean): void {
+		this.#enabled = enabled;
+	}
+
+	setPausedForCompatibility(paused: boolean): void {
+		this.#paused = paused;
+	}
+
+	async beforeGetUserInput(): Promise<void> {
+		if (this.ctx.session.getGoalModeState()?.mode === "exiting") {
+			await this.exit({ reason: "completed", silent: true });
+		}
+	}
+
+	scheduleContinuation(): void {
+		this.cancelContinuation();
+		if (!this.ctx.inputCallback) return;
+		if (!this.ctx.session.settings.get("goal.continuationModes").includes("interactive")) return;
+		if (this.ctx.planModeActive || !this.#enabled || this.#paused || this.#suppressNextContinuation) return;
+		if (this.ctx.hasPendingSubmission || this.ctx.editorText.trim() || this.ctx.hasPendingImages) return;
+		const state = this.ctx.session.getGoalModeState();
+		if (!state?.enabled || state.goal.status !== "active") return;
+		const prompt = this.ctx.session.goalRuntime.buildContinuationPrompt();
+		if (!prompt) return;
+		this.#continuationTimer = setTimeout(() => {
+			this.#continuationTimer = undefined;
+			if (!this.ctx.inputCallback || !this.#enabled || this.#paused) return;
+			if (this.ctx.hasPendingSubmission || this.ctx.editorText.trim() || this.ctx.hasPendingImages) return;
+			if (this.ctx.session.isStreaming || this.ctx.session.isCompacting) {
+				this.scheduleContinuation();
+				return;
+			}
+			const latestState = this.ctx.session.getGoalModeState();
+			if (!latestState?.enabled || latestState.goal.status !== "active") return;
+			this.#continuationTurnInFlight = true;
+			this.ctx.inputCallback(
+				this.ctx.startPendingSubmission({ text: prompt, customType: "goal-continuation", display: false }),
+			);
+		}, 800);
+	}
+
+	cancelContinuation(): void {
+		if (this.#continuationTimer) clearTimeout(this.#continuationTimer);
+		this.#continuationTimer = undefined;
+	}
+
+	onPendingSubmissionFinished(customType?: string): void {
+		if (customType === "goal-continuation") this.#continuationTurnInFlight = false;
+	}
+
+	onUserSubmission(): void {
+		this.#resetContinuationSuppression();
+	}
+
+	async handleSessionEvent(event: AgentSessionEvent): Promise<void> {
+		if (event.type === "agent_start") {
+			this.#turnHadToolCalls = false;
+			this.#goalTurnToolStarts.clear();
+			this.#goalTurnOutcomes = [];
+			this.#goalTurnUnpaired = false;
+			const goal = this.ctx.session.getGoalModeState()?.goal;
+			this.#goalTurnSnapshotKey = goal ? `${goal.id}\u0000${goal.objective}` : undefined;
+			this.cancelContinuation();
+			return;
+		}
+		if (event.type === "tool_execution_start") {
+			this.#turnHadToolCalls = true;
+			this.#goalTurnToolStarts.set(event.toolCallId, {
+				toolName: event.toolName,
+				argsKey: canonicalArgsKey(event.args),
+			});
+			if (!this.#continuationTurnInFlight) this.#resetContinuationSuppression();
+			return;
+		}
+		if (event.type === "tool_execution_end") {
+			const start = this.#goalTurnToolStarts.get(event.toolCallId);
+			if (!start) {
+				this.#turnHadToolCalls = true;
+				this.#goalTurnUnpaired = true;
+			} else {
+				this.#goalTurnOutcomes.push({
+					...start,
+					kind: classifyToolOutcome(event.isError, toResultText(event.result)),
+				});
+				this.#goalTurnToolStarts.delete(event.toolCallId);
+			}
+			return;
+		}
+		if (event.type === "message_start" && event.message.role === "user" && !event.message.synthetic) {
+			this.#resetContinuationSuppression();
+			return;
+		}
+		if (event.type === "goal_updated") {
+			if (event.state?.goal?.status === "dropped") {
+				await this.exit({ reason: "dropped", silent: true });
+				return;
+			}
+			const goal = event.state?.goal;
+			const snapshotKey = goal ? `${goal.id}\u0000${goal.objective}` : undefined;
+			if (this.#goalHeldSnapshotKey !== undefined && this.#goalHeldSnapshotKey !== snapshotKey)
+				this.#resetContinuationSuppression();
+			if (event.state?.enabled && !this.#previousTools) this.#previousTools = this.ctx.session.getActiveToolNames();
+			this.#enabled = event.state?.enabled === true;
+			this.#paused = event.state?.enabled !== true && event.state?.goal?.status === "paused";
+			if (this.#enabled || this.#paused) this.ctx.modeGate.enter("goal");
+			else this.ctx.modeGate.exit("goal");
+			if (!event.state?.enabled) {
+				this.#resetContinuationSuppression();
+				this.cancelContinuation();
+			}
+			this.#updateStatus();
+			return;
+		}
+		if (event.type !== "agent_end") return;
+		if (this.#continuationTurnInFlight) {
+			this.#suppressNextContinuation = !this.#turnHadToolCalls;
+			const fingerprint =
+				this.#goalTurnToolStarts.size > 0 || this.#goalTurnUnpaired
+					? null
+					: turnTimeoutFingerprint(this.#goalTurnOutcomes);
+			const decision = decideTimeoutHold(
+				{
+					heldSnapshotKey: this.#goalHeldSnapshotKey,
+					fingerprint: this.#goalTimeoutFingerprint,
+					streak: this.#goalIdenticalTimeoutStreak,
+				},
+				{ snapshotKey: this.#goalTurnSnapshotKey ?? "", fingerprint },
+			);
+			if (fingerprint === null) this.#resetTimeoutHold();
+			else {
+				this.#goalHeldSnapshotKey = decision.next.heldSnapshotKey;
+				this.#goalTimeoutFingerprint = decision.next.fingerprint;
+				this.#goalIdenticalTimeoutStreak = decision.next.streak;
+			}
+			if (decision.hold) {
+				this.#suppressNextContinuation = true;
+				this.ctx.showStatus(
+					`Goal paused for attention: repeated identical timeout from ${this.#goalTurnOutcomes[0]?.toolName ?? "tool"}. Send a message to continue.`,
+				);
+			}
+			this.#continuationTurnInFlight = false;
+		} else {
+			this.#resetTimeoutHold();
+		}
+		if (this.ctx.session.getGoalModeState()?.mode === "exiting") {
+			await this.exit({ reason: "completed", silent: true });
+			return;
+		}
+		this.scheduleContinuation();
+	}
+
+	async restoreFromSession(sessionContext: SessionContext): Promise<boolean> {
+		const goalEnabled = this.ctx.session.settings.get("goal.enabled");
+		if (!goalEnabled && (sessionContext.mode === "goal" || sessionContext.mode === "goal_paused")) {
+			this.ctx.sessionManager.appendModeChange("none");
+			return true;
+		}
+		if (sessionContext.mode === "goal" || sessionContext.mode === "goal_paused") {
+			const goal = normalizeGoal(sessionContext.modeData?.goal) ?? undefined;
+			if (!goal) {
+				this.ctx.sessionManager.appendModeChange("none");
+				return true;
+			}
+			this.ctx.session.setGoalModeState({ enabled: sessionContext.mode === "goal", mode: "active", goal });
+			const restored = await this.ctx.session.goalRuntime.onThreadResumed();
+			this.#enabled = restored?.enabled === true;
+			this.#paused = restored?.enabled !== true && restored?.goal.status === "paused";
+			if (this.#enabled || this.#paused) this.ctx.modeGate.enter("goal");
+			if (restored?.goal) {
+				this.#previousTools = this.ctx.session.getActiveToolNames();
+				await this.ctx.session.setActiveToolsByName([...new Set([...this.#previousTools, "goal"])]);
+			}
+			this.#updateStatus();
+			return true;
+		}
+		const pendingGoal = goalEnabled
+			? await consumePendingGoalModeRequest(this.ctx.sessionManager.getCwd(), this.ctx.sessionManager.getSessionId())
+			: null;
+		if (!pendingGoal) return false;
+		await this.enter({ objective: pendingGoal.objective, provenance: pendingGoal.provenance, silent: true });
+		this.scheduleContinuation();
+		return true;
+	}
+
+	async handleCommand(rest?: string): Promise<void> {
+		try {
+			if (this.ctx.planModeActive) return this.ctx.showWarning("Exit plan mode first.");
+			if (!this.ctx.session.settings.get("goal.enabled"))
+				return this.ctx.showWarning("Goal mode is disabled. Enable it in settings (goal.enabled).");
+			const { sub, rest: subRest } = parseGoalSubcommand(rest ?? "");
+			if (sub) return await this.#dispatchSubcommand(sub, subRest);
+			if (this.#enabled) {
+				if (subRest)
+					return this.ctx.showStatus(
+						"Goal mode is already active. Use /goal to manage it, or /goal drop to start over.",
+					);
+				return await this.#openMenu("active");
+			}
+			if (this.#getPausedState()) {
+				if (subRest)
+					return this.ctx.showWarning("Resume the current goal first, or drop it before setting a new objective.");
+				return await this.#openMenu("paused");
+			}
+			const objective = subRest || (await this.ctx.showHookEditor("Goal objective", { promptStyle: true }))?.trim();
+			if (objective) await this.#startFromObjective(objective);
+		} catch (error) {
+			this.ctx.showError(error instanceof Error ? error.message : String(error));
+		}
+	}
+
+	async enter(options: {
+		objective?: string;
+		provenance?: Goal["provenance"];
+		resume?: boolean;
+		silent?: boolean;
+	}): Promise<void> {
+		if (this.#enabled) return;
+		if (!this.ctx.modeGate.enter("goal")) return this.ctx.showWarning("Exit plan mode first.");
+		this.#previousTools = this.ctx.session.getActiveToolNames();
+		this.#paused = false;
+		const state = options.resume
+			? await this.ctx.session.goalRuntime.resumeGoal()
+			: await this.ctx.session.goalRuntime.createGoal({
+					objective: options.objective ?? "",
+					provenance: options.provenance,
+				});
+		await this.ctx.session.setActiveToolsByName([...new Set([...this.#previousTools, "goal"])]);
+		this.ctx.session.setGoalModeState(state);
+		this.#enabled = true;
+		this.#resetContinuationSuppression();
+		this.#updateStatus();
+		if (this.ctx.session.isStreaming) await this.ctx.session.sendGoalModeContext({ deliverAs: "steer" });
+		if (!options.silent) this.ctx.showStatus(options.resume ? "Goal mode resumed." : "Goal mode enabled.");
+	}
+
+	async exit(options?: {
+		silent?: boolean;
+		paused?: boolean;
+		reason?: "completed" | "paused" | "dropped";
+	}): Promise<void> {
+		const shouldRestoreTools =
+			this.#previousTools &&
+			options?.reason !== "dropped" &&
+			(this.#enabled || options?.reason === "completed" || options?.paused);
+		if (shouldRestoreTools && this.#previousTools) await this.ctx.session.setActiveToolsByName(this.#previousTools);
+		const currentState = this.ctx.session.getGoalModeState();
+		if (options?.reason === "completed") {
+			this.ctx.session.setGoalModeState(undefined);
+			this.ctx.sessionManager.appendModeChange("none");
+			this.ctx.sessionManager.appendCustomEntry("goal-completed", {
+				objective: currentState?.goal?.objective,
+				tokensUsed: currentState?.goal?.tokensUsed,
+				timeUsedSeconds: currentState?.goal?.timeUsedSeconds,
+			});
+		}
+		this.#enabled = false;
+		this.#paused = options?.paused ?? false;
+		this.#previousTools = undefined;
+		this.#continuationTurnInFlight = false;
+		this.#resetContinuationSuppression();
+		this.cancelContinuation();
+		if (!this.#paused) this.ctx.modeGate.exit("goal");
+		this.#updateStatus();
+		if (!options?.silent)
+			this.ctx.showStatus(
+				options?.reason === "completed"
+					? "Goal mode completed."
+					: options?.reason === "dropped"
+						? "Goal dropped."
+						: options?.paused
+							? "Goal mode paused."
+							: "Goal mode disabled.",
+			);
+	}
+
+	#getPausedState(): GoalModeState | undefined {
+		const state = this.ctx.session.getGoalModeState();
+		return state?.goal && !state.enabled && state.goal.status === "paused" ? state : undefined;
+	}
+
+	#updateStatus(): void {
+		this.ctx.updateGoalModeStatus(
+			this.#enabled || this.#paused ? { enabled: this.#enabled, paused: this.#paused } : undefined,
+		);
+	}
+
+	#resetTimeoutHold(): void {
+		this.#goalTurnToolStarts.clear();
+		this.#goalTurnOutcomes = [];
+		this.#goalTurnUnpaired = false;
+		this.#goalTurnSnapshotKey = undefined;
+		this.#goalHeldSnapshotKey = undefined;
+		this.#goalTimeoutFingerprint = undefined;
+		this.#goalIdenticalTimeoutStreak = 0;
+	}
+
+	#resetContinuationSuppression(): void {
+		this.#suppressNextContinuation = false;
+		this.#resetTimeoutHold();
+	}
+
+	async #dispatchSubcommand(sub: GoalSubcommand, rest: string): Promise<void> {
+		switch (sub) {
+			case "set":
+				return await this.#set(rest);
+			case "show":
+				return this.#showDetails();
+			case "pause":
+				return await this.#pause();
+			case "resume":
+				return await this.#resume();
+			case "drop":
+				return await this.#drop();
+		}
+	}
+
+	async #openMenu(state: "active" | "paused"): Promise<void> {
+		const goal = this.ctx.session.getGoalModeState()?.goal;
+		if (!goal) return;
+		const summary = goal.objective.length > 48 ? `${goal.objective.slice(0, 47)}…` : goal.objective;
+		const choice = await this.ctx.showHookSelector(
+			state === "active" ? `Goal: ${summary} (${goal.status})` : `Goal paused: ${summary}`,
+			state === "active" ? ["Show details", "Pause", "Drop"] : ["Resume", "Show details", "Drop"],
+		);
+		if (choice === "Show details") this.#showDetails();
+		else if (choice === "Pause") await this.#pause();
+		else if (choice === "Resume") await this.#resume();
+		else if (choice === "Drop") await this.#drop();
+	}
+
+	#showDetails(): void {
+		const state = this.ctx.session.getGoalModeState();
+		const goal = state?.goal;
+		if (!goal) return this.ctx.showStatus("No goal set.");
+		this.ctx.showStatus(
+			[
+				`Objective: ${goal.objective}`,
+				`Status: ${goal.status}${state?.enabled ? "" : " (paused)"}`,
+				`Tokens used: ${goal.tokensUsed.toLocaleString()}`,
+				`Time spent: ${formatDuration(goal.timeUsedSeconds * 1000)}`,
+			].join("\n"),
+		);
+	}
+
+	async #pause(): Promise<void> {
+		if (!this.#enabled) return this.ctx.showWarning("No active goal to pause.");
+		await this.ctx.session.goalRuntime.pauseGoal();
+		await this.exit({ paused: true, reason: "paused" });
+	}
+
+	async #resume(): Promise<void> {
+		if (!this.#getPausedState()) return this.ctx.showWarning("No paused goal to resume.");
+		await this.enter({ resume: true, silent: true });
+		this.ctx.showStatus("Goal mode resumed.");
+		this.scheduleContinuation();
+	}
+
+	async #drop(): Promise<void> {
+		if (!this.#enabled && !this.#getPausedState()) return this.ctx.showWarning("No goal to drop.");
+		if (
+			!(await this.ctx.showHookConfirm(
+				"Drop goal?",
+				"This removes the goal record. Accumulated usage stays in the session log.",
+			))
+		)
+			return;
+		await this.ctx.session.goalRuntime.dropGoal();
+		await this.exit({ reason: "dropped" });
+	}
+
+	async #startFromObjective(objective: string): Promise<void> {
+		await this.enter({ objective, silent: true });
+		this.#resetContinuationSuppression();
+		this.ctx.inputCallback?.(this.ctx.startPendingSubmission({ text: objective }));
+	}
+
+	async #replaceFromObjective(objective: string): Promise<void> {
+		const state = await this.ctx.session.goalRuntime.replaceGoal({ objective });
+		this.ctx.session.setGoalModeState(state);
+		this.#enabled = true;
+		this.#paused = false;
+		this.#resetContinuationSuppression();
+		this.#updateStatus();
+		if (this.ctx.session.isStreaming) await this.ctx.session.sendGoalModeContext({ deliverAs: "steer" });
+		this.ctx.inputCallback?.(this.ctx.startPendingSubmission({ text: objective }));
+	}
+
+	async #set(rest: string): Promise<void> {
+		if (!this.#enabled && this.#getPausedState())
+			return this.ctx.showWarning("Resume the current goal first, or drop it before setting a new objective.");
+		const objective = rest.trim() || (await this.ctx.showHookEditor("Goal objective", { promptStyle: true }))?.trim();
+		if (!objective) return;
+		if (this.#enabled) await this.#replaceFromObjective(objective);
+		else await this.#startFromObjective(objective);
+	}
+}