pi-goal-x 0.6.0

package/extensions/goal-auditor.ts

@@ -0,0 +1,341 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { Model } from "@earendil-works/pi-ai";
+import {
+	createAgentSession,
+	createExtensionRuntime,
+	SessionManager,
+	SettingsManager,
+	type ExtensionContext,
+	type ResourceLoader,
+} from "@earendil-works/pi-coding-agent";
+import type { GoalRecord } from "./goal-record.ts";
+
+export interface GoalAuditorConfig {
+	provider?: string;
+	model?: string;
+	thinkingLevel?: ThinkingLevel;
+	disabled?: boolean;
+}
+
+export interface AuditorProgress {
+	/** Current tool being executed by the auditor, if any */
+	currentTool?: string;
+	/** Arguments passed to the current tool (truncated for display) */
+	currentToolArgs?: string;
+	/** When the current tool started (ms since epoch) */
+	currentToolStartedAt?: number;
+	/** Recent text output lines from the auditor's assistant messages */
+	recentOutput: string[];
+	/** Phase of the audit */
+	phase: "running" | "tool_executing" | "producing_report" | "done";
+	/** Elapsed ms since audit started */
+	elapsedMs: number;
+}
+
+export type AuditorProgressCallback = (progress: AuditorProgress) => void;
+
+export interface GoalAuditorResult {
+	approved: boolean;
+	disapproved: boolean;
+	output: string;
+	model?: string;
+	thinkingLevel?: ThinkingLevel;
+	error?: string;
+}
+
+const THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh"]);
+
+export function goalAuditorConfigPath(cwd: string): string {
+	return path.join(cwd, ".pi", "goal-auditor.json");
+}
+
+function asNonEmptyString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function asThinkingLevel(value: unknown): ThinkingLevel | undefined {
+	const text = asNonEmptyString(value);
+	return text && THINKING_LEVELS.has(text) ? text as ThinkingLevel : undefined;
+}
+
+export function parseGoalAuditorConfig(raw: unknown): GoalAuditorConfig {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+	const record = raw as Record<string, unknown>;
+	const config: GoalAuditorConfig = {};
+	const provider = asNonEmptyString(record.provider);
+	const model = asNonEmptyString(record.model);
+	const thinkingLevel = asThinkingLevel(record.thinkingLevel ?? record.thinking_level);
+	if (provider) config.provider = provider;
+	if (model) config.model = model;
+	if (thinkingLevel) config.thinkingLevel = thinkingLevel;
+	if (record.disabled === true || record.disabled === "true") config.disabled = true;
+	return config;
+}
+
+export function loadGoalAuditorFileConfig(cwd: string): GoalAuditorConfig {
+	try {
+		const configPath = goalAuditorConfigPath(cwd);
+		if (fs.existsSync(configPath)) return parseGoalAuditorConfig(JSON.parse(fs.readFileSync(configPath, "utf8")));
+	} catch {
+		return {};
+	}
+	return {};
+}
+
+export function loadGoalAuditorConfig(cwd: string, env: NodeJS.ProcessEnv = process.env): GoalAuditorConfig {
+	const fileConfig = loadGoalAuditorFileConfig(cwd);
+	return {
+		...fileConfig,
+		provider: asNonEmptyString(env.PI_GOAL_AUDITOR_PROVIDER) ?? fileConfig.provider,
+		model: asNonEmptyString(env.PI_GOAL_AUDITOR_MODEL) ?? fileConfig.model,
+		thinkingLevel: asThinkingLevel(env.PI_GOAL_AUDITOR_THINKING_LEVEL ?? env.PI_GOAL_AUDITOR_THINKING) ?? fileConfig.thinkingLevel,
+	};
+}
+
+export function saveGoalAuditorFileConfig(cwd: string, config: GoalAuditorConfig): GoalAuditorConfig {
+	const clean: GoalAuditorConfig = {};
+	const provider = asNonEmptyString(config.provider);
+	const model = asNonEmptyString(config.model);
+	const thinkingLevel = asThinkingLevel(config.thinkingLevel);
+	if (provider) clean.provider = provider;
+	if (model) clean.model = model;
+	if (thinkingLevel) clean.thinkingLevel = thinkingLevel;
+	if (config.disabled === true) clean.disabled = true;
+	const configPath = goalAuditorConfigPath(cwd);
+	fs.mkdirSync(path.dirname(configPath), { recursive: true });
+	const persisted: Record<string, unknown> = {};
+	if (clean.provider) persisted.provider = clean.provider;
+	if (clean.model) persisted.model = clean.model;
+	if (clean.thinkingLevel) persisted.thinking_level = clean.thinkingLevel;
+	if (clean.disabled) persisted.disabled = true;
+	fs.writeFileSync(configPath, `${JSON.stringify(persisted, null, 2)}\n`, "utf8");
+	return clean;
+}
+
+export function parseAuditorDecision(output: string): { approved: boolean; disapproved: boolean } {
+	const approved = /<approved\s*\/>/.test(output);
+	const disapproved = /<disapproved\s*\/>/.test(output);
+	return { approved: approved && !disapproved, disapproved };
+}
+
+export function buildGoalAuditorPrompt(args: {
+	goal: GoalRecord;
+	completionSummary?: string | null;
+	detailedSummary: string;
+}): string {
+	return [
+		"You are the independent completion auditor for pi-goal.",
+		"The executor claims the goal is complete. Your job is to decide whether the user's objective is actually satisfied.",
+		"Be skeptical and semantic. Do not approve from paperwork, intent, file count, word count, build success, or a plausible summary alone.",
+		"Use read/grep/find/ls/bash as needed to inspect real artifacts. Do not mutate files or run destructive commands.",
+		"If the work is only an alpha scaffold, generated template, shallow draft, proxy milestone, or lacks the user-facing value requested, disapprove.",
+		"If any explicit requirement is missing, weakly verified, contradicted, or not inspectable with the available evidence, disapprove.",
+		"Return a concise audit report. The final line MUST be exactly one of:",
+		"<approved/>",
+		"<disapproved/>",
+		"",
+		"Goal objective:",
+		"<objective>",
+		args.goal.objective,
+		"</objective>",
+		"",
+		"Executor completion claim:",
+		"<completion_summary>",
+		args.completionSummary?.trim() || "(none provided)",
+		"</completion_summary>",
+		"",
+		"Current goal metadata:",
+		"<goal_details>",
+		args.detailedSummary,
+		"</goal_details>",
+		"",
+		"Audit checklist:",
+		"1. Extract the real success criteria from the objective, including quality/reader outcomes.",
+		"2. Inspect artifacts or command output that can prove or disprove those criteria.",
+		"3. Explain missing or weak evidence, especially scaffold-vs-final quality gaps.",
+		"4. End with exactly <approved/> only if the objective is truly complete; otherwise end with exactly <disapproved/>.",
+	].join("\n");
+}
+
+function makeAuditorResourceLoader(): ResourceLoader {
+	return {
+		getExtensions: () => ({ extensions: [], errors: [], runtime: createExtensionRuntime() }),
+		getSkills: () => ({ skills: [], diagnostics: [] }),
+		getPrompts: () => ({ prompts: [], diagnostics: [] }),
+		getThemes: () => ({ themes: [], diagnostics: [] }),
+		getAgentsFiles: () => ({ agentsFiles: [] }),
+		getSystemPrompt: () => [
+			"You are a read-only completion auditor running in an isolated pi agent session.",
+			"Inspect the repository and decide whether the claimed goal completion is genuinely satisfied.",
+			"Never modify files. Never approve unless the actual user objective is complete.",
+		].join("\n"),
+		getAppendSystemPrompt: () => [],
+		extendResources: () => {},
+		reload: async () => {},
+	};
+}
+
+function resolveAuditorModel(ctx: ExtensionContext, config: GoalAuditorConfig): { model: Model<any> | undefined; error?: string } {
+	if (!config.model && !config.provider) return { model: ctx.model };
+	if (config.provider && config.model) {
+		const model = ctx.modelRegistry.find(config.provider, config.model);
+		return model ? { model } : { model: undefined, error: `Configured auditor model not found: ${config.provider}/${config.model}` };
+	}
+	if (config.provider) {
+		const matches = ctx.modelRegistry.getAvailable().filter((model) => model.provider === config.provider);
+		return matches[0] ? { model: matches[0] } : { model: undefined, error: `No available auditor model for provider: ${config.provider}` };
+	}
+	if (!config.model) return { model: ctx.model };
+	const slash = config.model.indexOf("/");
+	if (slash > 0) {
+		const provider = config.model.slice(0, slash);
+		const modelId = config.model.slice(slash + 1);
+		const model = ctx.modelRegistry.find(provider, modelId);
+		return model ? { model } : { model: undefined, error: `Configured auditor model not found: ${config.model}` };
+	}
+	const matches = ctx.modelRegistry.getAvailable().filter((model) => model.id === config.model || model.name === config.model);
+	if (matches.length === 1) return { model: matches[0] };
+	return { model: undefined, error: `Configured auditor model is ambiguous or unavailable: ${config.model}` };
+}
+
+function modelLabel(model: Model<any> | undefined): string | undefined {
+	return model ? `${model.provider}/${model.id}` : undefined;
+}
+
+export async function runGoalCompletionAuditor(args: {
+	ctx: ExtensionContext;
+	goal: GoalRecord;
+	completionSummary?: string | null;
+	detailedSummary: string;
+	signal?: AbortSignal;
+	onProgress?: AuditorProgressCallback;
+	/**
+	 * Optional factory for creating the auditor agent session.
+	 * Exposed for testing so a mock/controllable session can be injected.
+	 * Defaults to the real createAgentSession from @earendil-works/pi-coding-agent.
+	 */
+	createSession?: typeof createAgentSession;
+}): Promise<GoalAuditorResult> {
+	const config = loadGoalAuditorConfig(args.ctx.cwd);
+	const resolved = resolveAuditorModel(args.ctx, config);
+	const model = resolved.model;
+	const thinkingLevel = config.thinkingLevel;
+	const outputParts: string[] = [];
+	if (resolved.error) {
+		return { approved: false, disapproved: true, output: "", model: modelLabel(model), thinkingLevel, error: resolved.error };
+	}
+	try {
+		const createSession = args.createSession ?? createAgentSession;
+		const { session } = await createSession({
+			cwd: args.ctx.cwd,
+			model,
+			thinkingLevel,
+			modelRegistry: args.ctx.modelRegistry,
+			resourceLoader: makeAuditorResourceLoader(),
+			sessionManager: SessionManager.inMemory(args.ctx.cwd),
+			settingsManager: SettingsManager.inMemory({ compaction: { enabled: false } }),
+			tools: ["read", "grep", "find", "ls", "bash"],
+		});
+		const startedAt = Date.now();
+		const progress: AuditorProgress = {
+			recentOutput: [],
+			phase: "running",
+			elapsedMs: 0,
+		};
+		function emitProgress(): void {
+			progress.elapsedMs = Date.now() - startedAt;
+			args.onProgress?.({ ...progress });
+		}
+		const unsubscribe = session.subscribe((event) => {
+			if (event.type === "tool_execution_start") {
+				progress.currentTool = event.toolName;
+				progress.currentToolArgs = typeof event.args === "object" && event.args !== null
+					? JSON.stringify(event.args).slice(0, 120)
+					: String(event.args ?? "").slice(0, 120);
+				progress.currentToolStartedAt = Date.now();
+				progress.phase = "tool_executing";
+				emitProgress();
+				return;
+			}
+			if (event.type === "tool_execution_end") {
+				progress.currentTool = undefined;
+				progress.currentToolArgs = undefined;
+				progress.currentToolStartedAt = undefined;
+				progress.phase = "running";
+				emitProgress();
+				return;
+			}
+			if (event.type === "message_update") {
+				progress.phase = "producing_report";
+				const message = event.message as any;
+				if (message?.role === "assistant") {
+					for (const part of message.content ?? []) {
+						if (part.type === "text" && typeof part.text === "string" && part.text.trim()) {
+							// Keep the last 5 non-empty text lines for live display
+							const lines = part.text.split("\n").filter((l: string) => l.trim());
+							progress.recentOutput = [...lines.slice(-5)];
+						}
+					}
+				}
+				emitProgress();
+				return;
+			}
+			if (event.type !== "message_end") return;
+			const message = event.message as any;
+			if (message.role !== "assistant") return;
+			for (const part of message.content ?? []) {
+				if (part.type === "text" && typeof part.text === "string") outputParts.push(part.text);
+			}
+			// Show the accumulated output in progress
+			const fullText = outputParts.join("\n\n");
+			const lines = fullText.split("\n").filter((l: string) => l.trim());
+			progress.recentOutput = lines.slice(-8);
+			emitProgress();
+		});
+		// Wire the external AbortSignal to abort the running session when fired
+		// This is the mechanism that makes Esc-to-skip actually stop the auditor.
+		const abortSession = () => { session.abort(); };
+		args.signal?.addEventListener("abort", abortSession, { once: true });
+
+		// Emit initial progress
+		emitProgress();
+		try {
+			if (args.signal?.aborted) return { approved: false, disapproved: true, output: "", model: modelLabel(model), thinkingLevel, error: "Auditor aborted." };
+			await session.prompt(buildGoalAuditorPrompt(args));
+		} finally {
+			args.signal?.removeEventListener("abort", abortSession);
+			progress.phase = "done";
+			emitProgress();
+			unsubscribe();
+		}
+		// session.abort() does NOT throw — the agent loop returns normally with
+		// whatever output was captured before the abort. Check the signal after
+		// prompt completes and treat any abort as auditor-aborted regardless of
+		// whether an exception propagated.
+		if (args.signal?.aborted) {
+			return {
+				approved: false,
+				disapproved: true,
+				output: outputParts.join("\n\n").trim(),
+				model: modelLabel(model),
+				thinkingLevel,
+				error: "Auditor aborted.",
+			};
+		}
+		const output = outputParts.join("\n\n").trim();
+		const decision = parseAuditorDecision(output);
+		return { ...decision, output, model: modelLabel(model), thinkingLevel };
+	} catch (error) {
+		const isAborted = args.signal?.aborted || (error instanceof Error && error.name === "AbortError");
+		return {
+			approved: false,
+			disapproved: true,
+			output: outputParts.join("\n\n").trim(),
+			model: modelLabel(model),
+			thinkingLevel,
+			error: isAborted ? "Auditor aborted." : (error instanceof Error ? error.message : String(error)),
+		};
+	}
+}

