@fyeeme/pi-goal 1.0.2 → 1.0.4

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [1.0.4] - 2026-10-01
+
+### Added
+
+- Objective length cap (`MAX_OBJECTIVE_CHARS`, 4,000 code points) enforced by the runtime on `create` and `replace` — the objective is re-injected into context on every continuation and passed to the evaluator subprocess, so an oversized one silently burns budget every turn; the error guides long instructions into a referenced file. Counting is code-point-based, not UTF-16 units. (Borrowed from mitsuhiko/agent-stuff `extensions/goal.ts`.)
+
+### Fixed
+
+- Print/json/rpc modes could never create a goal: `session_start` removed the `goal` tool from the active set when no goal existed (omp sdk.ts parity), but non-interactive modes have no `/goal` or `/guided-goal` command to re-arm it — leaving the model unable to start a goal at all (found via live goal-mode testing). The tool is now only removed in TUI mode.
+- The run that creates/resumes a goal via the tool never saw the goal context prompt: `before_agent_start` injection only fires on the next agent run, and the command-path steer was not wired to the tool path (found via live goal-mode testing). The tool now fires an `onActivated` hook so the host injects the goal context into the current run as a steer.
+- The evaluator subprocess ran with full extension discovery: any other installed goal extension (with an active-goal system prompt) would pollute the judge that is supposed to be independent, and the startup overhead contributed to live 300s timeouts. It now runs lean (`--no-extensions --no-skills`), the default timeout is raised to 600s, and `GOAL_EVALUATOR_TIMEOUT_MS` overrides it.
+
+### Changed
+
+- Context hygiene: hidden goal messages no longer accumulate in the LLM's view. A `context` handler keeps only the newest `goal-mode-context` and `goal-budget-limit` messages plus the newest `goal-continuation` stamped for the currently active goal id (`details.goalId`); stale ones — including all continuations once no goal is active — are dropped from the model's view, not from the transcript. (Borrowed from mitsuhiko/agent-stuff `extensions/goal.ts`.)
+- Run-error handling: when a run ends with an assistant `stopReason: "error"`, the active goal now pauses (persisted) instead of letting the continuation loop fire into a likely retry loop, with a classified notice — provider usage/rate/quota/limit errors read differently from generic faults. Abort behavior is unchanged. (Borrowed from mitsuhiko/agent-stuff `extensions/goal.ts`.)
+- Peer dependency floor raised to `@earendil-works/pi-coding-agent >= 0.99.0`; dev toolchain pinned to 0.99.2 (typecheck and tests pass against 0.99.2 unchanged).
+
 ## [1.0.2] - 2026-09-16
 
 ### Changed

package/index.ts

@@ -27,12 +27,18 @@
  *   goal_updated session event             → pi.events.emit("goal_updated")
  *   sendHiddenMessage (budget steer)       → pi.sendMessage display:false
  *   prompt-time prependMessages goal context
- *                                          → before_agent_start message
- *                                            injection (hidden custom message)
+ *                                          → context_with_system per-request
+ *                                            injection (0.87.0): survives
+ *                                            compaction, supersedes transcript
+ *                                            copies instead of accumulating
  *   #scheduleGoalContinuation 800ms TUI timer
- *                                          → followUp delivery + triggerTurn
- *                                            (editor-empty guard dropped: pi
- *                                            extensions cannot read the editor)
+ *                                          → agent_before_settle actionable
+ *                                            boundary (0.87.0):
+ *                                            { entries: [continuation draft],
+ *                                              continue: true } — exactly one
+ *                                            next provider request; sendMessage
+ *                                            fallback kept for continuations
+ *                                            withheld after settlement
  *   setActiveToolsByName                   → pi.setActiveTools
  *   status-line segment                    → ctx.ui.setStatus("goal", ...)
  *   settings goal.enabled / continuationModes / statusInFooter
