pi-goal-x 0.31.0 → 0.31.1

package/README.md

@@ -35,6 +35,12 @@ Sisyphus goals work well for migrations, staged refactors, release procedures, d
 
 The `/goal` and `/sisyphus` commands start a guided drafting process. The agent can ask focused questions, clarify the objective, and propose a task plan for confirmation.
 
+RPC and browser hosts use native select/input dialogs when the terminal overlay is unavailable. Questions retain their context, and proposal confirmation includes a choice of completion auditor. Cancelling or losing a dialog never confirms an unseen proposal; the draft stays available.
+
+When used with `pi-subagents`, goal mode stays in the parent session. Fresh, forked, resumed, and nested children inherit their assignment context without goal tools, goal state writes, or automatic goal continuations. Ordinary interactive forks retain goal mode.
+
+Audit progress remains visible in the dashboard. Audit transcript messages appear after the agent settles and are excluded from model input; existing sessions containing interleaved audit events can resume after loading the updated extension, without rewriting their history.
+
 The proposal is written to the conversation as a durable summary (objective, plan, verification, automatic continuation, auditor state); confirming it creates and focuses the goal and starts working automatically.
 
 ### Direct goal creation

package/extensions/goal-completion.ts

@@ -1,5 +1,5 @@
 import { type AgentToolResult, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { GOAL_AUDIT_ENTRY, detailedSummary, goalDetails, type GoalAuditEventDetails } from "./goal-format.ts";
+import { GOAL_AUDIT_ENTRY, detailedSummary, goalDetails } from "./goal-format.ts";
 import {
 	buildCompletionReport,
 	buildTaskSummary,
@@ -22,7 +22,6 @@ import type { GoalMutationOutcome } from "./goal-service.ts";
 // actual workspace evidence. An optional completion_summary is forwarded as an
 // UNTRUSTED executor claim — never evidence and never an approval bypass.
 export async function runGoalCompletionFlow(core: GoalCore, ctx: ExtensionContext, completionSummary?: string): Promise<AgentToolResult<unknown>> {
-	const { pi } = core;
  const flushError = core.goalService.flushForAudit(ctx);
  if (flushError) return {content: [{type: "text", text: flushError}], details: goalDetails(core.state.goal)};
 	core.reconcileFocusedGoalFromDisk(ctx);
@@ -131,7 +130,7 @@ function commitGoalCompletion(core: GoalCore, ctx: ExtensionContext, opts: {
 // records remain readable and honored for compatibility; no model tool or
 // task dialog creates new per-goal bypass state).
 if (auditTarget.skipAuditor) {
-	pi.sendMessage<GoalAuditEventDetails>({
+	core.auditMessages.enqueue(ctx, {
 		customType: GOAL_AUDIT_ENTRY,
 		content: `Goal completed — per-goal auditor disabled.`,
 		display: true,
@@ -161,7 +160,7 @@ if (auditTarget.skipAuditor) {
 // the auditor, records audit_skipped, and proceeds through the normal
 // deferred-completion path. No model-side bypass flag is required.
 if (settings.disabled === true) {
-	pi.sendMessage<GoalAuditEventDetails>({
+	core.auditMessages.enqueue(ctx, {
 		customType: GOAL_AUDIT_ENTRY,
 		content: `Goal completed — auditor disabled in settings.`,
 		display: true,
@@ -188,7 +187,7 @@ if (settings.disabled === true) {
 }
 
 	// Auditor is enabled — run the normal audit flow
-	await pi.sendMessage<GoalAuditEventDetails>({
+	core.auditMessages.enqueue(ctx, {
 		customType: GOAL_AUDIT_ENTRY,
 		content: [
 			"Auditor: I am starting the independent completion audit.",
@@ -197,7 +196,7 @@ if (settings.disabled === true) {
 		].filter((line): line is string => line !== undefined).join("\n"),
 		display: true,
 		details: { phase: "started", goalId: auditTarget.id, auditor: auditorLabel },
-	}, { triggerTurn: false });
+	});
 	if (!core.isFocusedOperationCurrent(completionFocus)) {
 		return core.focusedOperationCancelledResult("Goal completion", completionFocus);
 	}
@@ -298,7 +297,7 @@ if (settings.disabled === true) {
 
 		if (userChoice === "complete_without_audit") {
 			// ── Mark complete without audit ────────────────────────────
-			pi.sendMessage<GoalAuditEventDetails>({
+			core.auditMessages.enqueue(ctx, {
 				customType: GOAL_AUDIT_ENTRY,
 				content: `Goal completed — user bypassed audit via Escape.`,
 				display: true,
@@ -379,7 +378,7 @@ if (settings.disabled === true) {
 			"",
 			auditor.output || "Auditor produced no approval marker.",
 		].filter((line): line is string => line !== undefined).join("\n");
-		pi.sendMessage<GoalAuditEventDetails>({
+		core.auditMessages.enqueue(ctx, {
 			customType: GOAL_AUDIT_ENTRY,
 			content: rejectionText,
 			display: true,
@@ -396,7 +395,7 @@ if (settings.disabled === true) {
 		"",
 		auditor.output || "Auditor approved completion.",
 	].filter((line): line is string => line !== undefined).join("\n");
-	pi.sendMessage<GoalAuditEventDetails>({
+	core.auditMessages.enqueue(ctx, {
 		customType: GOAL_AUDIT_ENTRY,
 		content: approvalText,
 		display: true,

package/extensions/goal-drafting.ts

@@ -8,7 +8,7 @@ import { deriveTasksFromObjective } from "./goal-task-derive.ts";
 import { goalDetails, renderGoalResult } from "./goal-format.ts";
 import { buildGoalCreatedReport } from "./goal-policy.ts";
 import { loadGoalSettings } from "./goal-settings.ts";
-import { formatQuestionnaireAnswers, runGoalQuestionnaire, shouldAutoConfirmProposal, showProposalDialog, type GoalQuestionnaireQuestion, type ProposalDecision } from "./goal-questionnaire.ts";
+import { DIALOG_UNAVAILABLE_HINT, proposalDialogFailureMessage, formatQuestionnaireAnswers, runGoalQuestionnaire, shouldAutoConfirmProposal, showProposalDialog, type GoalQuestionnaireQuestion, type ProposalDecision } from "./goal-questionnaire.ts";
 import { currentTaskIdIsPending, nowIso, type GoalRecord, type GoalTaskList } from "./goal-record.ts";
 import type { GoalCore } from "./goal-state.ts";
 import { convertFlatTasks, countTasks, mergeTasksWithExisting, type FlatTaskInput } from "./goal-task-tools.ts";
@@ -250,7 +250,10 @@ export function registerDraftingTools(core: GoalCore): void {
 			core.enterGoalModal();
 			try {
 				const result = await runGoalQuestionnaire(ctx, [{ id: "question", question: params.question, options: params.options ?? [], recommended: params.recommended, allowCustom: params.allow_custom }]);
+				if (result.unavailable === true) return { content: [{ type: "text", text: `${DIALOG_UNAVAILABLE_HINT} Ask the question in chat instead.` }], details: goalDetails(core.state.goal) };
 				return { content: [{ type: "text", text: result.cancelled ? "The user cancelled the question. Continue drafting conversationally." : formatQuestionnaireAnswers(result) }], details: goalDetails(core.state.goal) };
+			} catch (error) {
+				return { content: [{ type: "text", text: `Goal drafting dialog failed: ${error instanceof Error ? error.message : String(error)}. Drafting remains active; ask in chat instead of retrying the dialog.` }], details: goalDetails(core.state.goal) };
 			} finally {
 				core.exitGoalModal();
 			}
@@ -284,7 +287,10 @@ export function registerDraftingTools(core: GoalCore): void {
 					const active = activeDraft(core);
 					if (active) active.questionnaireEcho = formatQuestionnaireAnswers(result); // E5
 				}
+				if (result.unavailable === true) return { content: [{ type: "text", text: `${DIALOG_UNAVAILABLE_HINT} Ask the questions in chat instead.` }], details: goalDetails(core.state.goal) };
 				return { content: [{ type: "text", text: result.cancelled ? "The user cancelled the questionnaire. Continue drafting conversationally." : formatQuestionnaireAnswers(result) }], details: goalDetails(core.state.goal) };
+			} catch (error) {
+				return { content: [{ type: "text", text: `Goal drafting dialog failed: ${error instanceof Error ? error.message : String(error)}. Drafting remains active; ask in chat instead of retrying the dialog.` }], details: goalDetails(core.state.goal) };
 			} finally {
 				core.exitGoalModal();
 			}
@@ -326,16 +332,15 @@ export function registerDraftingTools(core: GoalCore): void {
 			const target = draft.mode === "tweak" ? core.state.goal : undefined;
 			if (draft.mode === "tweak" && (!target || target.id !== draft.targetGoalId)) return { content: [{ type: "text", text: "The goal changed while drafting; review it and start /goal-tweak again." }], details: goalDetails(core.state.goal) };
 			if (draft.mode === "sisyphus" && !sisyphusObjectiveSufficient(objective)) return { content: [{ type: "text", text: "A Sisyphus goal needs ordered steps with explicit per-step done criteria. Refine the objective with numbered steps (1) ..., 2) ...) or Step N: blocks before proposing again." }], details: goalDetails(core.state.goal) };
-			const auditorLine = draft.auditorEnabled
-				? "\n\nAuditor for this goal: enabled (independent approval required before completion)."
-				: "\n\nAuditor for this goal: disabled (completion skips the audit).";
-			let confirmation: { decision: ProposalDecision; auditorEnabled: boolean };
+			let confirmation: { decision: ProposalDecision; auditorEnabled: boolean; unavailable: boolean };
 			if (shouldAutoConfirmProposal({ hasUI: ctx.hasUI, autoConfirmEnv: process.env.PI_GOAL_AUTO_CONFIRM })) {
-				confirmation = { decision: "confirm" as const, auditorEnabled: draft.auditorEnabled };
+				confirmation = { decision: "confirm" as const, auditorEnabled: draft.auditorEnabled, unavailable: false };
 			} else {
 				core.enterGoalModal();
 				try {
-					confirmation = await showProposalDialog(ctx, proposalText(draft, objective, params.auto_continue !== false, taskResult.value, target ?? undefined) + auditorLine, draft.mode === "sisyphus" ? "sisyphus" : "goal", draft.auditorEnabled);
+					confirmation = await showProposalDialog(ctx, proposalText(draft, objective, params.auto_continue !== false, taskResult.value, target ?? undefined), draft.mode === "sisyphus" ? "sisyphus" : "goal", draft.auditorEnabled);
+				} catch (error) {
+					return { content: [{ type: "text", text: `${proposalDialogFailureMessage(error)} Do not retry the dialog until the host issue is resolved.` }], details: goalDetails(core.state.goal) };
 				} finally {
 					core.exitGoalModal();
 				}
@@ -350,12 +355,15 @@ export function registerDraftingTools(core: GoalCore): void {
 				taskList: taskResult.value,
 				verificationContract: extracted.verificationContract,
 				autoContinue: params.auto_continue !== false,
-				auditorEnabled: draft.auditorEnabled,
+				auditorEnabled: confirmation.auditorEnabled,
 			});
 			if (confirmation.decision === "cancel") {
 				clearGoalDrafting(core, ctx);
 				return { content: [{ type: "text", text: `${summary}\n\nDraft cancelled; no goal was created. Run /goal or /sisyphus to start a new draft.` }], details: goalDetails(core.state.goal) };
 			}
+			if (confirmation.unavailable) {
+				return { content: [{ type: "text", text: `${summary}\n\n${DIALOG_UNAVAILABLE_HINT} The goal was NOT created and drafting remains active; do not retry the dialog until the host supports it or the user explicitly restarts with PI_GOAL_AUTO_CONFIRM=1.` }], details: goalDetails(core.state.goal) };
+			}
 			if (confirmation.decision !== "confirm") {
 				// Continue refining: preserve the user's auditor choice for the
 				// next proposal (memory and the durable session entry).

package/extensions/goal-events.ts

@@ -31,6 +31,7 @@ import { consumeOracleFollowupMarker, hasPendingOracleAdviceForFocusedGoal } fro
 import { hasActiveDraft, rehydrateDraft } from "./goal-drafting.ts";
 import { syncTerminalInputPause } from "./goal-widget.ts";
 import type { GoalCore } from "./goal-state.ts";
+import { filterGoalSessionContext } from "./goal-session-safety.ts";
 import type { GoalMutationOutcome } from "./goal-service.ts";
 
 /**
@@ -87,8 +88,8 @@ export function registerGoalEvents(core: GoalCore): void {
 	let networkErrorRecoveryAfterSettleFor: string | null = null;
 
 	pi.on("context", async (event) => {
-		const messages = compactGoalCheckpointContext(event.messages, core.state.goal);
-		// Reference equality means no goal-event messages existed at all.
+		const filtered = filterGoalSessionContext(event.messages);
+		const messages = compactGoalCheckpointContext(filtered ?? event.messages, core.state.goal) ?? filtered;
 		return messages === null ? undefined : { messages: messages as typeof event.messages };
 	});
 
@@ -270,6 +271,7 @@ export function registerGoalEvents(core: GoalCore): void {
 	});
 
 	pi.on("session_start", async (event, ctx) => {
+		core.auditMessages.clear();
 		// NAF: the zero-op read caches are session-scoped — a new session always
 		// re-reads settings/pool/ledger fresh from disk (cross-process and
 		// hand-edited changes are picked up at the session boundary).
@@ -327,6 +329,7 @@ export function registerGoalEvents(core: GoalCore): void {
 	});
 
 	pi.on("session_tree", async (_event, ctx) => {
+		core.auditMessages.clear();
 		core.goalService.flushTurn(ctx); // P1-3: persist any buffered transaction before reload
 		await core.loadState(ctx);
 		rehydrateDraft(core, ctx);
@@ -530,6 +533,7 @@ export function registerGoalEvents(core: GoalCore): void {
 	});
 
 	pi.on("agent_settled", async (_event, ctx) => {
+		core.auditMessages.flush(ctx, pi);
 		const goalId = continuationAfterSettleFor;
 		continuationAfterSettleFor = null;
 		const networkErrorGoalId = networkErrorRecoveryAfterSettleFor;
@@ -560,6 +564,7 @@ export function registerGoalEvents(core: GoalCore): void {
 	});
 
 	pi.on("session_shutdown", async (_event, ctx) => {
+		core.auditMessages.clear();
 		continuationAfterSettleFor = null;
 		networkErrorRecoveryAfterSettleFor = null;
 		core.accountProgress(ctx);

package/extensions/goal-questionnaire.ts

@@ -26,6 +26,13 @@ export interface GoalQuestionnaireResult {
 	answers: GoalQuestionnaireAnswer[];
 	cancelled: boolean;
 	auditorEnabled?: boolean;
+	/**
+	 * The host could not present the dialog at all, so `cancelled` reflects an
+	 * absent UI rather than a decision the user made. Hosts that expose a
+	 * non-terminal UI keep `ctx.hasUI` true while `ctx.ui.custom` stays the
+	 * SDK's headless default, which resolves to `undefined`.
+	 */
+	unavailable?: boolean;
 }
 
 export type ProposalDecision = "confirm" | "continue" | "cancel";
@@ -298,6 +305,60 @@ export function isHeadlessQuestionSufficientForDraft(args: { topic: string; ques
 	return !vagueTopic;
 }
 
+const CUSTOM_ANSWER_LABEL = "Write your own answer...";
+
+/** Sequential native dialogs for hosts that cannot render terminal components. */
+async function runQuestionnaireWithBasicDialogs(
+	ctx: ExtensionContext,
+	questions: GoalQuestionnaireQuestion[],
+	auditorToggleInit?: { defaultEnabled: boolean },
+): Promise<GoalQuestionnaireResult> {
+	const unavailable = (): GoalQuestionnaireResult => ({ questions: [], answers: [], cancelled: true, unavailable: true, ...(auditorToggleInit ? { auditorEnabled: auditorToggleInit.defaultEnabled } : {}) });
+	// Require only the primitives this questionnaire can actually use.
+	if ((auditorToggleInit || questions.some(q => q.options.length > 0)) && typeof ctx.ui.select !== "function") return unavailable();
+	if (questions.some(q => q.options.length === 0 || q.allowCustom !== false) && typeof ctx.ui.input !== "function") return unavailable();
+	let auditorEnabled = auditorToggleInit?.defaultEnabled;
+	const cancelled = (): GoalQuestionnaireResult => ({ questions, answers: [], cancelled: true, auditorEnabled });
+	if (auditorToggleInit) {
+		const enabled = "Enabled — require independent approval";
+		const disabled = "Disabled — skip the completion audit";
+		const choices = auditorEnabled ? [enabled, disabled] : [disabled, enabled];
+		const picked = await ctx.ui.select(`Completion auditor (currently ${auditorEnabled ? "enabled" : "disabled"})`, choices);
+		if (picked === undefined) return cancelled();
+		if (!choices.includes(picked)) throw new Error("The host returned an unknown auditor choice");
+		auditorEnabled = picked === enabled;
+	}
+	const answers: GoalQuestionnaireAnswer[] = [];
+	for (const question of questions) {
+		let prompt = question.context ? `${question.question}\n\n${question.context}` : question.question;
+		if (auditorToggleInit) prompt += `\n\nAuditor for this goal: ${auditorEnabled ? "enabled (independent approval required)" : "disabled (completion skips the audit)"}.`;
+		let answer: string | undefined;
+		let wasCustom = question.options.length === 0;
+		if (!wasCustom) {
+			// Numbered labels keep duplicate/reserved option text unambiguous.
+			const labels = question.options.map((option, i) => `${i + 1}. ${option}${question.recommended === i ? " (Recommended)" : ""}`);
+			const customLabel = `${labels.length + 1}. ${CUSTOM_ANSWER_LABEL}`;
+			const options = question.allowCustom === false ? labels : [...labels, customLabel];
+			const picked = await ctx.ui.select(prompt, options);
+			if (picked === undefined) return cancelled();
+			if (!options.includes(picked)) throw new Error("The host returned an unknown questionnaire choice");
+			wasCustom = picked === customLabel && question.allowCustom !== false;
+			if (!wasCustom) answer = question.options[labels.indexOf(picked)];
+		}
+		if (wasCustom) {
+			// Match the terminal editor: whitespace alone is not a submitted answer.
+			do {
+				answer = (await ctx.ui.input(prompt, "Write your answer"))?.trim();
+			} while (answer === "");
+		}
+		if (answer === undefined) return cancelled();
+		answers.push({ id: question.id, question: question.question, answer, wasCustom });
+	}
+	return { questions, answers, cancelled: false, auditorEnabled };
+}
+
+export const DIALOG_UNAVAILABLE_HINT = "This host cannot display the required goal-drafting dialogs. Use a host with select/input support or the pi TUI, or explicitly restart with PI_GOAL_AUTO_CONFIRM=1 to confirm proposals without a dialog.";
+
 export function proposalDialogFailureMessage(error: unknown): string {
 	const detail = error instanceof Error ? error.message : String(error);
 	return `Goal draft confirmation failed: ${detail}. The goal was NOT created; drafting remains active.`;
@@ -314,10 +375,18 @@ export async function runGoalQuestionnaire(ctx: ExtensionContext, rawQuestions:
 	}
 
 	const questions = normalizeQuestionnaireQuestions(rawQuestions);
+	if (ctx.mode === "rpc" || typeof ctx.ui.custom !== "function") {
+		return runQuestionnaireWithBasicDialogs(ctx, questions, auditorToggleInit);
+	}
 	const isMulti = questions.length > 1;
 	const totalTabs = questions.length + 1;
 
-	return await ctx.ui.custom<GoalQuestionnaireResult>((tui, theme, _kb, done) => {
+	const result = await ctx.ui.custom<GoalQuestionnaireResult | undefined>((tui, theme, _kb, done) => {
+		// Some web hosts invoke the factory with a render callback in place of a TUI.
+		if (!tui || typeof tui.getShowHardwareCursor !== "function" || typeof tui.setShowHardwareCursor !== "function" || typeof tui.requestRender !== "function") {
+			done(undefined);
+			return { render: () => [], invalidate: () => {} };
+		}
 		// Suppress hardware cursor during dialog to reduce TUI auto-scroll
 		// (the TUI render loop runs at ~60fps and writes ANSI cursor positioning
 		// sequences every cycle, which can cause terminal viewport snapping).
@@ -947,6 +1016,8 @@ function advanceAfterAnswer() {
 			},
 		};
 	});
+	if (result !== undefined) return result;
+	return runQuestionnaireWithBasicDialogs(ctx, questions, auditorToggleInit);
 }
 
 /**
@@ -958,7 +1029,7 @@ export async function showProposalDialog(
 	confirmationText: string,
 	focus: GoalDraftingFocus,
 	defaultAuditorEnabled?: boolean,
-): Promise<{ decision: ProposalDecision; auditorEnabled: boolean }> {
+): Promise<{ decision: ProposalDecision; auditorEnabled: boolean; unavailable: boolean }> {
 	const headerTitle = focus === "sisyphus" ? "Confirm Sisyphus Goal Draft" : "Confirm Goal Draft";
 	const result = await runGoalQuestionnaire(ctx, [{
 		id: "confirm",
@@ -972,5 +1043,5 @@ export async function showProposalDialog(
 		cancelled: result.cancelled,
 		answer: result.answers[0]?.answer,
 	});
-	return { decision, auditorEnabled: result.auditorEnabled ?? true };
+	return { decision, auditorEnabled: result.auditorEnabled ?? true, unavailable: result.unavailable === true };
 }

package/extensions/goal-session-safety.ts

@@ -0,0 +1,48 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { GOAL_AUDIT_ENTRY, goalEventMessageId } from "./goal-format.ts";
+
+/** pi-subagents marks fresh, forked, resumed and nested worker processes. */
+export function isDelegatedGoalSession(env: Record<string, string | undefined> = process.env): boolean {
+	const depth = Number(env.PI_SUBAGENT_DEPTH);
+	return env.PI_SUBAGENT_CHILD === "1" || (Number.isFinite(depth) && depth > 0);
+}
+
+/** Display-only audits must never become user messages between a tool and its result. */
+export function filterGoalSessionContext<T>(messages: readonly T[], child = false): T[] | null {
+	let filtered: T[] | null = null;
+	for (let i = 0; i < messages.length; i++) {
+		const message = messages[i]!;
+		const entry = message as { role?: string; customType?: string; details?: unknown; content?: unknown } | null;
+		const remove = entry && typeof entry === "object" && entry.role === "custom"
+			&& (entry.customType === GOAL_AUDIT_ENTRY || (child && goalEventMessageId(entry) !== null));
+		if (remove) filtered ??= messages.slice(0, i);
+		else filtered?.push(message);
+	}
+	return filtered;
+}
+
+type TranscriptMessage = Parameters<ExtensionAPI["sendMessage"]>[0];
+type SessionKey = string | ExtensionContext["sessionManager"];
+const sessionKey = (ctx: ExtensionContext): SessionKey => ctx.sessionManager.getSessionId?.() ?? ctx.sessionManager;
+
+/** Transcript output waits for the entire agent run, including tool results, to settle. */
+export class GoalAuditMessages {
+	private pending: { session: SessionKey; message: TranscriptMessage }[] = [];
+
+	enqueue(ctx: ExtensionContext, message: TranscriptMessage): void {
+		this.pending.push({ session: sessionKey(ctx), message });
+	}
+
+	clear(): void {
+		this.pending = [];
+	}
+
+	flush(ctx: ExtensionContext, pi: ExtensionAPI): void {
+		const session = sessionKey(ctx);
+		this.pending = this.pending.filter(item => item.session === session);
+		if (!ctx.isIdle()) return;
+		const pending = this.pending;
+		this.pending = [];
+		for (const item of pending) pi.sendMessage(item.message, { triggerTurn: false });
+	}
+}

package/extensions/goal-state.ts

@@ -32,6 +32,7 @@ import { GoalService } from "./goal-service.ts";
 import { goalActivityEvents } from "./goal-ledger.ts";
 import { GoalAccounting } from "./goal-accounting.ts";
 import { GoalRuntime } from "./goal-runtime.ts";
+import { GoalAuditMessages } from "./goal-session-safety.ts";
 import {
 	focusedGoalFromPool,
 	openGoalsFromPool,
@@ -78,6 +79,7 @@ export interface GoalCore {
 	goalWidgetComponentRef: { current: GoalWidgetComponent | null };
 	goalService: GoalService;
 	runtime: GoalRuntime;
+	auditMessages: GoalAuditMessages;
 	accounting: GoalAccounting;
 
 	assignFocusedGoalId(goalId: string | null): void;
@@ -1000,6 +1002,7 @@ export function createGoalCore(
 		goalWidgetComponentRef,
 		goalService,
 		runtime,
+		auditMessages: new GoalAuditMessages(),
 		accounting,
 		assignFocusedGoalId,
 		focusedOperationToken,

package/extensions/goal.ts

@@ -12,6 +12,7 @@ import {
 import type { GoalEventDetails } from "./goal-record.ts";
 import { createGoalCore } from "./goal-state.ts";
 import { registerGoalTools } from "./goal-tools.ts";
+import { filterGoalSessionContext, isDelegatedGoalSession } from "./goal-session-safety.ts";
 
 /**
  * pi-goal thin installer. All state lives in the GoalCore (goal-state.ts);
@@ -23,6 +24,14 @@ export default function goalExtension(
 	pi: ExtensionAPI,
 	dependencies: { runCompletionAuditor?: typeof runGoalCompletionAuditor } = {},
 ): void {
+	if (isDelegatedGoalSession()) {
+		// Inherit conversation without inheriting ownership of the parent's goal.
+		pi.on("context", async event => {
+			const messages = filterGoalSessionContext(event.messages, true);
+			return messages === null ? undefined : { messages };
+		});
+		return;
+	}
 	pi.registerMessageRenderer<GoalEventDetails>(GOAL_EVENT_ENTRY, renderGoalEvent);
 	pi.registerMessageRenderer<GoalAuditEventDetails>(GOAL_AUDIT_ENTRY, renderGoalAuditEvent);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-x",
-  "version": "0.31.0",
+  "version": "0.31.1",
   "description": "Goal mode extension for pi: durable long-running objectives, five model tools, structured tasks, independent completion audit, Sisyphus mode, auto-continue, and a status overlay.",
   "license": "MIT",
   "author": "pi-goal-x contributors",