@gajae-code/coding-agent 0.7.6 → 0.7.7

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/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/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);
+}

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

@@ -1,4 +1,5 @@
 import * as crypto from "node:crypto";
+import * as os from "node:os";
 import * as path from "node:path";
 import { inflateSync } from "node:zlib";
 import { normalizeGoal } from "../goals/state";
@@ -11,7 +12,13 @@ import { gjcRoot, sessionUltragoalDir } from "./session-layout";
 import { resolveGjcSessionForRead, resolveGjcSessionForWrite, writeSessionActivityMarker } from "./session-resolution";
 import { renderUltragoalStatusMarkdown } from "./state-renderer";
 import { reconcileWorkflowSkillState } from "./state-runtime";
-import { appendJsonl, persistedStateRevision, writeArtifact, writeGuardedJsonAtomic } from "./state-writer";
+import {
+	appendJsonl,
+	persistedStateRevision,
+	withWorkflowStateLock,
+	writeArtifact,
+	writeGuardedJsonAtomic,
+} from "./state-writer";
 
 export type UltragoalGjcGoalMode = "aggregate" | "per-story";
 export type UltragoalGoalStatus =
@@ -80,6 +87,44 @@ export interface UltragoalLedgerEvent extends JsonObject {
 	timestamp?: string;
 }
 
