@fyeeme/pi-goal 1.0.2 → 1.0.3

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+### 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`.)
+
 ## [1.0.2] - 2026-09-16
 
 ### Changed

package/index.ts

@@ -97,6 +97,7 @@ const goalModeContextPrompt = readFileSync(
 interface EntryMessageLike {
 	role?: string;
 	stopReason?: string;
+	errorMessage?: string;
 	usage?: { input?: number; output?: number; cacheRead?: number; cacheWrite?: number } | undefined;
 }
 
@@ -340,6 +341,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");
@@ -408,7 +426,9 @@ 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" },
 		);
 	}
@@ -425,6 +445,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 +526,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;
@@ -563,15 +593,51 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 		};
 	});
 
+	// 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 {
+			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;
+			}),
+		};
+	});
+
 	pi.on("agent_end", async (event, ctx) => {
 		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) {
@@ -665,6 +731,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,6 +1,6 @@
 {
 	"name": "@fyeeme/pi-goal",
-	"version": "1.0.2",
+	"version": "1.0.3",
 	"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.",
 	"type": "module",
 	"license": "MIT",

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,
@@ -222,6 +226,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);
@@ -295,6 +307,9 @@ describe("pi-goal extension wiring", () => {
 		expect(continuation).toBeDefined();
 		expect(continuation?.display).toBe(false);
 		expect(continuation?.options).toMatchObject({ triggerTurn: true, deliverAs: "followUp" });
+		// 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(continuation?.details).toMatchObject({ goalId });
 	});
 
 	it("suppresses the next continuation when a continuation turn produced no tool calls", async () => {
@@ -632,4 +647,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(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(0);
+	});
+
+	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" }));