@@ -59,7 +65,12 @@
 import { readFileSync } from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type {
+	ContextEditEntryDraft,
+	ExtensionAPI,
+	ExtensionContext,
+	SessionBoundaryDraft,
+} from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import {
 	createGoalCommand,
@@ -97,6 +108,7 @@ const goalModeContextPrompt = readFileSync(
 interface EntryMessageLike {
 	role?: string;
 	stopReason?: string;
+	errorMessage?: string;
 	usage?: { input?: number; output?: number; cacheRead?: number; cacheWrite?: number } | undefined;
 }
 
@@ -104,6 +116,34 @@ interface EntryUsageLike {
 	usage?: EntryMessageLike["usage"];
 }
 
+/** Budget slimming drafts (opt-in via PI_GOAL_SLIM_ON_BUDGET=1, attached once
+ *  per goal at the budget-limited flip): omit toolResult entries that precede
+ *  the newest real user message from future provider context via append-only
+ *  context-edit drafts — superseded turns' work products. Raw history, usage
+ *  and UI history stay untouched (context_edit contract). Pure: returns the
+ *  drafts; the settle boundary attaches them. */
+export function contextSlimDrafts(branch: unknown[]): ContextEditEntryDraft[] {
+	const drafts: ContextEditEntryDraft[] = [];
+	let keepFrom = -1;
+	for (let i = branch.length - 1; i >= 0; i--) {
+		const entry = branch[i] as { type?: string; message?: { role?: string } } | undefined;
+		if (entry?.type === "message" && entry.message?.role === "user") {
+			keepFrom = i;
+			break;
+		}
+	}
+	if (keepFrom <= 0) return drafts;
+	const seen = new Set<string>();
+	for (let i = 0; i < keepFrom; i++) {
+		const entry = branch[i] as { type?: string; id?: string; message?: { role?: string } } | undefined;
+		if (entry?.type !== "message" || entry.message?.role !== "toolResult") continue;
+		if (!entry.id || seen.has(entry.id)) continue;
+		seen.add(entry.id);
+		drafts.push({ type: "context_edit", targetId: entry.id, replacement: null });
+	}
+	return drafts;
+}
+
 export default function piGoalExtension(pi: ExtensionAPI): void {
 	// ------------------------------------------------------------------
 	// Closure state (omp session fields)
@@ -125,6 +165,10 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 	/** A blocking ctx.ui dialog is open (ui_prompt_start/end). While open, no
 	 *  continuation may fire: the modal would hide a turn starting behind it. */
 	let uiPromptOpen = false;
+	/** Goal id whose budget-limited flip already armed context slimming. */
+	let slimmedBudgetGoalId: string | undefined;
+	/** Context-slimming drafts pending attachment at the next settle boundary. */
+	let pendingSlim = false;
 
 	// ------------------------------------------------------------------
 	// Usage accounting (mirror of pi getSessionStats().tokens sums)
@@ -256,6 +300,14 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 			return;
 		}
 		goalState = state;
+		if (
+			state?.goal.status === "budget-limited" &&
+			process.env.PI_GOAL_SLIM_ON_BUDGET === "1" &&
+			slimmedBudgetGoalId !== state.goal.id
+		) {
+			slimmedBudgetGoalId = state.goal.id;
+			pendingSlim = true;
+		}
 		if (!state?.enabled) {
 			continuationInFlight = false;
 		}
@@ -340,6 +392,23 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 		await exitGoalMode({ reason: "paused" });
 	}
 
+	/** A provider/agent error ended the run (borrowed from mitsuhiko/agent-stuff
+	 *  goal.ts): pause the active goal instead of letting scheduleContinuation
+	 *  fire into a likely retry loop, and classify the failure for the user.
+	 *  Usage/rate/quota errors read differently from generic faults. */
+	async function pauseOnRunError(messages: unknown[]): Promise<void> {
+		if (!goalState?.enabled || goalState.goal.status !== "active") return;
+		const errorMessage = lastAssistantErrorMessage(messages) ?? "";
+		const usageLimited = /\b(usage|rate|quota|limit)\b/i.test(errorMessage);
+		await runtime.pauseGoal();
+		notify(
+			usageLimited
+				? "Goal paused: the last turn hit provider usage/rate limits. /goal resume when ready."
+				: "Goal paused: the last turn ended with an error. /goal resume to continue.",
+			"error",
+		);
+	}
+
 	async function dropGoal(): Promise<void> {
 		if (!goalState) {
 			notify("No goal to drop.", "warning");
@@ -398,7 +467,9 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 		return renderTemplate(goalModeContextPrompt, { goalContext: content, todoContext });
 	}
 
-	/** omp #scheduleGoalContinuation (TUI timer replaced by followUp delivery). */
+	/** omp #scheduleGoalContinuation. Post-settlement fallback path only: the
+	 *  primary continuation decision lives in the agent_before_settle boundary
+	 *  below (0.87.0). */
 	function scheduleContinuation(): void {
 		if (!goalState?.enabled || goalState.goal.status !== "active") return;
 		if (suppressNextContinuation) return;
@@ -408,11 +479,33 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 		if (!prompt) return;
 		continuationInFlight = true;
 		pi.sendMessage(
-			{ customType: "goal-continuation", content: prompt, display: false },
+			// details.goalId keys context pruning (see the "context" handler below):
+			// only the newest continuation of the CURRENTLY active goal survives.
+			{ customType: "goal-continuation", content: prompt, display: false, details: { goalId: goalState.goal.id } },
 			{ triggerTurn: true, deliverAs: "followUp" },
 		);
 	}
 
+	/** omp #scheduleGoalContinuation decision chain, settled into a draft:
+	 *  guards pass → one custom_message draft carrying the continuation
+	 *  prompt (details.goalId keys context pruning). */
+	function continuationDraft(ctx: ExtensionContext): SessionBoundaryDraft | undefined {
+		if (!goalState?.enabled || goalState.goal.status !== "active") return undefined;
+		if (suppressNextContinuation) return undefined;
+		if (uiPromptOpen) return undefined; // modal open: never start a turn behind it
+		if (ctx.hasPendingMessages()) return undefined;
+		const prompt = runtime.buildContinuationPrompt();
+		if (!prompt) return undefined;
+		continuationInFlight = true;
+		return {
+			type: "custom_message",
+			customType: "goal-continuation",
+			content: prompt,
+			display: false,
+			details: { goalId: goalState.goal.id },
+		};
+	}
+
 	// ------------------------------------------------------------------
 	// Tool + command registration
 	// ------------------------------------------------------------------
@@ -425,6 +518,11 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 		// fall back to the process cwd.
 		runEvaluator: (request, opts) =>
 			runGoalEvaluator(request, { cwd: opts.cwd ?? currentCtx?.cwd ?? process.cwd(), signal: opts.signal }),
+		// Mid-run activation (tool create/resume): inject the goal context into
+		// the CURRENT run as a steer — before_agent_start only covers the next run.
+		onActivated: async () => {
+			if (currentCtx && !currentCtx.isIdle()) await sendGoalModeContext("steer");
+		},
 	};
 	pi.registerTool(createGoalTool(goalToolDeps));
 
@@ -501,11 +599,16 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 		const restored = restoreGoalFromEntries(branch);
 		if (!restored) {
 			goalState = undefined;
-			// omp sdk.ts excludes the goal tool from the initial set; mirror that
-			// when this session has no goal to manage.
-			const active = pi.getActiveTools();
-			if (active.includes("goal")) {
-				pi.setActiveTools(active.filter((name) => name !== "goal"));
+			// omp sdk.ts excludes the goal tool from the initial set; mirror that in
+			// TUI where /goal and /guided-goal re-arm it. In non-interactive modes
+			// (print/json/rpc) no slash command exists, so removing the tool would
+			// leave the model unable to create a goal at all (found via live
+			// goal-mode testing): keep it active there.
+			if (ctx.mode === "tui") {
+				const active = pi.getActiveTools();
+				if (active.includes("goal")) {
+					pi.setActiveTools(active.filter((name) => name !== "goal"));
+				}
 			}
 			updateStatus();
 			return;
@@ -554,12 +657,59 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 		}
 	});
 
