@gajae-code/coding-agent 0.7.6 → 0.7.8

package/src/export/html/template.js

@@ -1113,17 +1113,6 @@
         return html;
       }
 
-      function renderInspectImage(name, args, result, ctx) {
-        const p = str(args.path == null ? args.url : args.path) || '';
-        let html = toolHead('inspect_image', escapeHtml(shortenPath(p)));
-        if (result) {
-          html += ctx.renderResultImages();
-          const output = ctx.getResultText();
-          if (output) html += formatExpandableOutput(output, 8);
-        }
-        return html;
-      }
-
       function renderGenerateImage(name, args, result, ctx) {
         const subject = str(args.subject) || '';
         const badges = args.aspect_ratio ? [String(args.aspect_ratio)] : null;
@@ -1544,7 +1533,6 @@
         debug: renderDebug,
         puppeteer: renderBrowser,
         browser: renderBrowser,
-        inspect_image: renderInspectImage,
         generate_image: renderGenerateImage,
         ask: renderAsk,
         resolve: renderResolve,

package/src/gjc-runtime/launch-tmux.ts

@@ -6,6 +6,7 @@ import type { Args } from "../cli/args";
 import { tmuxRuntimeSessionPath } from "./session-layout";
 import { GJC_COORDINATOR_SESSION_ID_ENV, GJC_COORDINATOR_SESSION_STATE_FILE_ENV } from "./session-state-sidecar";
 import {
+	buildGjcTmuxExactSessionTarget,
 	buildGjcTmuxProfileCommands,
 	buildGjcTmuxSessionName,
 	buildGjcTmuxSessionSlug,
@@ -21,6 +22,7 @@ import {
 import { findGjcTmuxSessionByName, findGjcTmuxSessionByScope, type GjcTmuxSessionStatus } from "./tmux-sessions";
 
 export {
+	buildGjcTmuxExactSessionTarget,
 	buildGjcTmuxProfileCommands,
 	GJC_DEFAULT_TMUX_SESSION,
 	GJC_TMUX_COMMAND_ENV,
@@ -201,12 +203,24 @@ function buildWindowsPowerShellInnerCommand(context: CommandResolutionContext, r
 	const envLines = Object.entries({ [GJC_TMUX_LAUNCHED_ENV]: "1", ...(context.extraEnv ?? {}) }).map(
 		([key, value]) => `$env:${key} = ${powershellQuote(value)}`,
 	);
-	const invocation = ["&", ...command.map(powershellQuote), ...stripRootTmuxFlag(rawArgs).map(powershellQuote)].join(
-		" ",
-	);
+	// The inner `&` invocation must wrap the resolved gjc command in a
+	// script-block so the trailing PowerShell exec-policy flags from the
+	// outer invocation are not forwarded into the bun / node / .bat
+	// binary the gjc command resolves to. Without the wrapping, the flags
+	// reach the runtime binary and cause an immediate failure that closes
+	// the psmux pane before the gjc --tmux attach can land.
+	const resolvedCommand = command.map(powershellQuote).join(" ");
+	const innerArgs = stripRootTmuxFlag(rawArgs).map(powershellQuote).join(" ");
+	const invocation = `& { ${resolvedCommand} ${innerArgs} }`;
 	const exitLine = "if ($null -ne $LASTEXITCODE) { exit $LASTEXITCODE } else { exit 1 }";
 	const script = [...envLines, invocation, exitLine].join("\n");
-	const encodedCommand = Buffer.from(script, "utf16le").toString("base64");
+	// PowerShell -EncodedCommand requires a UTF-16LE BOM (0xFF 0xFE) at the
+	// start of the decoded buffer; without it pwsh may misinterpret the
+	// leading bytes and reject the script with a parse error, which would
+	// kill the psmux pane before the gjc --tmux attach could land.
+	const bom = Buffer.from([0xff, 0xfe]);
+	const body = Buffer.from(script, "utf16le");
+	const encodedCommand = Buffer.concat([bom, body]).toString("base64");
 	return `pwsh -NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -EncodedCommand ${encodedCommand}`;
 }
 
@@ -395,7 +409,11 @@ function readCurrentBranch(cwd: string): string | null {
 }
 
 function cleanupCreatedTmuxSession(plan: TmuxLaunchPlan, spawnSync: TmuxSpawnSync, options: TmuxSpawnOptions): void {
-	spawnSync(plan.tmuxCommand, ["kill-session", "-t", `=${plan.sessionName}`], options);
+	spawnSync(
+		plan.tmuxCommand,
+		["kill-session", "-t", buildGjcTmuxExactSessionTarget(plan.sessionName, { env: options.env })],
+		options,
+	);
 }
 function isTmuxAttachDisconnectError(result: TmuxSpawnResult): boolean {
 	if (result.signalCode === "SIGHUP") return true;
@@ -499,7 +517,11 @@ export function launchDefaultTmuxIfNeeded(context: TmuxLaunchContext): boolean {
 	};
 
 	if (plan.attachSessionName) {
-		const attached = spawnSync(plan.tmuxCommand, ["attach-session", "-t", `=${plan.attachSessionName}`], options);
+		const attached = spawnSync(
+			plan.tmuxCommand,
+			["attach-session", "-t", buildGjcTmuxExactSessionTarget(plan.attachSessionName, { env })],
+			options,
+		);
 		if (attached.exitCode === 0) return true;
 	}
 
@@ -510,7 +532,7 @@ export function launchDefaultTmuxIfNeeded(context: TmuxLaunchContext): boolean {
 			buildGjcTmuxWindowTitle(plan.project ?? plan.cwd, plan.branch),
 			spawnSync,
 			options,
-			`=${plan.sessionName}`,
+			buildGjcTmuxExactSessionTarget(plan.sessionName, { env }),
 		);
 
 		const profile = applyGjcTmuxProfile({
@@ -535,7 +557,11 @@ export function launchDefaultTmuxIfNeeded(context: TmuxLaunchContext): boolean {
 		}
 	}
 	if (created.exitCode !== 0) return false;
-	const attached = spawnSync(plan.tmuxCommand, ["attach-session", "-t", `=${plan.sessionName}`], options);
+	const attached = spawnSync(
+		plan.tmuxCommand,
+		["attach-session", "-t", buildGjcTmuxExactSessionTarget(plan.sessionName, { env })],
+		options,
+	);
 	if (attached.exitCode === 0) return true;
 	if (isTmuxAttachDisconnectError(attached)) {
 		(context.diagnosticWriter ?? safeStderrWrite)(formatTmuxLaunchDiagnostic("attach disconnected", attached.stderr));

package/src/gjc-runtime/launch-worktree.ts

@@ -118,6 +118,20 @@ function findWorktreeByPath(entries: GitWorktreeEntry[], worktreePath: string):
 	return entries.find(entry => path.resolve(entry.path) === resolved) ?? null;
 }
 
+function describeWorktreeEntry(entry: GitWorktreeEntry): string {
+	return entry.detached ? `detached HEAD ${entry.head}` : (entry.branchRef ?? `HEAD ${entry.head}`);
+}
+
+function formatWorktreeTargetMismatch(plan: GjcLaunchWorktreePlan, existing: GitWorktreeEntry): string {
+	const expected = plan.detached ? `detached HEAD ${plan.baseRef}` : `branch refs/heads/${plan.branchName ?? ""}`;
+	return [
+		`worktree_target_mismatch:${plan.worktreePath}`,
+		`GJC launch worktree target is already registered for ${describeWorktreeEntry(existing)}, but this launch expects ${expected}.`,
+		`Path: ${plan.worktreePath}`,
+		"Refusing to delete or reuse the conflicting worktree automatically. Safe remediation: inspect the path, commit/stash any work, then remove or prune the stale worktree with git worktree remove <path> when it is no longer needed, or choose a different --worktree name.",
+	].join("\n");
+}
+
 function hasBranchInUse(entries: GitWorktreeEntry[], branchName: string, worktreePath: string): boolean {
 	const expectedRef = `refs/heads/${branchName}`;
 	const resolvedPath = path.resolve(worktreePath);
@@ -228,7 +242,7 @@ export function ensureLaunchWorktree(
 		let dirty = isWorktreeDirty(plan.worktreePath);
 		if (plan.detached) {
 			if (!existingAtPath.detached) {
-				throw new Error(`worktree_target_mismatch:${plan.worktreePath}`);
+				throw new Error(formatWorktreeTargetMismatch(plan, existingAtPath));
 			}
 			if (existingAtPath.head !== plan.baseRef) {
 				if (dirty) throw new Error(`worktree_dirty:${plan.worktreePath}`);
@@ -236,7 +250,7 @@ export function ensureLaunchWorktree(
 				dirty = false;
 			}
 		} else if (existingAtPath.branchRef !== expectedBranchRef) {
-			throw new Error(`worktree_target_mismatch:${plan.worktreePath}`);
+			throw new Error(formatWorktreeTargetMismatch(plan, existingAtPath));
 		}
 		return {
 			...plan,

package/src/gjc-runtime/state-renderer.ts

@@ -256,6 +256,11 @@ export function renderUltragoalStatusMarkdown(summary: {
 	currentGoal?: { id: string; status: string; title?: string; objective?: string };
 	counts: Record<string, number>;
 	goals: unknown[];
+	nudgeBudget?: number;
+	nudgeCount?: number;
+	nudgeRemaining?: number;
+	nudgeGoalId?: string;
+	nudgeTargetKind?: string;
 }): string {
 	if (!summary.exists)
 		return `# ultragoal status\n\n- status: missing\n- No ultragoal plan found at ${summary.paths.goalsPath}. Run \`gjc ultragoal create-goals --brief "..."\` first.\n`;
@@ -270,6 +275,14 @@ export function renderUltragoalStatusMarkdown(summary: {
 	];
 	if (summary.gjcObjective) lines.push(`- objective: ${summary.gjcObjective}`);
 	if (summary.currentGoal) lines.push(`- current: ${summary.currentGoal.id} (${summary.currentGoal.status})`);
+	if (summary.nudgeBudget !== undefined && summary.nudgeGoalId) {
+		const used = summary.nudgeCount ?? 0;
+		const remaining = summary.nudgeRemaining ?? Math.max(0, summary.nudgeBudget - used);
+		const target = summary.nudgeTargetKind ? ` target=${summary.nudgeTargetKind}` : "";
+		lines.push(
+			`- nudge: ${summary.nudgeGoalId} ${used}/${summary.nudgeBudget} used (${remaining} remaining)${target}`,
+		);
+	}
 	lines.push(`- goals_path: ${summary.paths.goalsPath}`);
 	if (summary.paths.ledgerPath) lines.push(`- ledger_path: ${summary.paths.ledgerPath}`);
 	return `${lines.join("\n")}\n`;

package/src/gjc-runtime/team-runtime.ts

@@ -1896,13 +1896,27 @@ function readCurrentTmuxLeaderContext(tmuxCommand: string, env: NodeJS.ProcessEn
 	}
 	return { sessionName, windowIndex, leaderPaneId, target: `${sessionName}:${windowIndex}` };
 }
-export function resolveGjcWorkerCommand(cwd = process.cwd(), env: NodeJS.ProcessEnv = process.env): string {
+export function resolveGjcWorkerCommand(
+	cwd = process.cwd(),
+	env: NodeJS.ProcessEnv = process.env,
+	platform: NodeJS.Platform = process.platform,
+	argv: string[] = process.argv,
+	execPath = process.execPath,
+): string {
 	const explicit = env.GJC_TEAM_WORKER_COMMAND?.trim();
 	if (explicit) return explicit;
-	const entrypoint = process.argv[1];
-	if (entrypoint?.endsWith(".ts"))
-		return `${shellQuote(process.execPath)} ${shellQuote(path.resolve(cwd, entrypoint))}`;
-	if (entrypoint && path.basename(entrypoint).startsWith("gjc")) return shellQuote(path.resolve(cwd, entrypoint));
+	const entrypoint = argv[1];
+	if (!entrypoint) return "gjc";
+	const pathModule = platform === "win32" ? path.win32 : path;
+	const resolvedEntrypoint = pathModule.isAbsolute(entrypoint) ? entrypoint : pathModule.resolve(cwd, entrypoint);
+	if (platform === "win32") {
+		if (entrypoint.endsWith(".ts") || entrypoint.endsWith(".js") || entrypoint.endsWith(".mjs"))
+			return `${powershellQuote(execPath)} ${powershellQuote(resolvedEntrypoint)}`;
+		if (pathModule.basename(entrypoint).startsWith("gjc")) return powershellQuote(resolvedEntrypoint);
+		return "gjc";
+	}
+	if (entrypoint.endsWith(".ts")) return `${shellQuote(execPath)} ${shellQuote(resolvedEntrypoint)}`;
+	if (path.basename(entrypoint).startsWith("gjc")) return shellQuote(path.resolve(cwd, entrypoint));
 	return "gjc";
 }
 /** @internal Exported for unit tests. */
@@ -1937,7 +1951,8 @@ export function buildWorkerCommand(
 		...(worker.worktree_path ? [envAssignment("GJC_TEAM_WORKTREE_PATH", worker.worktree_path)] : []),
 	];
 	const joined = platform === "win32" ? envLines.join(" ") : envLines.join(" ");
-	return `${joined} ${config.worker_command} ${quote(prompt)}`;
+	const invocation = platform === "win32" ? `& ${config.worker_command}` : config.worker_command;
+	return `${joined} ${invocation} ${quote(prompt)}`;
 }
 interface GjcTeamInitialLane {
 	label: string;

package/src/gjc-runtime/tmux-common.ts

@@ -86,6 +86,22 @@ export function buildGjcTmuxExactOptionTarget(
 	return `=${sessionName}:`;
 }
 
+/**
+ * Build the exact-session target for tmux *session-scoped* commands such as
+ * `attach-session` and `kill-session`. Native tmux accepts `=NAME` for an
+ * exact session match, but Windows psmux 3.3.x rejects that target form for
+ * session commands even though the bare `NAME` resolves. Keep native tmux on
+ * exact targets and intentionally use the bare session name for psmux.
+ */
+export function buildGjcTmuxExactSessionTarget(
+	sessionName: string,
+	opts: { env?: NodeJS.ProcessEnv; platform?: NodeJS.Platform; binary?: ResolvedTmuxBinary } = {},
+): string {
+	const binary = opts.binary ?? resolveGjcTmuxBinary({ env: opts.env, platform: opts.platform });
+	if (binary.isPsmux) return sessionName;
+	return `=${sessionName}`;
+}
+
 export const GJC_TMUX_UNTAGGED_REASON = "gjc_tmux_session_untagged";
 
 export function buildGjcTmuxUntaggedSessionHint(tmuxCommand: string): string {

package/src/gjc-runtime/tmux-sessions.ts

@@ -1,6 +1,7 @@
 import { resolveGjcTmuxBinary } from "./psmux-detect";
 import {
 	buildGjcTmuxExactOptionTarget,
+	buildGjcTmuxExactSessionTarget,
 	buildGjcTmuxProfileCommands,
 	buildGjcTmuxSessionName,
 	buildGjcTmuxUntaggedSessionError,
@@ -60,7 +61,7 @@ function runTmux(args: string[], env: NodeJS.ProcessEnv = process.env): string {
 
 function tryKillSession(sessionName: string, env: NodeJS.ProcessEnv): void {
 	try {
-		runTmux(["kill-session", "-t", `=${sessionName}`], env);
+		runTmux(["kill-session", "-t", buildGjcTmuxExactSessionTarget(sessionName, { env })], env);
 	} catch {
 		// Best-effort cleanup only; preserve the original create/tag failure.
 	}
@@ -360,7 +361,7 @@ export function removeGjcTmuxSession(sessionName: string, env: NodeJS.ProcessEnv
 	if (readProfileForExactTarget(session.name, env) !== GJC_TMUX_PROFILE_VALUE) {
 		throw new Error(`gjc_tmux_session_not_managed:${sessionName}`);
 	}
-	runTmux(["kill-session", "-t", `=${session.name}`], env);
+	runTmux(["kill-session", "-t", buildGjcTmuxExactSessionTarget(session.name, { env })], env);
 	return session;
 }
 
@@ -404,18 +405,21 @@ export function forceCloseGjcTmuxSession(
 		}
 	}
 	// Intentionally NOT refusing live/attached panes — force-close is hard-kill.
-	runTmux(["kill-session", "-t", `=${session.name}`], env);
+	runTmux(["kill-session", "-t", buildGjcTmuxExactSessionTarget(session.name, { env })], env);
 	return session;
 }
 
 export function attachGjcTmuxSession(sessionName: string, env: NodeJS.ProcessEnv = process.env): never {
 	const session = statusGjcTmuxSession(sessionName, env);
 	const tmuxCommand = resolveGjcTmuxCommand(env);
-	const result = Bun.spawnSync([tmuxCommand, "attach-session", "-t", `=${session.name}`], {
-		stdin: "inherit",
-		stdout: "inherit",
-		stderr: "inherit",
-		env,
-	});
+	const result = Bun.spawnSync(
+		[tmuxCommand, "attach-session", "-t", buildGjcTmuxExactSessionTarget(session.name, { env })],
+		{
+			stdin: "inherit",
+			stdout: "inherit",
+			stderr: "inherit",
+			env,
+		},
+	);
 	process.exit(result.exitCode ?? 1);
 }

package/src/gjc-runtime/ultragoal-guard.ts

@@ -8,9 +8,13 @@ import {
 	hashStructuredValue,
 	readUltragoalLedger,
 	readUltragoalPlan,
+	recordUltragoalNudgeIfBudgetRemaining,
+	resolveUltragoalNudgeBudget,
+	selectUltragoalNudgeTarget,
 	type UltragoalCompletionVerification,
 	type UltragoalGoal,
 	type UltragoalLedgerEvent,
+	type UltragoalNudgeSurface,
 	type UltragoalPaths,
 	type UltragoalPlan,
 	type UltragoalReceiptKind,
@@ -494,6 +498,96 @@ export async function isUltragoalAskBlocked(cwd: string): Promise<UltragoalAskBl
 	});
 }
 
+const NUDGE_SURFACE_LABEL: Record<UltragoalNudgeSurface, string> = {
+	pause: "pausing the goal",
+	drop: "dropping the run",
+	ask: "asking the user",
+	premature_complete: "finishing the story early",
+};
+
+const NUDGE_SURFACE_REASON: Record<UltragoalNudgeSurface, string> = {
+	pause: "an active story still has resolvable work",
+	drop: "the aggregate run still has unfinished stories",
+	ask: "the decision can be resolved as durable story work",
+	premature_complete: "story verification is not yet satisfied",
+};
+
+/**
+ * Escalating per-attempt refusal text. Deliberately avoids every
+ * `isUltragoalBypassPrompt` trigger: no `update_goal(`, no "skip/weaken verification",
+ * no "mark ... complete", no "--status complete", and the word "complete" never
+ * appears (so the `goal` ... `complete` proximity rule cannot match).
+ */
+export function formatUltragoalNudgeMessage(input: {
+	surface: UltragoalNudgeSurface;
+	attempt: number;
+	budget: number;
+	goalId: string;
+}): string {
+	const label = NUDGE_SURFACE_LABEL[input.surface];
+	const reason = NUDGE_SURFACE_REASON[input.surface];
+	return [
+		`Ultragoal try-harder nudge (${input.attempt}/${input.budget}) for ${input.goalId}: ${label} was refused before the normal gate.`,
+		`Resolving this is part of the goal, not a reason to stop. Try a different approach first: inspect the failure, run a focused test or replay, find local credentials/config if access is the blocker, split the obstacle with \`gjc ultragoal steer --kind add_subgoal\`, delegate an executor, or record concrete review blockers.`,
+		`Reason: ${reason}.`,
+	].join("\n");
+}
+
+/**
+ * Consume one nudge for a guarded give-up attempt. MUST only be called from assert/
+ * consume paths, never from read-style `is...Blocked` diagnostics. Returns a nudge
+ * message while the per-story budget remains; otherwise reports not-nudged so the
+ * caller falls through to today's gate.
+ */
+async function consumeUltragoalNudge(input: {
+	cwd: string;
+	surface: UltragoalNudgeSurface;
+	currentGoal?: CurrentGoalLike | null;
+	sessionId?: string | null;
+}): Promise<{ nudged: true; message: string } | { nudged: false }> {
+	const sessionId = input.sessionId?.trim() || (await ultragoalReadPaths(input.cwd)).sessionId;
+	if (!sessionId) return { nudged: false };
+	const plan = await readUltragoalPlan(input.cwd, sessionId);
+	if (!plan) return { nudged: false };
+	const target = selectUltragoalNudgeTarget(plan, { currentGoalObjective: input.currentGoal?.objective });
+	if (!target) return { nudged: false };
+	const { budget } = await resolveUltragoalNudgeBudget(input.cwd);
+	const outcome = await recordUltragoalNudgeIfBudgetRemaining({
+		cwd: input.cwd,
+		sessionId,
+		target,
+		surface: input.surface,
+		budget,
+		reason: NUDGE_SURFACE_REASON[input.surface],
+		...(input.currentGoal?.objective ? { currentGoalObjective: input.currentGoal.objective } : {}),
+	});
+	if (outcome.nudged) {
+		return {
+			nudged: true,
+			message: formatUltragoalNudgeMessage({
+				surface: input.surface,
+				attempt: outcome.attempt,
+				budget: outcome.budget,
+				goalId: outcome.goalId,
+			}),
+		};
+	}
+	return { nudged: false };
+}
+
+/**
+ * Assert-path entry for the `ask` surface (the ask guard lives in another module).
+ * Resolves the active (leader) Ultragoal session so subagent/headless asks consume
+ * the leader run's budget rather than a fresh child ledger.
+ */
+export async function consumeUltragoalAskNudge(
+	cwd: string,
+	sessionId?: string | null,
+): Promise<{ nudged: true; message: string } | { nudged: false }> {
+	if (!cwd) return { nudged: false };
+	return consumeUltragoalNudge({ cwd, surface: "ask", sessionId });
+}
+
 export async function assertCanCompleteCurrentGoal(input: {
 	cwd: string;
 	currentGoal?: CurrentGoalLike | null;
@@ -502,6 +596,13 @@ export async function assertCanCompleteCurrentGoal(input: {
 	if (!input.cwd) return;
 	const diagnostic = await readUltragoalVerificationState(input);
 	if (["inactive", "unrelated_goal", "active_verified_complete"].includes(diagnostic.state)) return;
+	const nudge = await consumeUltragoalNudge({
+		cwd: input.cwd,
+		surface: "premature_complete",
+		currentGoal: input.currentGoal,
+		sessionId: input.sessionId,
+	});
+	if (nudge.nudged) throw new Error(nudge.message);
 	throw new Error(
 		`${diagnostic.message} Run strict \`gjc ultragoal checkpoint --status complete --quality-gate-json <file> --gjc-goal-json <file>\` first, or record review blockers and rerun verification.`,
 	);
@@ -558,6 +659,10 @@ export async function isUltragoalPauseBlocked(cwd: string): Promise<UltragoalPau
 }
 
 export async function assertUltragoalPauseAllowed(cwd: string): Promise<void> {
+	if (cwd) {
+		const nudge = await consumeUltragoalNudge({ cwd, surface: "pause" });
+		if (nudge.nudged) throw new Error(nudge.message);
+	}
 	const diagnostic = await isUltragoalPauseBlocked(cwd);
 	if (!diagnostic.blocked) return;
 	throw new Error(
@@ -568,3 +673,65 @@ export async function assertUltragoalPauseAllowed(cwd: string): Promise<void> {
 		].join("\n"),
 	);
 }
+/**
+ * Guard `goal({"op":"drop"})` during an active Ultragoal run. A *real give-up* (an
+ * aggregate run still mid-flight with incomplete required stories) is nudged while
+ * budget remains; once exhausted it falls through to today's drop behavior. Legitimate
+ * aggregate-reset drops — no durable run, unrelated goal, an already dropped/stale
+ * aggregate, or an all-stories-complete run — are never nudged. If durable state
+ * exists but cannot be read to classify the drop, fail closed.
+ */
+export async function assertUltragoalDropAllowed(input: {
+	cwd: string;
+	currentGoal?: CurrentGoalLike | null;
+	sessionId?: string | null;
+}): Promise<void> {
+	if (!input.cwd) return;
+	let paths: UltragoalPaths;
+	let sessionId: string | null;
+	try {
+		({ paths, sessionId } = await ultragoalReadPaths(input.cwd));
+	} catch (error) {
+		throw new Error(
+			`Unable to classify Ultragoal drop (durable state unreadable): ${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
+	if (sessionId === null) return;
+	try {
+		await fs.stat(paths.dir);
+	} catch (error) {
+		if (isEnoent(error)) return;
+		throw new Error(
+			`Unable to classify Ultragoal drop (durable state present but unreadable): ${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
+	let plan: UltragoalPlan | null;
+	try {
+		plan = await readUltragoalPlan(input.cwd, sessionId);
+	} catch (error) {
+		throw new Error(
+			`Unable to classify Ultragoal drop (goals.json unreadable): ${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
+	if (!plan) {
+		throw new Error("Unable to classify Ultragoal drop: durable state exists but goals.json is missing or empty.");
+	}
+	// Out of scope: per-story mode drops keep today's behavior.
+	if (plan.gjcGoalMode !== "aggregate") return;
+	// A real give-up requires an active aggregate goal to actually be abandoned. With no
+	// current goal-mode goal (or a non-active one), `drop` is a no-op/reset before a fresh
+	// `create`, never a give-up — so it is left un-nudged.
+	if (!input.currentGoal) return;
+	if (input.currentGoal.status !== "active") return;
+	// Unrelated active goal: not this aggregate run.
+	if (!objectiveMatches(input.currentGoal.objective, plan)) return;
+	// All required stories complete: a legitimate reset, not a give-up.
+	if (getUltragoalRunCompletionState(plan).allComplete) return;
+	const nudge = await consumeUltragoalNudge({
+		cwd: input.cwd,
+		surface: "drop",
+		currentGoal: input.currentGoal,
+		sessionId,
+	});
+	if (nudge.nudged) throw new Error(nudge.message);
+}