package/extensions/goal-compaction.ts

@@ -0,0 +1,124 @@
+import {
+  formatDuration,
+  formatTokenValue,
+  statusLabel,
+  truncateText,
+} from "./goal-core.ts";
+import {
+  latestAuditorResultForGoal,
+  latestEventsForGoal,
+  reconstructGoalLedger,
+  type GoalLedgerEvent,
+} from "./goal-ledger.ts";
+import { type GoalRecord } from "./goal-record.ts";
+
+export function buildGoalCompactSummary(goal: GoalRecord, events: GoalLedgerEvent[]): string {
+  const lines: string[] = [];
+  lines.push(`Goal ${goal.id} — ${statusLabel(goal)}`);
+  lines.push(`  Objective: ${truncateText(goal.objective, 200)}`);
+  if (goal.usage.tokensUsed > 0) {
+    lines.push(`  Usage: ${formatTokenValue(goal.usage.tokensUsed)}`);
+  }
+  if (goal.usage.activeSeconds > 0) {
+    lines.push(`  Time: ${formatDuration(goal.usage.activeSeconds)}`);
+  }
+
+  const recent = latestEventsForGoal(events, goal.id, 5);
+  if (recent.length > 0) {
+    lines.push("  Recent events:");
+    for (const event of recent) {
+      switch (event.type) {
+        case "goal_paused":
+          lines.push(`    - paused: ${event.reason}`);
+          break;
+        case "goal_resumed":
+          lines.push(`    - resumed: ${event.reason}`);
+          break;
+        case "goal_tweaked":
+          lines.push(`    - tweaked: ${event.changeSummary}`);
+          break;
+        case "completion_requested":
+          lines.push(`    - completion requested${event.summary ? `: ${truncateText(event.summary, 80)}` : ""}`);
+          break;
+        case "audit_result":
+          lines.push(`    - auditor ${event.verdict}${event.verdict === "disapproved" ? `: ${truncateText(event.report, 80)}` : ""}`);
+          break;
+        case "goal_completed":
+          lines.push("    - completed");
+          break;
+        case "goal_aborted":
+          lines.push(`    - aborted: ${event.reason}`);
+          break;
+        default:
+          break;
+      }
+    }
+  }
+
+  const auditor = latestAuditorResultForGoal(events, goal.id);
+  if (auditor && auditor.verdict === "disapproved") {
+    lines.push(`  Auditor rejection (latest): ${truncateText(auditor.report, 120)}`);
+  }
+
+  if (goal.pauseReason) {
+    lines.push(`  Pause reason: ${goal.pauseReason}`);
+  }
+  if (goal.pauseSuggestedAction) {
+    lines.push(`  Suggested action: ${goal.pauseSuggestedAction}`);
+  }
+
+  return lines.join("\n");
+}
+
+export function buildCompactionSummary(args: {
+  goalsById: Map<string, GoalRecord>;
+  focusedGoalId: string | null;
+  ledgerEvents: GoalLedgerEvent[];
+  capOpenGoals?: number;
+  capEventsPerGoal?: number;
+}): string {
+  const { goalsById, focusedGoalId, ledgerEvents, capOpenGoals = 20, capEventsPerGoal = 5 } = args;
+
+  const lines: string[] = [];
+  const openGoals = Array.from(goalsById.values()).filter((g) => g.status !== "complete");
+  const reconstructed = reconstructGoalLedger(ledgerEvents);
+
+  if (focusedGoalId && goalsById.has(focusedGoalId)) {
+    const focused = goalsById.get(focusedGoalId)!;
+    lines.push(`[FOCUSED GOAL]`);
+    lines.push(buildGoalCompactSummary(focused, latestEventsForGoal(ledgerEvents, focusedGoalId, capEventsPerGoal)));
+    lines.push("");
+  }
+
+  const otherOpen = openGoals.filter((g) => g.id !== focusedGoalId);
+  if (otherOpen.length > 0) {
+    lines.push(`[OTHER OPEN GOALS — ${otherOpen.length} total]`);
+    for (const goal of otherOpen.slice(0, capOpenGoals)) {
+      lines.push(`- ${goal.id} — ${statusLabel(goal)} — ${truncateText(goal.objective, 120)}`);
+    }
+    if (otherOpen.length > capOpenGoals) {
+      lines.push(`... and ${otherOpen.length - capOpenGoals} more`);
+    }
+    lines.push("");
+  }
+
+  if (reconstructed.terminalGoals.size > 0) {
+    lines.push(`[TERMINAL GOALS — ${reconstructed.terminalGoals.size} completed or aborted]`);
+    for (const [goalId, state] of reconstructed.terminalGoals) {
+      const label = state.latestStatus === "complete" ? "completed" : "aborted";
+      lines.push(`- ${goalId} — ${label}${state.completedAt ? ` at ${state.completedAt}` : ""}${state.abortedAt ? ` at ${state.abortedAt}` : ""}`);
+    }
+    lines.push("");
+  }
+
+  if (openGoals.length === 0 && reconstructed.terminalGoals.size === 0) {
+    lines.push("[NO GOALS]");
+    lines.push("No open or terminal goals recorded in this session.");
+  }
+
+  lines.push("[INSTRUCTION]");
+  lines.push("Continue from the focused goal above, or ask the user to run /goals, /goals-set, or /goal-focus.");
+  lines.push("Do not rely on chat memory for goal state; use the facts above.");
+
+  return lines.join("\n");
+}