+export type UltragoalNudgeSurface = "pause" | "drop" | "ask" | "premature_complete";
+export type UltragoalNudgeTargetKind = "story" | "final_aggregate_receipt";
+
+export interface UltragoalNudgeLedgerEvent extends UltragoalLedgerEvent {
+	event: "nudge";
+	goalId: string;
+	targetKind: UltragoalNudgeTargetKind;
+	surface: UltragoalNudgeSurface;
+	attempt: number;
+	budget: number;
+	reason: string;
+	currentGoalObjective?: string;
+}
+
+export interface UltragoalNudgeTarget {
+	goalId: string;
+	targetKind: UltragoalNudgeTargetKind;
+}
+
+export type UltragoalNudgeOutcome =
+	| {
+			nudged: true;
+			attempt: number;
+			budget: number;
+			goalId: string;
+			targetKind: UltragoalNudgeTargetKind;
+			event: UltragoalNudgeLedgerEvent;
+	  }
+	| {
+			nudged: false;
+			exhausted: true;
+			count: number;
+			budget: number;
+			goalId: string;
+			targetKind: UltragoalNudgeTargetKind;
+	  }
+	| { nudged: false; inactive: true; reason: string };
+
 export interface UltragoalPaths {
 	dir: string;
 	briefPath: string;
@@ -95,6 +140,11 @@ export interface UltragoalStatusSummary {
 	currentGoal?: UltragoalGoal;
 	counts: Record<UltragoalGoalStatus, number>;
 	goals: UltragoalGoal[];
+	nudgeBudget?: number;
+	nudgeCount?: number;
+	nudgeRemaining?: number;
+	nudgeGoalId?: string;
+	nudgeTargetKind?: UltragoalNudgeTargetKind;
 }
 
 export interface UltragoalCommandResult {
@@ -220,6 +270,156 @@ export async function readUltragoalLedger(cwd: string, sessionId?: string | null
 	}
 }
 
+export const DEFAULT_ULTRAGOAL_NUDGE_BUDGET = 10;
+
+/** Pure: count ledger `nudge` rows for an exact goalId. */
+export function countUltragoalNudges(ledger: readonly UltragoalLedgerEvent[], goalId: string): number {
+	return ledger.filter(event => event.event === "nudge" && event.goalId === goalId).length;
+}
+
+function parseNudgeBudgetValue(value: unknown): number | null {
+	return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= 0 ? value : null;
+}
+
+async function readSettingsNudgeBudget(settingsPath: string): Promise<number | null> {
+	try {
+		const raw = await Bun.file(settingsPath).text();
+		const parsed = JSON.parse(raw) as Record<string, unknown>;
+		// Support both the flat dotted key and a nested gjc.ultragoal.nudgeBudget shape.
+		const flat = parseNudgeBudgetValue(parsed["gjc.ultragoal.nudgeBudget"]);
+		if (flat !== null) return flat;
+		const gjc = parsed.gjc;
+		if (gjc && typeof gjc === "object") {
+			const ultragoal = (gjc as Record<string, unknown>).ultragoal;
+			if (ultragoal && typeof ultragoal === "object") {
+				return parseNudgeBudgetValue((ultragoal as Record<string, unknown>).nudgeBudget);
+			}
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Resolve the per-story nudge budget. Project `./.gjc/settings.json` overrides the
+ * user settings (`$GJC_CONFIG_DIR/settings.json` or `~/.gjc/settings.json`), else the
+ * default. Mirrors the `gjc.deepInterview.ambiguityThreshold` user+project precedence.
+ */
+export async function resolveUltragoalNudgeBudget(cwd: string): Promise<{ budget: number; source: string }> {
+	const projectPath = path.join(gjcRoot(cwd), "settings.json");
+	const project = await readSettingsNudgeBudget(projectPath);
+	if (project !== null) return { budget: project, source: projectPath };
+	const userDir = process.env.GJC_CONFIG_DIR?.trim() || path.join(os.homedir(), ".gjc");
+	const userPath = path.join(userDir, "settings.json");
+	const user = await readSettingsNudgeBudget(userPath);
+	if (user !== null) return { budget: user, source: userPath };
+	return { budget: DEFAULT_ULTRAGOAL_NUDGE_BUDGET, source: "default" };
+}
+
+/**
+ * Pure canonical selector shared by guards and status so `nudgeGoalId` can never
+ * diverge between what a guard consumes and what status displays. Prefers the active
+ * current-goal objective, then active > pending > failed (matching `chooseNextGoal`),
+ * then the aggregate final-receipt target when all stories are complete but the
+ * aggregate run still needs a final receipt. Returns null for verified-complete or
+ * absent/unrelated plans.
+ */
+export function selectUltragoalNudgeTarget(
+	plan: UltragoalPlan,
+	options: { currentGoalObjective?: string; retryFailed?: boolean } = {},
+): UltragoalNudgeTarget | null {
+	const objective = options.currentGoalObjective?.trim();
+	if (objective) {
+		const matched = plan.goals.find(
+			goal => goal.objective.trim() === objective && SCHEDULABLE_STATUSES.has(goal.status),
+		);
+		if (matched) return { goalId: matched.id, targetKind: "story" };
+	}
+	const next = chooseNextGoal(plan, options.retryFailed === true);
+	if (next) return { goalId: next.id, targetKind: "story" };
+	const completion = getUltragoalRunCompletionState(plan, { retryFailed: options.retryFailed });
+	if (completion.needsFinalAggregateReceipt) {
+		const required = requiredUltragoalGoals(plan);
+		const finalGoal = required.at(-1);
+		if (finalGoal) return { goalId: finalGoal.id, targetKind: "final_aggregate_receipt" };
+	}
+	return null;
+}
+
+/**
+ * Atomic consuming writer. Locks the ledger path, rereads + counts nudge rows for the
+ * target story, and appends exactly one `nudge` row inside the same critical section
+ * only while budget remains. Reuses the lockless `appendLedger` inside the lock (it
+ * does not acquire a conflicting lock), so concurrent guarded attempts cannot both
+ * observe `count = budget - 1` and overshoot the budget.
+ */
+export async function recordUltragoalNudgeIfBudgetRemaining(input: {
+	cwd: string;
+	sessionId?: string | null;
+	target: UltragoalNudgeTarget;
+	surface: UltragoalNudgeSurface;
+	budget: number;
+	reason: string;
+	currentGoalObjective?: string;
+}): Promise<UltragoalNudgeOutcome> {
+	const { cwd, sessionId, target, surface, budget, reason } = input;
+	if (!Number.isFinite(budget) || budget <= 0) {
+		return {
+			nudged: false,
+			exhausted: true,
+			count: 0,
+			budget: Math.max(0, budget | 0),
+			goalId: target.goalId,
+			targetKind: target.targetKind,
+		};
+	}
+	const resolvedSessionId =
+		sessionId?.trim() || resolveGjcSessionForWrite(cwd, { envSessionId: process.env.GJC_SESSION_ID }).gjcSessionId;
+	const paths = getUltragoalPaths(cwd, resolvedSessionId);
+	return withWorkflowStateLock(
+		paths.ledgerPath,
+		async () => {
+			const ledger = await readUltragoalLedger(cwd, resolvedSessionId);
+			const count = countUltragoalNudges(ledger, target.goalId);
+			if (count >= budget) {
+				return {
+					nudged: false,
+					exhausted: true,
+					count,
+					budget,
+					goalId: target.goalId,
+					targetKind: target.targetKind,
+				} as const;
+			}
+			const attempt = count + 1;
+			const entry = (await appendLedger(
+				cwd,
+				{
+					event: "nudge",
+					goalId: target.goalId,
+					targetKind: target.targetKind,
+					surface,
+					attempt,
+					budget,
+					reason,
+					...(input.currentGoalObjective ? { currentGoalObjective: input.currentGoalObjective } : {}),
+				},
+				resolvedSessionId,
+			)) as UltragoalNudgeLedgerEvent;
+			return {
+				nudged: true,
+				attempt,
+				budget,
+				goalId: target.goalId,
+				targetKind: target.targetKind,
+				event: entry,
+			} as const;
+		},
+		{ cwd },
+	);
+}
+
 async function writePlan(cwd: string, plan: UltragoalPlan, sessionId?: string | null): Promise<void> {
 	const resolvedSessionId =
 		sessionId?.trim() || resolveGjcSessionForWrite(cwd, { envSessionId: process.env.GJC_SESSION_ID }).gjcSessionId;
@@ -525,6 +725,20 @@ export async function getUltragoalStatus(cwd: string, sessionId?: string | null)
 	else if (counts.active > 0) status = "active";
 	else if (counts.failed > 0) status = "failed";
 	else if (counts.blocked > 0 || counts.review_blocked > 0) status = "blocked";
+	const nudgeTarget = selectUltragoalNudgeTarget(plan, { currentGoalObjective: currentGoal?.objective });
+	let nudgeFields: Partial<UltragoalStatusSummary> = {};
+	if (nudgeTarget) {
+		const { budget } = await resolveUltragoalNudgeBudget(cwd);
+		const ledger = await readUltragoalLedger(cwd, resolvedSessionId);
+		const nudgeCount = countUltragoalNudges(ledger, nudgeTarget.goalId);
+		nudgeFields = {
+			nudgeBudget: budget,
+			nudgeCount,
+			nudgeRemaining: Math.max(0, budget - nudgeCount),
+			nudgeGoalId: nudgeTarget.goalId,
+			nudgeTargetKind: nudgeTarget.targetKind,
+		};
+	}
 	return {
 		exists: true,
 		status,
@@ -533,6 +747,7 @@ export async function getUltragoalStatus(cwd: string, sessionId?: string | null)
 		currentGoal,
 		counts,
 		goals: plan.goals,
+		...nudgeFields,
 	};
 }
 export function buildUltragoalHudSummary(
@@ -3847,6 +4062,11 @@ async function reconcileUltragoalState(cwd: string): Promise<void> {
 			goals_path: summary.paths.goalsPath,
 		};
 		if (summary.gjcObjective) payload.gjc_objective = summary.gjcObjective;
+		if (summary.nudgeBudget !== undefined) payload.nudge_budget = summary.nudgeBudget;
+		if (summary.nudgeCount !== undefined) payload.nudge_count = summary.nudgeCount;
+		if (summary.nudgeRemaining !== undefined) payload.nudge_remaining = summary.nudgeRemaining;
+		if (summary.nudgeGoalId !== undefined) payload.nudge_goal_id = summary.nudgeGoalId;
+		if (summary.nudgeTargetKind !== undefined) payload.nudge_target_kind = summary.nudgeTargetKind;
 		const ledgerText = await Bun.file(summary.paths.ledgerPath)
 			.text()
 			.catch(() => "");

package/src/goals/tools/goal-tool.ts

@@ -4,7 +4,11 @@ import { Text } from "@gajae-code/tui";
 import { formatNumber, prompt } from "@gajae-code/utils";
 import * as z from "zod/v4";
 import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
-import { assertCanCompleteCurrentGoal, assertUltragoalPauseAllowed } from "../../gjc-runtime/ultragoal-guard";
+import {
+	assertCanCompleteCurrentGoal,
+	assertUltragoalDropAllowed,
+	assertUltragoalPauseAllowed,
+} from "../../gjc-runtime/ultragoal-guard";
 import type { Theme, ThemeColor } from "../../modes/theme/theme";
 import goalDescription from "../../prompts/tools/goal.md" with { type: "text" };
 import { formatDuration } from "../../slash-commands/helpers/format";
@@ -103,6 +107,15 @@ async function executeGoalOperation(session: ToolSession, params: GoalToolInput)
 		return buildGoalToolResponse(paused?.goal ?? null);
 	}
 	if (params.op === "drop") {
+		try {
+			await assertUltragoalDropAllowed({
+				cwd: session.cwd,
+				currentGoal: session.getGoalModeState?.()?.goal ?? null,
+				sessionId: session.getSessionId?.(),
+			});
+		} catch (error) {
+			throw new ToolError(error instanceof Error ? error.message : String(error));
+		}
 		const dropped = await runtime.dropGoal();
 		return buildGoalToolResponse(dropped ?? null);
 	}