-	pi.on("before_agent_start", (_event, ctx) => {
+	// Goal context injection (0.87.0 context_with_system): runs after `context`
+	// handlers on the full transcript including system messages; the result is
+	// sent verbatim. Per-request injection survives compaction (re-applied every
+	// call) and the fresh copy supersedes any steer-injected transcript copies.
+	pi.on("context_with_system", (event, ctx) => {
 		currentCtx = ctx;
 		const content = buildGoalModeMessage();
 		if (!content) return undefined;
+		const messages = event.messages.filter((message) => {
+			const msg = message as { role?: string; customType?: string } | undefined;
+			return !(msg?.role === "custom" && msg.customType === "goal-mode-context");
+		});
+		messages.push({
+			role: "custom",
+			customType: "goal-mode-context",
+			content,
+			display: false,
+		} as (typeof event.messages)[number]);
+		return { messages };
+	});
+
+	// Context hygiene (borrowed from mitsuhiko/agent-stuff goal.ts): hidden goal
+	// messages otherwise accumulate one per run/continuation and burn context
+	// every LLM call. Keep only the newest goal-mode-context and
+	// goal-budget-limit, plus the newest continuation stamped for the currently
+	// active goal id; stale ones (including all continuations once no goal is
+	// active) are dropped from the model's view, not from the transcript.
+	pi.on("context", (event) => {
+		const activeGoalId = goalState?.enabled && goalState.goal.status === "active" ? goalState.goal.id : undefined;
+		let lastContext = -1;
+		let lastBudget = -1;
+		let lastContinuation = -1;
+		for (let i = 0; i < event.messages.length; i++) {
+			const msg = event.messages[i] as
+				| { role?: string; customType?: string; details?: { goalId?: string } }
+				| undefined;
+			if (msg?.role !== "custom") continue;
+			if (msg.customType === "goal-mode-context") lastContext = i;
+			else if (msg.customType === "goal-budget-limit") lastBudget = i;
+			else if (msg.customType === "goal-continuation" && activeGoalId !== undefined && msg.details?.goalId === activeGoalId) {
+				lastContinuation = i;
+			}
+		}
+		if (lastContext === -1 && lastBudget === -1 && lastContinuation === -1) return undefined;
 		return {
-			message: { customType: "goal-mode-context", content, display: false },
+			messages: event.messages.filter((message, index) => {
+				const msg = message as { role?: string; customType?: string } | undefined;
+				if (msg?.role !== "custom") return true;
+				if (msg.customType === "goal-mode-context") return index === lastContext;
+				if (msg.customType === "goal-budget-limit") return index === lastBudget;
+				if (msg.customType === "goal-continuation") return index === lastContinuation;
+				return true;
+			}),
 		};
 	});
 
@@ -567,11 +717,12 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 		currentCtx = ctx;
 		// omp separates onAgentEnd (session) from continuation scheduling
 		// (interactive-mode); both subscribe to the same end-of-run moment.
-		const aborted = lastAssistantStopReason(event.messages) === "aborted";
-		if (aborted) {
+		const stopReason = lastAssistantStopReason(event.messages);
+		if (stopReason === "aborted") {
 			await runtime.onTaskAborted({ reason: "interrupted" });
 		} else {
 			await runtime.onAgentEnd({ currentUsage: currentUsage(ctx) });
+			if (stopReason === "error") await pauseOnRunError(event.messages);
 		}
 
 		if (continuationInFlight) {
@@ -583,7 +734,31 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 			return;
 		}
 		updateStatus();
-		scheduleContinuation();
+	});
+
+	// omp #scheduleGoalContinuation migrated to the 0.87.0 actionable boundary:
+	// at settle time decide ONCE whether exactly one more provider request
+	// should run, attaching the continuation prompt as a custom_message draft.
+	// No timer, no followUp scheduling — pi owns the request. Guards mirror the
+	// old scheduleContinuation chain; continuations withheld after settlement
+	// (modal closed late, budget set while idle) still recover via the
+	// sendMessage fallback in scheduleContinuation().
+	pi.on("agent_before_settle", (_event, ctx) => {
+		currentCtx = ctx;
+		// Context slimming (opt-in): attach pending context_edit drafts first —
+		// they persist even when the continuation itself is withheld.
+		const drafts: SessionBoundaryDraft[] = [];
+		if (pendingSlim) {
+			pendingSlim = false;
+			drafts.push(...contextSlimDrafts(ctx.sessionManager.getBranch()));
+		}
+		const continuation = continuationDraft(ctx);
+		if (continuation) drafts.push(continuation);
+		if (drafts.length === 0) return undefined;
+		// Absent `continue` = no opinion on auto-continuation (budget-limited
+		// goals settle without one); `continue: true` guarantees exactly one
+		// next provider request.
+		return continuation !== undefined ? { entries: drafts, continue: true } : { entries: drafts };
 	});
 
 	pi.on("turn_end", (_event, ctx) => {
@@ -665,6 +840,14 @@ function lastAssistantStopReason(messages: unknown[]): string | undefined {
 	return undefined;
 }
 
+function lastAssistantErrorMessage(messages: unknown[]): string | undefined {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const message = messages[i] as EntryMessageLike | undefined;
+		if (message?.role === "assistant") return message.errorMessage;
+	}
+	return undefined;
+}
+
 export type { GoalRuntimeHost } from "./src/runtime.ts";
 // Re-exported for consumers that compose the pieces directly (tests, tools).
 export { GoalRuntime } from "./src/runtime.ts";

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@fyeeme/pi-goal",
-	"version": "1.0.2",
-	"description": "Goal mode for pi \u2014 one persistent autonomous objective looped until verified success: goal tool (create/get/complete/resume/drop), token/time budget accounting with budget-limit steering, automatic continuation turns, /goal and /guided-goal commands, and a goal_updated event bus for other extensions.",
+	"version": "1.0.4",
+	"description": "Goal mode for pi — one persistent autonomous objective looped until verified success: goal tool (create/get/complete/resume/drop), token/time budget accounting with budget-limit steering, automatic continuation turns, /goal and /guided-goal commands, and a goal_updated event bus for other extensions.",
 	"type": "module",
 	"license": "MIT",
 	"author": "fyeeme",
@@ -47,17 +47,17 @@
 		"typecheck": "tsc"
 	},
 	"peerDependencies": {
-		"@earendil-works/pi-ai": ">=0.84.4",
-		"@earendil-works/pi-coding-agent": ">=0.84.4",
-		"@earendil-works/pi-tui": ">=0.84.4",
+		"@earendil-works/pi-ai": ">=0.99.0",
+		"@earendil-works/pi-coding-agent": ">=0.99.0",
+		"@earendil-works/pi-tui": ">=0.99.0",
 		"typebox": ">=1.0.0",
-		"@earendil-works/pi-agent-core": "0.84.4"
+		"@earendil-works/pi-agent-core": "0.99.2"
 	},
 	"devDependencies": {
-		"@earendil-works/pi-agent-core": "0.84.4",
-		"@earendil-works/pi-ai": "0.84.4",
-		"@earendil-works/pi-coding-agent": "0.84.4",
-		"@earendil-works/pi-tui": "0.84.4",
+		"@earendil-works/pi-agent-core": "0.99.2",
+		"@earendil-works/pi-ai": "0.99.2",
+		"@earendil-works/pi-coding-agent": "0.99.2",
+		"@earendil-works/pi-tui": "0.99.2",
 		"@types/node": "22.19.19",
 		"typescript": "5.9.3",
 		"vitest": "3.2.7"

package/src/evaluator.ts

@@ -34,8 +34,16 @@ const evaluatorCompletePrompt = readFileSync(path.join(promptsDir, "evaluator-co
 const evaluatorImpossiblePrompt = readFileSync(path.join(promptsDir, "evaluator-impossible.md"), "utf8");
 
 /** Hard cap on one evaluator run — the grounded check may run test suites,
- *  so this is deliberately generous; anything longer has failed. */
-export const EVALUATOR_TIMEOUT_MS = 300_000;
+ *  so this is deliberately generous; anything longer has failed. Each LLM
+ *  call on slow providers can take 20s+, and the evaluator is a multi-step
+ *  agent (inspect repo, run checks, emit JSON), so the default needs real
+ *  headroom. Override with GOAL_EVALUATOR_TIMEOUT_MS. */
+export const EVALUATOR_TIMEOUT_MS = 600_000;
+
+function evaluatorTimeout(): number {
+	const raw = Number.parseInt(process.env.GOAL_EVALUATOR_TIMEOUT_MS ?? "", 10);
+	return Number.isInteger(raw) && raw > 0 ? raw : EVALUATOR_TIMEOUT_MS;
+}
 
 /** Argv-safety caps (kernel MAX_ARG_STRLEN ≈ 128KB; these keep the prompt
  *  argument far under it even for verbose objectives/audits). */
@@ -118,6 +126,16 @@ export function buildEvaluatorPrompt(request: GoalEvaluatorRequest): string {
 	});
 }
 
+/** Build the evaluator argv: a one-shot headless run. Lean flags matter here:
+ *  without them the nested pi loads the user's full extension set — including
+ *  any OTHER goal extension, whose active-goal system prompt would pollute the
+ *  very evaluator that is supposed to judge the goal independently — and its
+ *  startup cost pushes long verification runs over the timeout (observed
+ *  live: 300s timeout hit while the evaluator was still working). */
+function evaluatorInvocation(prompt: string): { command: string; args: string[] } {
+	return getPiInvocation(["-p", "--no-session", "--no-extensions", "--no-skills", prompt]);
+}
+
 /** Extract the first balanced JSON object from evaluator output. Handles the
  *  clean case, code-fenced output, and prose-wrapped JSON; anything else is
  *  unparseable. Never throws. */
@@ -181,10 +199,10 @@ export async function runGoalEvaluator(
 ): Promise<GoalEvaluatorOutcome> {
 	const prompt = buildEvaluatorPrompt(request);
 	const spawn = opts.spawn ?? defaultSpawn;
-	const timeoutMs = opts.timeoutMs ?? EVALUATOR_TIMEOUT_MS;
+	const timeoutMs = opts.timeoutMs ?? evaluatorTimeout();
 	let stdout: string;
 	try {
-		stdout = await spawn(getPiInvocation(["-p", "--no-session", prompt]), {
+		stdout = await spawn(evaluatorInvocation(prompt), {
 			cwd: opts.cwd,
 			timeoutMs,
 			signal: opts.signal,

package/src/runtime.ts

@@ -128,6 +128,25 @@ export function completionBudgetReport(goal: Goal): string | null {
 	return `Goal achieved. Report final budget usage to the user: ${parts.join("; ")}.`;
 }
 
+/** Objective length cap. The objective is re-injected into context on every
+ *  continuation and passed to the evaluator subprocess, so an oversized one
+ *  silently burns budget every turn. Borrowed from mitsuhiko/agent-stuff
+ *  goal.ts (MAX_OBJECTIVE_CHARS). */
+export const MAX_OBJECTIVE_CHARS = 4_000;
+
+function charCount(value: string): number {
+	return [...value].length;
+}
+
+function validateObjective(objective: string): void {
+	const count = charCount(objective);
+	if (count > MAX_OBJECTIVE_CHARS) {
+		throw new Error(
+			`Goal objective is too long: ${count.toLocaleString()} characters. Limit: ${MAX_OBJECTIVE_CHARS.toLocaleString()} characters. Put longer instructions in a file and reference that file in the objective.`,
+		);
+	}
+}
+
 function validateTokenBudget(tokenBudget: number | undefined): void {
 	if (tokenBudget !== undefined && (!Number.isInteger(tokenBudget) || tokenBudget <= 0)) {
 		throw new Error("goal token_budget must be a positive integer when provided");
@@ -408,6 +427,7 @@ export class GoalRuntime {
 	async createGoal(input: { objective: string; tokenBudget?: number }): Promise<GoalModeState> {
 		const objective = input.objective.trim();
 		if (!objective) throw new Error("objective is required when op=create");
+		validateObjective(objective);
 		validateTokenBudget(input.tokenBudget);
 		return await this.#withAccounting(async () => {
 			const existing = this.#host.getState();
@@ -425,6 +445,7 @@ export class GoalRuntime {
 	async replaceGoal(input: { objective: string; tokenBudget?: number }): Promise<GoalModeState> {
 		const objective = input.objective.trim();
 		if (!objective) throw new Error("objective is required when op=replace");
+		validateObjective(objective);
 		validateTokenBudget(input.tokenBudget);
 		return await this.#withAccounting(async () => {
 			const existing = this.#host.getState();

package/src/tool.ts

@@ -127,6 +127,11 @@ export interface GoalToolDeps {
 	/** Independent completion/impossibility evaluator (src/evaluator.ts).
 	 *  Gates `complete` and adjudicates `impossible`. */
 	runEvaluator: GoalEvaluatorFn;
+	/** Called after the tool ACTIVATES a goal mid-run (create/resume). The
+	 *  before_agent_start injection only fires on the next agent run, so
+	 *  without this hook the run that created the goal never sees the goal
+	 *  context prompt at all (observed live in print mode). */
+	onActivated?: () => Promise<void>;
 }
 
 function describeEvaluatorVerdict(verdict: string): string {
@@ -172,12 +177,14 @@ export function createGoalTool(deps: GoalToolDeps): ToolDefinition<typeof GoalPa
 			if (params.op === "create") {
 				const created = await runtime.createGoal(validateCreateParams(params));
 				response = buildGoalToolResponse(created.goal);
+				await deps.onActivated?.();
 			} else if (params.op === "get") {
 				const state = deps.getState();
 				response = buildGoalToolResponse(state?.goal ?? null);
 			} else if (params.op === "resume") {
 				const resumed = await runtime.resumeGoal();
 				response = buildGoalToolResponse(resumed.goal);
+				await deps.onActivated?.();
 			} else if (params.op === "drop") {
 				const dropped = await runtime.dropGoal();
 				response = buildGoalToolResponse(dropped ?? null);

package/test/evaluator.test.ts

@@ -15,7 +15,6 @@ import {
 	runGoalEvaluator,
 	type EvaluatorSpawn,
 } from "../src/evaluator.ts";
-
 function spawnReturning(stdout: string): { spawn: EvaluatorSpawn; calls: { args: string[]; cwd: string }[] } {
 	const calls: { args: string[]; cwd: string }[] = [];
 	return {
@@ -31,6 +30,38 @@ const COMPLETE_REQUEST = { mode: "complete" as const, objective: "Ship it", clai
 const IMPOSSIBLE_REQUEST = { mode: "impossible" as const, objective: "Ship it", claim: "no network access" };
 const RUN_OPTS = { cwd: "/tmp/repo" };
 
+describe("evaluator subprocess invocation", () => {
+	it("runs lean: no extensions, no skills (a nested goal extension would pollute the judge)", async () => {
+		const run = spawnReturning('{"ok": true}');
+		await runGoalEvaluator(COMPLETE_REQUEST, { ...RUN_OPTS, spawn: run.spawn });
+		const { args } = run.calls[0]!;
+		expect(args).toContain("--no-extensions");
+		expect(args).toContain("--no-skills");
+		// Prompt stays last (argv-safety caps rely on it).
+		expect(args.indexOf("--no-skills")).toBeLessThan(args.length - 1);
+	});
+
+	it("honors GOAL_EVALUATOR_TIMEOUT_MS over the default", async () => {
+		const run = spawnReturning('{"ok": true}');
+		const timeouts: number[] = [];
+		const previous = process.env.GOAL_EVALUATOR_TIMEOUT_MS;
+		process.env.GOAL_EVALUATOR_TIMEOUT_MS = "12345";
+		try {
+			await runGoalEvaluator(COMPLETE_REQUEST, {
+				...RUN_OPTS,
+				spawn: async (invocation, opts) => {
+					timeouts.push(opts.timeoutMs);
+					return run.spawn(invocation, opts);
+				},
+			});
+		} finally {
+			if (previous === undefined) delete process.env.GOAL_EVALUATOR_TIMEOUT_MS;
+			else process.env.GOAL_EVALUATOR_TIMEOUT_MS = previous;
+		}
+		expect(timeouts).toEqual([12_345]);
+	});
+});
+
 describe("extractJsonObject", () => {
 	it("parses a clean JSON object", () => {
 		expect(extractJsonObject('{"ok": true, "reason": "tests pass"}')).toEqual({

package/test/index.test.ts

@@ -36,6 +36,7 @@ interface FakeHost {
 		customType: string;
 		content: string;
 		display: boolean;
+		details?: unknown;
 		options?: { deliverAs?: string; triggerTurn?: boolean };
 	}>;
 	sentUserMessages: Array<{ content: string; options?: { deliverAs?: string } }>;
@@ -114,7 +115,10 @@ function fakeHost(): FakeHost {
 	return host;
 }
 
-function createContext(host: FakeHost, overrides: { entries?: unknown[]; pending?: boolean; idle?: boolean } = {}) {
+function createContext(
+	host: FakeHost,
+	overrides: { entries?: unknown[]; pending?: boolean; idle?: boolean; mode?: string } = {},
+) {
 	return {
 		ui: {
 			notify: (text: string) => {
@@ -130,7 +134,7 @@ function createContext(host: FakeHost, overrides: { entries?: unknown[]; pending
 			editor: async () => undefined,
 		},
 		hasUI: true,
-		mode: "tui",
+		mode: overrides.mode ?? "tui",
 		cwd: "/tmp",
 		isIdle: () => overrides.idle ?? true,
 		hasPendingMessages: () => overrides.pending ?? false,
@@ -148,6 +152,19 @@ async function fire(host: FakeHost, event: string, payload: unknown, ctx?: unkno
 	}
 }
 
+/** Fire agent_before_settle and return its boundary result. */
+function fireBeforeSettle(
+	host: FakeHost,
+	ctx?: unknown,
+): { continue?: boolean; entries?: Array<{ type: string; customType?: string; details?: unknown }> } | undefined {
+	const list = host.handlers.get("agent_before_settle") ?? [];
+	let result: unknown;
+	for (const handler of list) {
+		result = handler({ type: "agent_before_settle" }, ctx ?? createContext(host));
+	}
+	return result as { continue?: boolean; entries?: Array<{ type: string; customType?: string; details?: unknown }> } | undefined;
+}
+
 function fireBus(host: FakeHost, channel: string, data: unknown): void {
 	for (const handler of host.busHandlers.get(channel) ?? []) {
 		handler(data);
@@ -222,6 +239,14 @@ describe("pi-goal extension wiring", () => {
 		expect(host.activeTools).toContain("read");
 	});
 
+	it("session_start keeps the goal tool in non-interactive modes (no slash commands there)", async () => {
+		const host = fakeHost();
+		defaultExport(host.pi);
+		const ctx = createContext(host, { mode: "print" });
+		await fire(host, "session_start", { type: "session_start", reason: "startup" }, ctx);
+		expect(host.activeTools).toContain("goal");
+	});
+
 	it("session_start restores a persisted active goal, re-adds the tool, then pauses it (omp onThreadResumed)", async () => {
 		const host = fakeHost();
 		defaultExport(host.pi);
@@ -256,30 +281,52 @@ describe("pi-goal extension wiring", () => {
 		expect(host.statuses.get("goal")).toBe("🎯 Goal 0");
 	});
 
-	it("before_agent_start injects the hidden goal-mode-context message only while a goal is active", async () => {
+	it("context_with_system injects the goal-mode-context message only while a goal is active", async () => {
 		const host = fakeHost();
 		defaultExport(host.pi);
 		await fire(host, "session_start", { type: "session_start", reason: "startup" });
 
-		let result: unknown;
-		const handler = host.handlers.get("before_agent_start")?.[0];
-		result = await handler!({ prompt: "hi", systemPrompt: "" }, createContext(host));
+		const handler = host.handlers.get("context_with_system")?.[0]!;
+		const transcript = [{ role: "user", content: "hi" }];
+		let result = (await handler({ type: "context_with_system", messages: transcript }, createContext(host))) as
+			| { messages: Array<{ customType?: string; content?: string }> }
+			| undefined;
 		expect(result).toBeUndefined();
 
 		await host.commands.goal!.handler("Do the thing", createContext(host));
-		result = await handler!({ prompt: "hi", systemPrompt: "" }, createContext(host));
-		expect(result).toMatchObject({ message: { customType: "goal-mode-context", display: false } });
-		const content = (result as { message: { content: string } }).message.content;
-		expect(content).toContain("<goal_context>");
-		expect(content).toContain("Do the thing");
+		result = (await handler({ type: "context_with_system", messages: transcript }, createContext(host))) as
+			| { messages: Array<{ customType?: string; content?: string }> }
+			| undefined;
+		const contexts = result!.messages.filter((m) => m.customType === "goal-mode-context");
+		expect(contexts).toHaveLength(1);
+		expect(contexts[0]?.content).toContain("<goal_context>");
+		expect(contexts[0]?.content).toContain("Do the thing");
 	});
 
-	it("agent_end schedules a continuation when the goal is still active", async () => {
+	it("context_with_system supersedes steer-injected transcript copies (single fresh context)", async () => {
+		const host = fakeHost();
+		defaultExport(host.pi);
+		await fire(host, "session_start", { type: "session_start", reason: "startup" });
+		await host.commands.goal!.handler("Do the thing", createContext(host));
+
+		const handler = host.handlers.get("context_with_system")?.[0]!;
+		const transcript = [
+			{ role: "user", content: "hi" },
+			{ role: "custom", customType: "goal-mode-context", content: "stale copy", display: false },
+		];
+		const result = (await handler({ type: "context_with_system", messages: transcript }, createContext(host))) as {
+			messages: Array<{ customType?: string; content?: string }>;
+		};
+		const contexts = result.messages.filter((m) => m.customType === "goal-mode-context");
+		expect(contexts).toHaveLength(1);
+		expect(contexts[0]?.content).not.toBe("stale copy");
+	});
+
+	it("agent_before_settle continues exactly one request when the goal is still active", async () => {
 		const host = fakeHost();
 		defaultExport(host.pi);
 		await fire(host, "session_start", { type: "session_start", reason: "startup" });
 		await host.commands.goal!.handler("Do the thing", createContext(host));
-		host.sentMessages.length = 0;
 
 		await fire(host, "agent_start", { type: "agent_start" });
 		await fire(host, "tool_execution_end", {
@@ -291,10 +338,16 @@ describe("pi-goal extension wiring", () => {
 		});
 		await fire(host, "agent_end", { type: "agent_end", messages: [assistantMessage("toolUse")] });
 
-		const continuation = host.sentMessages.find((m) => m.customType === "goal-continuation");
-		expect(continuation).toBeDefined();
-		expect(continuation?.display).toBe(false);
-		expect(continuation?.options).toMatchObject({ triggerTurn: true, deliverAs: "followUp" });
+		const result = fireBeforeSettle(host);
+		expect(result?.continue).toBe(true);
+		// The continuation prompt rides as a custom_message draft.
+		const draft = result?.entries?.[0];
+		expect(draft).toMatchObject({ type: "custom_message", customType: "goal-continuation", display: false });
+		// details.goalId keys the context-pruning handler.
+		const goalId = (host.entries.find((e) => e.customType === GOAL_STATE_ENTRY_TYPE)?.data as { goal: Goal }).goal.id;
+		expect(draft?.details).toMatchObject({ goalId });
+		// The boundary path sends no followUp message.
+		expect(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(0);
 	});
 
 	it("suppresses the next continuation when a continuation turn produced no tool calls", async () => {
@@ -302,18 +355,16 @@ describe("pi-goal extension wiring", () => {
 		defaultExport(host.pi);
 		await fire(host, "session_start", { type: "session_start", reason: "startup" });
 		await host.commands.goal!.handler("Do the thing", createContext(host));
-		host.sentMessages.length = 0;
 
 		// Continuation turn: agent replies with no tool calls.
 		await fire(host, "agent_start", { type: "agent_start" });
 		await fire(host, "agent_end", { type: "agent_end", messages: [assistantMessage("stop")] });
-		expect(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(1);
+		expect(fireBeforeSettle(host)?.continue).toBe(true);
 
-		// That turn's end marks suppression: the following end schedules nothing.
-		host.sentMessages.length = 0;
+		// That turn's end marks suppression: the following settle continues nothing.
 		await fire(host, "agent_start", { type: "agent_start" });
 		await fire(host, "agent_end", { type: "agent_end", messages: [assistantMessage("stop")] });
-		expect(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(0);
+		expect(fireBeforeSettle(host)?.continue).toBeUndefined();
 
 		// A real user message re-arms the loop.
 		await fire(host, "message_start", { type: "message_start", message: { role: "user" } });
@@ -325,9 +376,8 @@ describe("pi-goal extension wiring", () => {
 			result: {},
 			isError: false,
 		});
-		host.sentMessages.length = 0;
 		await fire(host, "agent_end", { type: "agent_end", messages: [assistantMessage("stop")] });
-		expect(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(1);
+		expect(fireBeforeSettle(host)?.continue).toBe(true);
 	});
 
 	it("interrupt aborts pause the goal instead of continuing", async () => {
@@ -340,7 +390,7 @@ describe("pi-goal extension wiring", () => {
 		await fire(host, "agent_start", { type: "agent_start" });
 		await fire(host, "agent_end", { type: "agent_end", messages: [assistantMessage("aborted")] });
 
-		expect(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(0);
+		expect(fireBeforeSettle(host)?.continue).toBeUndefined();
 		// omp footer segment: pause icon + usage.
 		expect(host.statuses.get("goal")).toBe("⏸ Goal 0");
 		const pauseEntry = [...host.entries].reverse().find((e) => e.customType === GOAL_STATE_ENTRY_TYPE);
@@ -365,7 +415,7 @@ describe("pi-goal extension wiring", () => {
 		expect(host.entries.some((e) => e.customType === GOAL_CLEARED_ENTRY_TYPE)).toBe(true);
 		expect(host.notifications).toContain("Goal mode completed.");
 		expect(host.statuses.has("goal")).toBe(false);
-		expect(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(0);
+		expect(fireBeforeSettle(host)?.continue).toBeUndefined();
 	});
 
 	it("budget-limit steering sends one hidden steer message when usage crosses the budget", async () => {
@@ -428,6 +478,96 @@ describe("pi-goal extension wiring", () => {
 		expect(host.sentMessages.filter((m) => m.customType === "goal-budget-limit")).toHaveLength(0);
 	});
 
+	it("budget flip attaches context-slimming drafts when PI_GOAL_SLIM_ON_BUDGET=1", async () => {
+		const host = fakeHost();
+		defaultExport(host.pi);
+		await fire(host, "session_start", { type: "session_start", reason: "startup" });
+		await host.commands.goal!.handler("Do the thing", createContext(host));
+		await host.commands.goal!.handler("budget 10", createContext(host));
+
+		const entries: unknown[] = [
+			{ type: "message", id: "t-old", message: { role: "toolResult" } },
+			{ type: "message", id: "u1", message: { role: "user" } },
+			{ type: "message", id: "t-new", message: { role: "toolResult" } },
+		];
+		const ctx = createContext(host, { entries });
+
+		vi.stubEnv("PI_GOAL_SLIM_ON_BUDGET", "1");
+		await fire(host, "turn_start", { type: "turn_start", turnIndex: 0, timestamp: 0 }, ctx);
+		entries.push({
+			type: "message",
+			id: "m1",
+			message: { role: "assistant", stopReason: "toolUse", usage: { input: 25, output: 0, cacheRead: 0, cacheWrite: 0 } },
+		});
+		await fire(host, "tool_execution_end", {
+			type: "tool_execution_end",
+			toolCallId: "t1",
+			toolName: "read",
+			result: {},
+			isError: false,
+		}, ctx);
+
+		// Budget flip arms slimming; the boundary attaches the drafts.
+		// Budget-limited goals stop auto-continuing (omp semantics), so the
+		// boundary persists the edits without a next request.
+		const result = fireBeforeSettle(host, ctx);
+		expect(result?.continue).toBeUndefined();
+		const edits = (result?.entries ?? []).filter((e) => e.type === "context_edit");
+		expect(edits).toEqual([{ type: "context_edit", targetId: "t-old", replacement: null }]);
+
+		// Once per goal: the next settle carries no further slimming drafts.
+		entries.push({
+			type: "message",
+			id: "m2",
+			message: { role: "assistant", stopReason: "toolUse", usage: { input: 50, output: 0, cacheRead: 0, cacheWrite: 0 } },
+		});
+		await fire(host, "tool_execution_end", {
+			type: "tool_execution_end",
+			toolCallId: "t2",
+			toolName: "read",
+			result: {},
+			isError: false,
+		}, ctx);
+		expect(fireBeforeSettle(host, ctx)).toBeUndefined();
+		vi.unstubAllEnvs();
+	});
+
+	it("context slimming stays off by default (opt-in via PI_GOAL_SLIM_ON_BUDGET)", async () => {
+		const host = fakeHost();
+		defaultExport(host.pi);
+		await fire(host, "session_start", { type: "session_start", reason: "startup" });
+		await host.commands.goal!.handler("Do the thing", createContext(host));
+		await host.commands.goal!.handler("budget 10", createContext(host));
+
+		const entries: unknown[] = [
+			{ type: "message", id: "t-old", message: { role: "toolResult" } },
+			{ type: "message", id: "u1", message: { role: "user" } },
+			{ type: "message", id: "t-new", message: { role: "toolResult" } },
+		];
+		const ctx = createContext(host, { entries });
+
+		// Explicitly opt out (order-independent against leaking stubs).
+		vi.stubEnv("PI_GOAL_SLIM_ON_BUDGET", "");
+		await fire(host, "turn_start", { type: "turn_start", turnIndex: 0, timestamp: 0 }, ctx);
+		entries.push({
+			type: "message",
+			id: "m1",
+			message: { role: "assistant", stopReason: "toolUse", usage: { input: 25, output: 0, cacheRead: 0, cacheWrite: 0 } },
+		});
+		await fire(host, "tool_execution_end", {
+			type: "tool_execution_end",
+			toolCallId: "t1",
+			toolName: "read",
+			result: {},
+			isError: false,
+		}, ctx);
+
+		// Budget flip steers but arms no slimming drafts; budget-limited goals
+		// do not auto-continue, so the boundary settles empty.
+		expect(fireBeforeSettle(host, ctx)).toBeUndefined();
+		vi.unstubAllEnvs();
+	});
+
 	it("/guided-goal queues a hidden interview kickoff", async () => {
 		const host = fakeHost();
 		defaultExport(host.pi);
@@ -488,7 +628,8 @@ describe("pi-goal extension wiring", () => {
 
 		await fire(host, "agent_start", { type: "agent_start" });
 		await fire(host, "agent_end", { type: "agent_end", messages: [assistantMessage("stop")] });
-		expect(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(0);
+		// Modal open at settle: the boundary withholds the continuation.
+		expect(fireBeforeSettle(host)?.continue).toBeUndefined();
 
 		// Dialog closes while idle: the withheld continuation is scheduled now.
 		const idleCtx = createContext(host, { idle: true });
@@ -517,7 +658,8 @@ describe("pi-goal extension wiring", () => {
 		expect(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(0);
 
 		await fire(host, "agent_end", { type: "agent_end", messages: [assistantMessage("stop")] });
-		expect(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(1);
+		// Modal already closed: the boundary itself continues the run.
+		expect(fireBeforeSettle(host)?.continue).toBe(true);
 	});
 
 	it("refreshes the status on agent_settled (status integrations per docs)", async () => {
@@ -632,4 +774,77 @@ describe("pi-goal extension wiring", () => {
 		expect(component.text).toContain("6K (no budget) tokens");
 		expect(component.text).toContain("20s");
 	});
+
+	it("pauses the goal instead of continuing when the run ends with a provider error", async () => {
+		const host = fakeHost();
+		defaultExport(host.pi);
+		await fire(host, "session_start", { type: "session_start", reason: "startup" });
+		await host.commands.goal!.handler("Do the thing", createContext(host));
+		host.sentMessages.length = 0;
+
+		await fire(host, "agent_start", { type: "agent_start" });
+		await fire(host, "agent_end", {
+			type: "agent_end",
+			messages: [
+				{ role: "assistant", stopReason: "error", errorMessage: "429 rate limit exceeded", usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } },
+			],
+		});
+
+		// Paused and persisted, with a classified notice; no continuation queued.
+		const pauseEntry = [...host.entries].reverse().find((e) => e.customType === GOAL_STATE_ENTRY_TYPE);
+		expect(pauseEntry?.data).toMatchObject({ enabled: false, goal: { status: "paused" } });
+		expect(host.notifications.some((n) => n.includes("rate limits"))).toBe(true);
+		expect(fireBeforeSettle(host)?.continue).toBeUndefined();
+	});
+
+	it("pauses with a generic notice on non-usage errors", async () => {
+		const host = fakeHost();
+		defaultExport(host.pi);
+		await fire(host, "session_start", { type: "session_start", reason: "startup" });
+		await host.commands.goal!.handler("Do the thing", createContext(host));
+
+		await fire(host, "agent_start", { type: "agent_start" });
+		await fire(host, "agent_end", {
+			type: "agent_end",
+			messages: [
+				{ role: "assistant", stopReason: "error", errorMessage: "socket hang up", usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } },
+			],
+		});
+
+		expect(host.notifications.some((n) => n.includes("ended with an error"))).toBe(true);
+	});
+
+	it("context pruning keeps only the newest goal messages and drops stale continuations", async () => {
+		const host = fakeHost();
+		defaultExport(host.pi);
+		await fire(host, "session_start", { type: "session_start", reason: "startup" });
+		await host.commands.goal!.handler("Do the thing", createContext(host));
+		const goalId = (host.entries.find((e) => e.customType === GOAL_STATE_ENTRY_TYPE)?.data as { goal: Goal }).goal.id;
+
+		const custom = (customType: string, details?: unknown) => ({ role: "custom", customType, display: false, details });
+		const messages = [
+			{ role: "user", content: "hi" },
+			custom("goal-mode-context"), // stale context
+			custom("goal-continuation", { goalId: "old-goal" }), // stale goal id
+			custom("goal-budget-limit"),
+			custom("goal-mode-context"), // newest context: kept
+			custom("goal-continuation", { goalId }), // newest for the active goal: kept
+			{ role: "assistant", content: "working" },
+			custom("goal-continuation", { goalId: "old-goal" }), // another stale: dropped
+		];
+
+		const handler = host.handlers.get("context")?.[0]!;
+		const result = (await handler({ type: "context", messages }, createContext(host))) as { messages: unknown[] };
+		const kept = result.messages.filter((m) => (m as { role?: string }).role === "custom");
+		expect(kept.map((m) => (m as { customType: string }).customType)).toEqual([
+			"goal-budget-limit",
+			"goal-mode-context",
+			"goal-continuation",
+		]);
+
+		// Once no goal is active, every continuation is dropped.
+		await host.commands.goal!.handler("drop", createContext(host));
+		const result2 = (await handler({ type: "context", messages }, createContext(host))) as { messages: unknown[] };
+		expect(result2.messages.filter((m) => (m as { customType?: string }).customType === "goal-continuation")).toHaveLength(0);
+	});
 });

package/test/runtime.test.ts

@@ -468,4 +468,22 @@ describe("goal runtime", () => {
 		const second = await harness.runtime.createGoal({ objective: "Two" });
 		expect(first.goal.id).not.toBe(second.goal.id);
 	});
+
+	it("rejects objectives beyond the character cap on create and replace", async () => {
+		const harness = createHarness();
+		const oversized = "x".repeat(4_001);
+		await expect(harness.runtime.createGoal({ objective: oversized })).rejects.toThrow(/too long.*4,000/s);
+		// Boundary: exactly at the cap is fine.
+		await harness.runtime.createGoal({ objective: "x".repeat(4_000) });
+		// Replace path enforces the same cap.
+		await expect(harness.runtime.replaceGoal({ objective: oversized })).rejects.toThrow(/too long/);
+	});
+
+	it("counts characters as code points, not UTF-16 units", async () => {
+		const harness = createHarness();
+		// Astral emoji: 1 code point, 2 UTF-16 units. 2_001 emoji is 4_002 UTF-16
+		// units (a naive .length cap would reject it) but 2_001 code points: kept.
+		await expect(harness.runtime.createGoal({ objective: "😀".repeat(2_001) })).resolves.toBeDefined();
+		await expect(harness.runtime.createGoal({ objective: "😀".repeat(4_001) })).rejects.toThrow(/too long/);
+	});
 });

package/test/tool.test.ts

@@ -90,8 +90,14 @@ function stubEvaluator(outcome: GoalEvaluatorOutcome) {
 function createTestTool(
 	harness: ReturnType<typeof createRuntimeHarness>,
 	evaluator: (request: GoalEvaluatorRequest, opts: { cwd?: string }) => Promise<GoalEvaluatorOutcome>,
+	onActivated?: () => Promise<void>,
 ) {
-	return createGoalTool({ getRuntime: () => harness.runtime, getState: harness.getState, runEvaluator: evaluator });
+	return createGoalTool({
+		getRuntime: () => harness.runtime,
+		getState: harness.getState,
+		runEvaluator: evaluator,
+		onActivated,
+	});
 }
 
 // ---------------------------------------------------------------------------
@@ -99,6 +105,25 @@ function createTestTool(
 // ---------------------------------------------------------------------------
 
 describe("goal tool", () => {
+	it("onActivated hook fires on create and resume (mid-run context injection)", async () => {
+		const harness = createRuntimeHarness();
+		const activations: string[] = [];
+		const tool = createTestTool(
+			harness,
+			async () => ({ status: "confirmed", reason: "ok" }),
+			async () => {
+				activations.push("activated");
+			},
+		);
+		await executeTool(tool, { op: "create", objective: "Ship it" });
+		expect(activations).toHaveLength(1);
+		await executeTool(tool, { op: "resume" });
+		expect(activations).toHaveLength(2);
+		// get does not re-activate.
+		await executeTool(tool, { op: "get" });
+		expect(activations).toHaveLength(2);
+	});
+
 	it("create starts a goal and returns the objective/status text", async () => {
 		const harness = createRuntimeHarness();
 		const tool = createTestTool(harness, async () => ({ status: "confirmed", reason: "verified" }));