package/extensions/goal-core.ts

@@ -0,0 +1,77 @@
+export interface GoalUsageLike {
+	tokensUsed: number;
+	activeSeconds: number;
+}
+
+export interface GoalDisplayRecordLike {
+	objective: string;
+	status: "active" | "paused" | "complete";
+	autoContinue: boolean;
+	usage: GoalUsageLike;
+	sisyphus: boolean;
+	stopReason?: "user" | "agent";
+}
+
+export { isQuestionLikeToolName } from "./goal-tool-names.ts";
+
+
+export function truncateText(value: string, max = 120): string {
+	const oneLine = value.replace(/\s+/g, " ").trim();
+	return oneLine.length > max ? `${oneLine.slice(0, max - 3)}...` : oneLine;
+}
+
+export function displayObjectiveTitle(objective: string): string {
+	const lines = objective.replace(/\r/g, "").split("\n").map((line) => line.trim()).filter(Boolean);
+	const sectionHeader = /^(success criteria|boundaries|constraints|steps|order rules|don'ts|if blocked|if blocked \/ unclear \/ failing|sisyphus reminder)\s*[:：]/i;
+	for (const line of lines) {
+		if (/^=+\s*(?:sisyphus\s+)?goal\s*=+$/i.test(line)) continue;
+		const objectiveMatch = line.match(/^(?:objective|目标)\s*[:：]\s*(.+)$/i);
+		if (objectiveMatch?.[1]) return objectiveMatch[1].trim();
+		if (sectionHeader.test(line)) continue;
+		return line;
+	}
+	return truncateText(objective);
+}
+
+export function formatTokenValue(value: number): string {
+	const safe = Math.max(0, Math.floor(value));
+	const compact =
+		safe >= 1_000_000_000
+			? `${(safe / 1_000_000_000).toFixed(safe >= 10_000_000_000 ? 0 : 1).replace(/\.0$/, "")}B`
+			: safe >= 1_000_000
+				? `${(safe / 1_000_000).toFixed(safe >= 10_000_000 ? 0 : 1).replace(/\.0$/, "")}M`
+				: safe >= 10_000
+					? `${(safe / 1_000).toFixed(0)}K`
+					: safe >= 1_000
+						? `${(safe / 1_000).toFixed(1).replace(/\.0$/, "")}K`
+						: String(safe);
+	const exact = safe.toLocaleString("en-US");
+	if (compact === exact) return `${exact} tokens`;
+	return `${compact} (${exact}) tokens`;
+}
+
+export function formatDuration(seconds: number): string {
+	const total = Math.max(0, Math.floor(seconds));
+	const hours = Math.floor(total / 3600);
+	const minutes = Math.floor((total % 3600) / 60);
+	const secs = total % 60;
+	if (hours > 0) return `${hours}h${minutes.toString().padStart(2, "0")}m${secs.toString().padStart(2, "0")}s`;
+	if (minutes > 0) return `${minutes}m${secs.toString().padStart(2, "0")}s`;
+	return `${secs}s`;
+}
+
+export function statusLabel(goal: Pick<GoalDisplayRecordLike, "sisyphus" | "status" | "autoContinue" | "stopReason">): string {
+	const prefix = goal.sisyphus ? "sisyphus " : "";
+	if (goal.status === "active" && goal.autoContinue) return `${prefix}running`;
+	if (goal.status === "paused" && goal.stopReason === "agent") return `${prefix}paused (agent)`;
+	return `${prefix}${goal.status}`;
+}
+
+export function footerStatus(goal: GoalDisplayRecordLike): string {
+	const usageBits: string[] = [];
+	if (goal.usage.activeSeconds > 0) usageBits.push(formatDuration(goal.usage.activeSeconds));
+	if (goal.usage.tokensUsed > 0) usageBits.push(formatTokenValue(goal.usage.tokensUsed).split(" ")[0]);
+	const usage = usageBits.length > 0 ? ` [${usageBits.join(" ")}]` : "";
+	const prefix = goal.sisyphus ? "goal✊" : "goal";
+	return `${prefix}: ${statusLabel(goal)}${usage} - ${truncateText(goal.objective, 60)}`;
+}

package/extensions/goal-draft.ts

@@ -0,0 +1,148 @@
+export type GoalDraftingFocus = "goal" | "sisyphus";
+
+export interface GoalConfirmationIntentLike {
+	focus: GoalDraftingFocus;
+	originalTopic: string;
+	startedAt?: number;
+}
+
+export interface DraftProposalInput {
+	intent: GoalConfirmationIntentLike | null;
+	hasUnfinishedGoal: boolean;
+	objective: string;
+	sisyphus?: boolean;
+	draftId?: string;
+}
+
+export type DraftProposalValidation =
+	| { ok: true; objective: string; expectedSisyphus: boolean }
+	| { ok: false; message: string; clearDrafting?: boolean };
+
+export type ToolGateDecision =
+	| { block: false }
+	| { block: true; reason: string };
+
+export function promptSafeObjective(objective: string): string {
+	return objective.replace(/<\/?untrusted_objective>/gi, (tag) => tag.replace(/</g, "&lt;").replace(/>/g, "&gt;"));
+}
+
+export function buildDraftConfirmationText(args: {
+	focus: GoalDraftingFocus;
+	originalTopic: string;
+	objective: string;
+	autoContinue: boolean;
+}): string {
+	const lines: string[] = [];
+	const modeLabel = args.focus === "sisyphus" ? "Sisyphus (prompt/criteria style)" : "Normal goal";
+	lines.push("Goal draft ready for confirmation.");
+	lines.push("");
+	lines.push("Draft details:");
+	lines.push(`Mode: ${modeLabel}`);
+	lines.push(`Auto-continue: ${args.autoContinue ? "yes" : "no"}`);
+	lines.push("");
+	lines.push("Original topic:");
+	lines.push("");
+	lines.push(args.originalTopic.trim());
+	lines.push("");
+	lines.push("Proposed goal:");
+	lines.push("");
+	lines.push(args.objective);
+	return lines.join("\n");
+}
+
+export function evaluateDraftingToolGate(args: {
+	toolName: string;
+	draftingFocus?: GoalDraftingFocus | null;
+	tweakDraftingGoalId?: string | null;
+	activeGoalId?: string | null;
+	proposeToolName?: string;
+	tweakApplyToolName?: string;
+	getGoalToolName?: string;
+}): ToolGateDecision {
+	// Goal confirmation is prompt-guided, not runtime-enforced. The agent should
+	// avoid substantive work before confirmation, but minimal reconnaissance is allowed.
+	void args;
+	return { block: false };
+}
+
+export function validateGoalDraftProposal(input: DraftProposalInput): DraftProposalValidation {
+	if (input.intent === null) {
+		return {
+			ok: false,
+			message: "propose_goal_draft REJECTED: no /goals or /sisyphus intent discussion is in progress. Tell the user to invoke /goals <topic> or /sisyphus <topic> first, or use /goals-set / /sisyphus-set for immediate creation.",
+		};
+	}
+
+	const expectedSisyphus = input.intent.focus === "sisyphus";
+	const actualSisyphus = input.sisyphus === true;
+	if (actualSisyphus !== expectedSisyphus) {
+		return {
+			ok: false,
+			message: `propose_goal_draft REJECTED (focus gate): confirmation focus is "${input.intent.focus}" (user invoked ${input.intent.focus === "sisyphus" ? "/sisyphus" : "/goals"}) but you passed sisyphus=${actualSisyphus}. Set sisyphus=${expectedSisyphus} to match the user's choice, then retry. Do NOT change the user's mode autonomously.`,
+		};
+	}
+
+	const objective = input.objective.trim();
+	if (!objective) {
+		return { ok: false, message: "propose_goal_draft REJECTED: objective is empty." };
+	}
+
+	return { ok: true, objective, expectedSisyphus };
+}
+
+export function goalDraftingPrompt(topic: string, focus: GoalDraftingFocus): string {
+	const safeTopic = promptSafeObjective(topic.trim() || "(no topic provided — ask the user what they want to accomplish)");
+	const header = focus === "sisyphus"
+		? "[GOAL CONFIRMATION focus=sisyphus]\nThe user invoked Sisyphus intent discussion (/sisyphus). Help turn their request into a confirmed goal contract. Do NOT start substantive work yet."
+		: "[GOAL CONFIRMATION focus=goal]\nThe user invoked goal intent discussion (/goals). Help turn their request into a confirmed goal contract. Do NOT start substantive work yet.";
+
+	const commonProtocol = [
+		"Confirmation protocol:",
+		"- Treat this as a lightweight conversation with the user, not a separate long-running runtime phase.",
+		"- If the topic is vague, ask one focused question with a recommended default. Use goal_question or goal_questionnaire when a structured answer would help, but plain conversation is acceptable.",
+		"- Targeted read-only research is allowed when it helps define a better goal contract; do not start implementation before confirmation.",
+		"- If the topic is already concrete, you may proceed directly to propose_goal_draft.",
+		"- The goal contract should make the objective, success criteria, boundaries, constraints, and blocker rule explicit.",
+		"- Keep grilling assumptions until the objective, success criteria, boundaries, constraints, and blocker rule are clear enough to confirm.",
+		"- propose_goal_draft opens the user's Confirm / Continue Chatting dialog. Confirm creates and focuses the goal; Continue Chatting means keep clarifying.",
+		"- create_goal is not a shortcut. Direct create_goal calls are rejected so the user keeps explicit say in goal creation.",
+	];
+
+	const goalFocusItems = [
+		"For /goals, propose a normal goal in this shape when ready:",
+		"=== Goal ===",
+		"Objective: <one-sentence outcome>",
+		"Success criteria: <observable evidence the goal is done>",
+		"Boundaries: <in scope / out of scope>",
+		"Constraints: <hard rules>",
+		"If blocked: <default = stop and ask the user>",
+		"Call propose_goal_draft with sisyphus=false and autoContinue=true unless the user asked otherwise.",
+	];
+
+	const sisyphusFocusItems = [
+		"For /sisyphus, remember that Sisyphus is a prompt/criteria style, not a separate step-counter mechanism.",
+		"Propose a Sisyphus goal in this shape when ready:",
+		"=== Sisyphus Goal ===",
+		"Objective: <one-sentence outcome>",
+		"Success criteria: <observable evidence the whole ordered goal is done>",
+		"Boundaries: <in scope / out of scope>",
+		"Constraints: <hard rules, files not to touch, etc.>",
+		"Ordered steps: <preserve the user's requested steps and ordering; do not add preflight or reconnaissance steps they did not ask for>",
+		"If blocked / unclear / failing: <default = stop and ask the user>",
+		"Sisyphus reminder: Work patiently and sequentially. No rushing, no unrequested preflight steps, no improvising around blockers.",
+		"Call propose_goal_draft with sisyphus=true and autoContinue=true unless the user asked otherwise.",
+	];
+
+	return [
+		header,
+		"",
+		"Topic the user provided:",
+		"<goal_topic>",
+		safeTopic,
+		"</goal_topic>",
+		"",
+		...commonProtocol,
+		"",
+		...(focus === "sisyphus" ? sisyphusFocusItems : goalFocusItems),
+	].join("\n");
+}