pi-goal-x 0.30.4 → 0.31.0

package/README.md

@@ -251,6 +251,18 @@ Pressing `Esc` during active work pauses the goal.
 
 The agent can divide a goal into tasks and subtasks and update them as work progresses. The current task is tracked explicitly (persisted as the goal's execution focus) and highlighted in the dashboard; starting a task with `update_goal_task(status="start")` sets it, and completing or skipping it clears it.
 
+The model receives the objective excerpt, current task, next three pending tasks, progress, budget, and applicable rules. Full requirements, contracts, and evidence remain saved. `get_goal()` returns a compact summary; use `get_goal({section:"objective"})`, `section:"tasks"` (optionally `task_id`), or `section:"history"` for lossless pages of at most 4,000 content characters. Repeat the section and task with the returned `cursor` to continue. A changed source rejects stale cursors and asks for a restart. Existing `verbose` and `include_history` arguments remain supported.
+
+Task progress can be recorded atomically in order:
+
+```json
+{"updates":[{"task_id":"child","status":"complete","evidence":"Tests passed"},{"task_id":"parent","status":"complete"},{"task_id":"next","status":"start"}]}
+```
+
+Pass this to `update_goal_task`. A batch accepts 1–100 updates and validates every transition before applying any. Complete children before their parent; contracted tasks still require evidence, skips require reasons, and completed tasks cannot reopen. Single-task calls remain supported; do not mix the two forms. Each update retains its own ledger event. Turn-level writes check the original persisted revision, and completion audits wait for a successful flush.
+
+Goal tools appear when applicable. Outside drafting, creation and inspection remain available; outcomes appear for active, paused, or budget-limited goals, task planning for active or paused goals, and task progress for active goals with a task tree. Disabling tasks hides both task tools. Drafting keeps its question/proposal tools, and ordinary work tools remain available.
+
 Verification contracts describe the evidence required for completion. They can apply to the entire goal or to an individual task.
 
 Examples include:

package/docs/architecture.md

@@ -35,7 +35,10 @@ handlers from their dedicated modules:
 | `goal-draft.ts` | Drafting prompt/confirmation text helpers (goalDraftingPrompt, buildDraftConfirmationText, renderConfirmationTasks, GoalDraftingFocus) |
 | `goal-drafting.ts` | Guided drafting orchestration: durable `pi-goal-draft` session entries (survive compaction/tree navigation), resume/replace/cancel protection, transient drafting profile, `goal_question`/`goal_questionnaire`/`propose_goal_draft` tools, per-draft auditor selection |
 | `goal-questionnaire.ts` | Structured question/answer UI (`runGoalQuestionnaire`, `showProposalDialog`) used by the drafting tools and confirmations |
-| `goal-tool-names.ts` | The five published tool-name constants, fixed three/five profiles, work/progress classification, post-stop allowlist |
+| `goal-tool-names.ts` | The five published tool-name constants, lifecycle-dependent profiles, work/progress classification, post-stop allowlist |
+| `goal-detail.ts` | Lossless objective/task/history paging with content-bound cursors |
+| `goal-ledger-index.ts` | Incremental per-goal activity, audit, lifecycle, and Oracle projections |
+| `goal-task-index.ts` | Content-keyed task snapshots shared by prompts, tools, and dashboard models |
 | `prompts/goal-prompts.ts` | Bounded five-tool steering prompts (active-goal, continuation, stale-checkpoint, unfocused, budget-limited) |
 | `storage/goal-files.ts` | Goal path safety, serialization/parsing, active-file scanning, active-file writes, archive writes, prompt-body merge from disk |
 | `widgets/goal-widget.ts` | Above-editor Goal Beacon component |
@@ -197,19 +200,43 @@ The extension registers five normal-execution tools and three drafting-only tool
 | Tool | Purpose |
 |---|---|
 | `create_goal` | Create and focus a new goal after an explicit user request (objective 1–4000 chars, optional `mode` regular/sisyphus and `token_budget`). |
-| `get_goal` | Read-only complete focused goal snapshot. |
+| `get_goal` | Compact summary by default; lossless objective/tasks/history pages (up to 4,000 content characters), optional task selection, legacy verbose/history forms. |
 | `update_goal` | Run outcomes: `complete` (audited from actual evidence; optional `completion_summary` is an untrusted claim), `blocked` (after three consecutive identical blockers), or `paused` (immediate agent pause with required `reason`). |
 | `set_goal_tasks` | Create or structurally replace the task tree (flat parent-linked input, confirmation dialog, id-stable merge). |
-| `update_goal_task` | Update one task without stopping the turn: complete (evidence for contracted tasks), skipped (reason), pending (reopens skipped). |
+| `update_goal_task` | Update one task or an ordered atomic batch: start, complete (evidence for contracted tasks), skipped (reason), pending (reopens skipped). |
 | `goal_question` | Drafting-only structured clarification question. |
 | `goal_questionnaire` | Drafting-only multi-question clarification UI. |
 | `propose_goal_draft` | Drafting-only objective/task proposal with Confirm or Continue Chatting. |
 
-The normal execution profile is fixed: exactly five goal tools when tasks are
-enabled, exactly three when disabled. A user-started guided draft is the sole
-exception: it replaces those goal tools with question/questionnaire/proposal
-tools until confirmation or cancellation. Ordinary pi work tools are never
-touched. Invalid lifecycle calls return concise state-aware tool results.
+Outside drafting, creation and inspection are always advertised. Outcomes are
+advertised for active/paused/budget-limited goals; task planning for active or
+paused goals; task progress for active goals with tasks. Disabled tasks hide both
+task tools. A guided draft replaces goal tools with question/questionnaire/proposal
+tools until confirmation or cancellation. Ordinary pi work tools remain available.
+The SDK active profile changes only when membership changes. Executors still
+validate lifecycle state, including stale calls made after a transition.
+
+Normal prompt/dashboard reads use per-goal ledger indexes: 12 recent events,
+64 activity candidates in stable timestamp order, pinned audit/lifecycle state,
+and blocker-fingerprint Oracle state. Appends extend these indexes without
+copying history. Version 3 derived checkpoints use UTF-8 byte offsets and retain
+reconstructed Oracle advice; old or
+corrupt checkpoints rebuild from the authoritative JSONL ledger. Full history
+is loaded for explicit history/diagnostic requests. Saved goal/session formats
+remain compatible. Task presentation caches use content snapshots; usage changes
+do not rebuild task trees. Stable prompt rules precede changing goal data and
+usage counters, with retrieval instructions beside bounded excerpts.
+
+Warm settings resolution is cached by layer identity and applicable environment
+values; public resolved values remain independently editable. Task and prompt
+caches compare content fields without repeatedly serializing long contracts.
+Compiled detail pages reuse their source and cursor hash; history sources are
+invalidated by an opaque ledger generation on append or refresh. Cache size
+limits bound retained data; larger requirements remain available losslessly.
+Pure ANSI text wrapping/truncation is cached by text and layout arguments across
+widgets and dialogs. Live auditor previews scan only the report tail, while the
+complete final report remains available. Measurements and the module audit are
+in `specs/2026-09-07-comprehensive-optimization/`.
 
 The `tool_call` interceptor blocks work tools after a stop tool has fired in
 the same turn, and blocks work tools when the checkpoint that triggered the
@@ -283,7 +310,7 @@ entries and run them in one Node process with small test-only adapters for the
 SDK values used by handlers. This avoids loading unrelated model-provider and
 TUI media modules. The fast path requires Node 22.15+; `test:serial` remains
 the slow, real-SDK, process-isolated
-compatibility path. The suites cover: surface baselines (exactly the fixed five/three tool
+compatibility path. The suites cover: surface baselines (lifecycle-dependent goal tool
 profile and fourteen commands), golden file/ledger fixtures, stale-continuation behavior,
 GoalService mutation boundary, runtime/accounting, token-budget transitions,
 task-tool consolidation, verification contracts, the independent auditor,
@@ -298,7 +325,7 @@ The 2026-08-04 hardening plan
 is implemented: paused-status normalization (status authoritative, legacy
 `autoContinue: true` records stay paused), disk-fresh task transactions with
 structural-field clearing, token-budget integer validation, `task_reopened`
-ledger semantics with observable diagnostics, the three/five fixed tool
+ledger semantics with observable diagnostics, the lifecycle-dependent tool
 profile, and the supported integration/experiment coverage described above.
 (the interim drafting-surface removal was later reversed by the product
 correction in the runtime follow-up, which restores guided drafting as a

package/extensions/goal-activity.ts

@@ -136,6 +136,33 @@ function mapEvent(event: GoalLedgerEvent, taskTitles: ReadonlyMap<string, string
 	}
 }
 
+const indexedActivity = new WeakSet<readonly GoalLedgerEvent[]>();
+export function indexedActivityEvents(events: GoalLedgerEvent[]): GoalLedgerEvent[] {
+ indexedActivity.add(events);
+ return events;
+}
+
+/** Stable event identity for append-order deduplication, independent of title edits. */
+export function activityEventKey(event: GoalLedgerEvent): string | undefined {
+ const item = mapEvent(event, undefined);
+ return item ? `${item.kind}:${item.text}` : undefined;
+}
+
+const activityTypes = new Set([
+ "goal_created", "goal_tweaked", "auditor_toggled", "goal_paused", "goal_resumed", "goal_blocked",
+ "goal_budget_limited", "goal_completed", "goal_aborted", "task_started", "task_complete", "task_skipped",
+ "task_reopened", "completion_requested", "audit_started", "audit_result", "audit_skipped", "goal_archived",
+]);
+export function isActivityEvent(event: GoalLedgerEvent): boolean { return activityTypes.has(event.type); }
+
+/** Avoid formatting distinct task events during a cold ledger rebuild. */
+export function sameActivityEvent(left: GoalLedgerEvent, right: GoalLedgerEvent): boolean {
+ if (left.type !== right.type) return false;
+ if ("taskId" in left && "taskId" in right && left.taskId !== right.taskId) return false;
+ // Reasons/evidence use the exact display normalization for true duplicates.
+ return activityEventKey(left) === activityEventKey(right);
+}
+
 /**
  * Derive the readable activity feed for one goal from its durable ledger
  * events. Returns items in chronological order (oldest first), capped to the
@@ -148,6 +175,17 @@ export function deriveGoalActivity(
 ): GoalActivityItem[] {
 	const { taskTitles, limit = 5 } = options;
 	const items: GoalActivityItem[] = [];
+	if (indexedActivity.has(events)) {
+		// Runtime indexes already deduplicate and sort. Format only the requested tail.
+		for (let i = events.length - 1; i >= 0; i--) {
+			const event = events[i]!;
+			if (!("goalId" in event) || event.goalId !== goalId) continue;
+			const item = mapEvent(event, taskTitles);
+			if (item) items.push(item);
+			if (limit > 0 && items.length >= limit) break;
+		}
+		return items.reverse().slice(-limit);
+	}
 	for (const event of events) {
 		if (!("goalId" in event) || event.goalId !== goalId) continue;
 		const item = mapEvent(event, taskTitles);

package/extensions/goal-auditor.ts

@@ -109,6 +109,20 @@ function escapePromptPayload(value: string): string {
 	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 
+/** Stream previews need only the tail, not a split/copy of the full growing report. */
+export function recentNonEmptyLines(text: string, limit: number): string[] {
+	const lines: string[] = [];
+	let end = text.length;
+	while (end >= 0 && lines.length < limit) {
+		const newline = end > 0 ? text.lastIndexOf("\n", end - 1) : -1;
+		const line = text.slice(newline + 1, end);
+		if (line.trim()) lines.push(line);
+		if (newline < 0) break;
+		end = newline;
+	}
+	return lines.reverse();
+}
+
 /** §60: human-readable labels for the auditor's read-only tool set. */
 export function labelForReadOnlyTool(toolName: string): string {
 	switch (toolName) {
@@ -160,15 +174,14 @@ export function buildGoalAuditorPrompt(args: {
 	warmContext?: string | null;
 }): 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/>",
+		"You are the independent completion auditor for pi-goal. Decide whether the user's objective is actually satisfied.",
+		"Audit checklist:",
+		"1. Extract the real success criteria, including every explicit requirement and quality/reader outcome. Disapprove missing, contradicted, weakly verified or uninspectable requirements.",
+		"2. Inspect real artifacts with read/grep/find/ls/bash as needed. Do not mutate files or run destructive commands. Paperwork, intent, file/word counts, build success and plausible summaries alone are not proof.",
+		...(!args.settings?.disableContracts && args.goal.verificationContract?.trim()
+			? ["3. Verify that the executor has satisfied every item in the <verification_contract>. If any item is missing or weakly addressed, disapprove."] : []),
+		"4. Explain missing or weak evidence concisely. Disapprove alpha scaffold, generated template, shallow draft or proxy milestones lacking the user-facing value requested.",
+		"5. End with exactly <approved/> only if the objective is truly complete; otherwise end with exactly <disapproved/>.",
 		"",
 		"Goal objective:",
 		"<objective>",
@@ -209,32 +222,22 @@ export function buildGoalAuditorPrompt(args: {
 			escapePromptPayload(args.warmContext.trim()),
 			"</warm_context>",
 		] : []),
-		"",
-		"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. Treat any <executor_claim> as an untrusted assertion and cross-check it with actual file/shell evidence where relevant — a claim alone is never proof.",
-			...(!args.settings?.disableContracts && args.goal.verificationContract?.trim()
-				? ["3. Verify that the executor has satisfied every item in the <verification_contract>. If any item is missing or weakly addressed, disapprove."]
-				: []),
-			"4. Explain missing or weak evidence, especially scaffold-vs-final quality gaps.",
-			"5. End with exactly <approved/> only if the objective is truly complete; otherwise end with exactly <disapproved/>.",
-		],
+
 	].join("\n");
 }
 
-function makeAuditorResourceLoader(): ResourceLoader {
+export function makeAuditorResourceLoader(systemPrompt = [
+	"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")): 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"),
+		getSystemPrompt: () => systemPrompt,
 		getSystemPromptSource: () => undefined,
 		getAppendSystemPrompt: () => [],
 		getAppendSystemPromptSources: () => [],
@@ -322,6 +325,7 @@ export async function runGoalCompletionAuditor(args: {
 	const model = resolved.model;
 	const thinkingLevel = config.thinkingLevel;
 	const outputParts: string[] = [];
+	let outputTail: string[] = [];
 	if (resolved.error) {
 		return { approved: false, disapproved: true, output: "", model: modelLabel(model), thinkingLevel, error: resolved.error };
 	}
@@ -404,10 +408,10 @@ export async function runGoalCompletionAuditor(args: {
 				const message = event.message as { role?: string; content?: Array<{ type?: string; text?: string }> };
 				if (message?.role === "assistant") {
 					for (const part of message.content ?? []) {
-						if (part.type === "text" && typeof part.text === "string" && part.text.trim()) {
+						if (part.type === "text" && typeof part.text === "string") {
 							// 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)];
+							const lines = recentNonEmptyLines(part.text, 5);
+							if (lines.length) progress.recentOutput = lines;
 						}
 					}
 				}
@@ -418,18 +422,19 @@ export async function runGoalCompletionAuditor(args: {
 			const message = event.message as { role?: string; content?: Array<{ type?: string; text?: string }> };
 			if (message.role !== "assistant") return;
 			for (const part of message.content ?? []) {
-				if (part.type === "text" && typeof part.text === "string") outputParts.push(part.text);
+				if (part.type === "text" && typeof part.text === "string") {
+					outputParts.push(part.text);
+					outputTail = [...outputTail, ...recentNonEmptyLines(part.text, 8)].slice(-8);
+				}
 			}
 			// Final report production: derived label for the widget.
-			if (outputParts.some((t) => t.trim())) {
+			if (outputTail.length > 0) {
 				progress.label = "Producing report...";
 				progress.percentage = Math.max(progress.percentage ?? 0, 90);
 				progress.phase = "producing_report";
 			}
 			// 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);
+			progress.recentOutput = outputTail;
 			emitProgress();
 		});
 		// Wire the external AbortSignal to abort the running session when fired
@@ -451,6 +456,7 @@ export async function runGoalCompletionAuditor(args: {
 			progress.percentage = 100;
 			emitProgress();
 			unsubscribe();
+   session.dispose?.();
 		}
 		// session.abort() does NOT throw — the agent loop returns normally with
 		// whatever output was captured before the abort. Check the signal after

package/extensions/goal-commands.ts

@@ -170,7 +170,7 @@ export function registerGoalCommands(core: GoalCore): void {
 			} catch {}
 		}
 		if (!current) {
-			const openCount = core.openGoals().length;
+			const openCount = otherOpenGoalCount(core.goalsById, null);
 			ctx.ui.notify(openCount > 0 ? buildUnfocusedOpenGoalsSummary(openCount) : detailedSummary(null), "info");
 			return;
 		}
@@ -306,7 +306,7 @@ export function registerGoalCommands(core: GoalCore): void {
 	async function handleGoalPause(ctx: ExtensionContext): Promise<void> {
 		core.reconcileFocusedGoalFromDisk(ctx);
 		if (!core.state.goal) {
-			if (core.openGoals().length > 0) {
+			if (otherOpenGoalCount(core.goalsById, null) > 0) {
 				const selected = await chooseOpenGoal(ctx, "Pause which open goal?");
 				if (!selected) return;
 			} else {
@@ -329,7 +329,7 @@ export function registerGoalCommands(core: GoalCore): void {
 
 	async function handleGoalResume(ctx: ExtensionContext): Promise<void> {
 		core.reconcileFocusedGoalFromDisk(ctx);
-		if (!core.state.goal && core.openGoals().length > 0) {
+		if (!core.state.goal && otherOpenGoalCount(core.goalsById, null) > 0) {
 			const selected = await chooseOpenGoal(ctx, "Resume or focus open goal");
 			if (!selected) return;
 			if (selected.status === "active") {
@@ -660,7 +660,7 @@ export function registerGoalCommands(core: GoalCore): void {
 	}
 	async function handleGoalClear(ctx: ExtensionContext): Promise<void> {
 		core.reconcileFocusedGoalFromDisk(ctx);
-		if (!core.state.goal && core.openGoals().length > 0) {
+		if (!core.state.goal && otherOpenGoalCount(core.goalsById, null) > 0) {
 			const selected = await chooseOpenGoal(ctx, "Clear which open goal?");
 			if (!selected) return;
 		}
@@ -700,7 +700,7 @@ export function registerGoalCommands(core: GoalCore): void {
 	async function runGoalTweak(replacement: string, ctx: ExtensionContext): Promise<void> {
 		core.reconcileFocusedGoalFromDisk(ctx);
 		if (!core.state.goal) {
-			if (core.openGoals().length > 0) {
+			if (otherOpenGoalCount(core.goalsById, null) > 0) {
 				const selected = await chooseOpenGoal(ctx, "Tweak which open goal?");
 				if (!selected) return;
 			} else {

package/extensions/goal-compaction.ts

@@ -11,7 +11,8 @@ import {
   type GoalLedgerEvent,
   type LedgerStateReadResult,
 } from "./goal-ledger.ts";
-import { type GoalRecord, type GoalTask } from "./goal-record.ts";
+import { type GoalRecord } from "./goal-record.ts";
+import { taskIndex } from "./goal-task-index.ts";
 
 export function buildGoalCompactSummary(
   goal: GoalRecord,
@@ -169,17 +170,10 @@ export function buildPostCompactionGoalDelta(args: {
   lines.push(`[POST-COMPACTION RESYNC goalId=${goal.id}]`);
   // Execution focus (with contract) — the one thing memory must not lose.
   if (goal.currentTaskId && goal.taskList) {
-    const find = (tasks: GoalTask[]): GoalTask | undefined => {
-      for (const t of tasks) {
-        if (t.id === goal.currentTaskId) return t;
-        const nested = t.subtasks ? find(t.subtasks) : undefined;
-        if (nested) return nested;
-      }
-      return undefined;
-    };
-    const current = find(goal.taskList.tasks);
+    const current = taskIndex(goal.taskList.tasks).byId.get(goal.currentTaskId);
     if (current) {
-      lines.push(`Current task: ${current.id} — ${current.title}${current.verificationContract ? ` (contract: ${current.verificationContract})` : ""}`);
+      lines.push(`Current task: ${truncateText(current.id, 80)} — ${truncateText(current.title, 180)}${current.verificationContract ? ` (contract: ${truncateText(current.verificationContract, 600)})` : ""}`);
+      if (current.id.length > 80 || current.title.length > 180 || (current.verificationContract?.length ?? 0) > 600) lines.push('Retrieve omitted task requirements with get_goal(section="tasks") before continuing.');
     }
   }
   // Bounded recent-event tail.

package/extensions/goal-completion.ts

@@ -9,7 +9,7 @@ import {
 import { loadGoalSettings, loadGoalSettingsFileConfig } from "./goal-settings.ts";
 import { runGoalCompletionAuditor } from "./goal-auditor.ts";
 import { nowIso, type GoalRecord } from "./goal-record.ts";
-import { latestEventsForGoal, readGoalLedger } from "./goal-ledger.ts";
+import { latestEventsForGoal, goalRuntimeEvents } from "./goal-ledger.ts";
 import { mergeGoalPromptFromDisk } from "./storage/goal-files.ts";
 import { showEscapeDialog, type EscapeDialogResult } from "./widgets/goal-escape-dialog.ts";
 import type { GoalCore } from "./goal-state.ts";
@@ -23,6 +23,8 @@ import type { GoalMutationOutcome } from "./goal-service.ts";
 // 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);
 
 	// -- Completion --
@@ -239,7 +241,7 @@ if (settings.disabled === true) {
 
 	// P1-6: warm start — seed the auditor with the parent-rendered ledger tail
 	// (recent lifecycle + task evidence) so it does not re-derive session facts.
-	const ledger = readGoalLedger(ctx).events;
+	const ledger = goalRuntimeEvents(ctx, auditTarget.id);
 	const warmTail = latestEventsForGoal(ledger, auditTarget.id, 8);
 	const warmContext = warmTail.length > 0
 		? `Recent goal events (from the shared ledger):\n${warmTail.map((e) => `- ${e.at} ${e.type}${"taskId" in e ? ` (task ${e.taskId})` : ""}${"evidence" in e && e.evidence ? ` evidence: ${e.evidence}` : ""}`).join("\n")}`

package/extensions/goal-core-tools.ts

@@ -1,3 +1,5 @@
+import { goalDetailPage, type GoalDetailSection } from "./goal-detail.ts";
+import { taskIndex } from "./goal-task-index.ts";
 import { StringEnum, Type } from "@earendil-works/pi-ai";
 import { defineTool, type AgentToolResult, type ExtensionContext, type Theme } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
@@ -7,7 +9,7 @@ import { detailedSummary, goalDetails, renderGoalResult } from "./goal-format.ts
 import { budgetLine } from "./goal-accounting.ts";
 import { buildGoalCreatedReport, buildTaskSummary, findTaskInTree, validateGoalAgentPause, validateGoalBlock } from "./goal-policy.ts";
 import { buildUnfocusedOpenGoalsSummary, otherOpenGoalCount } from "./goal-pool.ts";
-import { readGoalLedger } from "./goal-ledger.ts";
+import { readGoalLedger, goalOracleState } from "./goal-ledger.ts";
 import { loadGoalSettings } from "./goal-settings.ts";
 import { buildGoalHistoryBlock, buildGoalTaskDetailBlock } from "./goal-format.ts";
 import { sisyphusStepProgress } from "./goal-policy.ts";
@@ -20,7 +22,6 @@ import {
 	buildBlockerFingerprint,
 	consumeOracleFollowupMarker,
 	hasPendingOracleAdviceForFocusedGoal,
-	oracleStateForFingerprint,
 	renderActionableOracleAdvice,
 	renderOracleAdviceReminder,
 	runBlockerOracle,
@@ -30,15 +31,9 @@ import { loadSettingsSnapshot, type ResolvedGoalOracleSettings } from "./goal-se
 /** Current + first-pending (excluding current) task pointers for concise get_goal. */
 function conciseTaskPointers(goal: GoalRecord): { findCurrentTask?: GoalTask; firstPendingTask?: GoalTask } {
 	if (!goal.taskList) return {};
-	let firstPendingTask: GoalTask | undefined;
-	const walk = (tasks: GoalTask[]): void => {
-		for (const t of tasks) {
-			if (!firstPendingTask && t.status === "pending" && t.id !== goal.currentTaskId) firstPendingTask = t;
-			if (t.subtasks) walk(t.subtasks);
-		}
-	};
-	walk(goal.taskList.tasks);
-	const findCurrentTask = goal.currentTaskId ? findTaskInTree(goal.taskList.tasks, goal.currentTaskId) : undefined;
+	const index = taskIndex(goal.taskList.tasks);
+	const firstPendingTask = index.pending.find(task => task.id !== goal.currentTaskId);
+	const findCurrentTask = goal.currentTaskId ? index.byId.get(goal.currentTaskId) : undefined;
 	return { findCurrentTask, firstPendingTask };
 }
 
@@ -53,12 +48,13 @@ export function registerCoreTools(
 pi.registerTool(defineTool({
 	name: "get_goal",
 	label: "Get Goal",
-	description: "Get the current pi goal for this session: objective, status, auto-continue, usage, and local file paths.",
-	promptSnippet: "Read the active pi goal state for the current session.",
-	promptGuidelines: [
-		"Use get_goal when you need the current goal before deciding whether to continue or mark it complete.",
-	],
+	description: "Read focused goal state. Default: compact summary. Retrieve full objective/contracts, tasks, or history in 4000-character pages with section and cursor. verbose preserves full legacy output.",
+	promptSnippet: "Inspect goal state or retrieve omitted requirements.",
+	promptGuidelines: [],
 	parameters: Type.Object({
+  section: Type.Optional(StringEnum(["summary", "objective", "tasks", "history"] as const)),
+  task_id: Type.Optional(Type.String({description: "With section=tasks, retrieve one task."})),
+  cursor: Type.Optional(Type.String({maxLength: 256, description: "Next page; repeat section/task."})),
 		verbose: Type.Optional(Type.Boolean({ description: "Full detail mode." })),
 		include_history: Type.Optional(Type.Boolean()),
 	}, { additionalProperties: false }),
@@ -66,7 +62,7 @@ pi.registerTool(defineTool({
 		core.reconcileFocusedGoalFromDisk(ctx);
 		if (core.state.goal) core.syncGoalPromptFromDisk(ctx);
 		const view = core.goalForDisplay() ?? core.state.goal;
-		const params = (_params ?? {}) as { verbose?: boolean; include_history?: boolean };
+		const params = (_params ?? {}) as { verbose?: boolean; include_history?: boolean; section?: "summary" | GoalDetailSection; task_id?: string; cursor?: string };
 		// PR E profile: legacy-v1 keeps pre-optimization verbose-by-default output;
 		// compact-v2 (default) returns a concise state line set because the full
 		// policy already lives in the injected active-goal system block.
@@ -74,15 +70,22 @@ pi.registerTool(defineTool({
 		const includeHistory = params.include_history === true || verbose;
 		const otherCount = otherOpenGoalCount(core.goalsById, core.focusedGoalId);
 		if (!view) {
-			const text = core.openGoals().length > 0
-				? `${buildUnfocusedOpenGoalsSummary(core.openGoals().length)}\n\nCall create_goal with the objective to create and focus a new goal, or ask the user to run /goal-focus to choose an open goal.`
+			const text = otherOpenGoalCount(core.goalsById, null) > 0
+				? `${buildUnfocusedOpenGoalsSummary(otherOpenGoalCount(core.goalsById, null))}\n\nCall create_goal with the objective to create and focus a new goal, or ask the user to run /goal-focus to choose an open goal.`
 				: "No goal is set in this session. Call create_goal with the objective when the user explicitly asks to start a persistent goal.";
 			return {
 				content: [{ type: "text", text }],
 				details: goalDetails(view),
 			};
 		}
-		if (verbose) {
+  if (params.section && params.section !== "summary") {
+   if (!["objective", "tasks", "history"].includes(params.section)) return {content: [{type: "text", text: "Unknown goal section."}], details: goalDetails(view)};
+   const history = params.section === "history" ? readGoalLedger(ctx) : undefined;
+   const page = goalDetailPage(view, {section: params.section, task_id: params.task_id, cursor: params.cursor}, history?.events, history?.revision);
+   return {content: [{type: "text", text: page.text}], details: {...goalDetails(view), ...(page.ok ? {page: {content: page.content, nextCursor: page.nextCursor, totalChars: page.totalChars}} : {})}};
+  }
+  if (params.cursor || params.task_id) return {content: [{type: "text", text: "Use section=objective, tasks, or history for detail retrieval; task_id requires tasks."}], details: goalDetails(view)};
+		if (verbose && !params.section) {
 			const lines: string[] = [`Goal ${view.id}: ${statusLabel(view)}, ${view.sisyphus ? "sisyphus" : "regular"}`];
 			lines.push(`Objective: ${view.objective}`, "");
 			lines.push(`Status: ${statusLabel(view)}`);
@@ -125,20 +128,17 @@ pi.registerTool(defineTool({
 			};
 		}
 
-		// compact-v2 default (PR E §53): concise state read. The full objective
-		// is kept — get_goal is an explicit state-read tool — but duplicated task
-		// headings and the lifecycle prose (already in the injected policy) are
-		// omitted.
+		// Compact state read; full requirements remain available through detail pages.
 		const lines: string[] = [`Goal ${view.id}: ${statusLabel(view)}, ${view.sisyphus ? "sisyphus" : "regular"}`];
-		lines.push(`Objective: ${view.objective}`);
+		lines.push(`Objective: ${truncateText(view.objective, 180)}${view.objective.length > 180 ? " (full: get_goal section=objective)" : ""}`);
 		if (view.taskList) {
 			const { findCurrentTask, firstPendingTask } = conciseTaskPointers(view);
 			if (findCurrentTask) {
-				const contract = findCurrentTask.verificationContract ? ` — contract: ${findCurrentTask.verificationContract}` : "";
-				lines.push(`Current task: ${findCurrentTask.id} — ${findCurrentTask.title}${contract}`);
+				const contract = findCurrentTask.verificationContract ? ` — contract: ${truncateText(findCurrentTask.verificationContract, 240)}` : "";
+				lines.push(`Current task: ${findCurrentTask.id} — ${truncateText(findCurrentTask.title, 180)}${contract}`);
 			}
 			if (firstPendingTask) {
-				lines.push(`Next pending: ${firstPendingTask.id} — ${firstPendingTask.title}`);
+				lines.push(`Next pending: ${firstPendingTask.id} — ${truncateText(firstPendingTask.title, 180)}`);
 			}
 			lines.push(`Tasks: ${buildTaskSummary(view.taskList)}`);
 		} else if (view.currentTaskId) {
@@ -149,6 +149,10 @@ pi.registerTool(defineTool({
 		if ((view.status === "paused" || view.status === "blocked") && view.pauseReason) {
 			lines.push(`Blocker: ${view.pauseReason}`);
 		}
+  if (params.include_history) {
+   const history = buildGoalHistoryBlock(view, readGoalLedger(ctx).events);
+   if (history) lines.push(history);
+  }
 		return {
 			content: [{ type: "text", text: lines.join("\n") }],
 			details: goalDetails(view),
@@ -165,17 +169,13 @@ pi.registerTool(defineTool({
 pi.registerTool(defineTool({
 	name: "create_goal",
 	label: "Create Goal",
-	description: "Create and focus a new pi goal after an explicit user request. Only call this when the user has explicitly asked to make something a persistent goal (directly, or via /goal or /sisyphus); do NOT infer a goal from an ordinary task. Creating a goal focuses it and leaves other open goals untouched.",
-	promptSnippet: "Create a persistent pi goal only when the user explicitly asks for one.",
-	promptGuidelines: [
-		"Call create_goal only when the user explicitly asks to start a long-running goal or hands you a concrete objective to pursue. Never infer a goal from an ordinary one-off task.",
-		"Creating a new goal focuses it and leaves other open goals untouched. Do not archive or replace existing goals unless the user explicitly asks through a user command.",
-		"Pass mode=\"sisyphus\" only when the user explicitly invoked Sisyphus mode.",
-	],
+	description: "Create and focus a persistent goal only on explicit user request; other open goals remain unchanged.",
+	promptSnippet: "Create a goal only when explicitly requested.",
+	promptGuidelines: ["Never infer persistent goals, Sisyphus mode, or token budgets from an ordinary task. The objective must faithfully preserve all user requirements and ordered steps."],
 	parameters: Type.Object({
-		objective: Type.String({ description: "Full goal text. For Sisyphus goals this MUST include the user's numbered steps + per-step done criteria, taken faithfully from the user's input. Length is capped by the `max objective length` goal setting (0/unset = no limit)." }),
-		mode: Type.Optional(StringEnum(["regular", "sisyphus"] as const, { description: "Goal mode. Defaults to regular. Use sisyphus only when the user explicitly invoked Sisyphus mode." })),
-		token_budget: Type.Optional(Type.Integer({ minimum: 1, description: "Optional token budget in whole tokens. Accept it only when the user explicitly supplied a budget; never invent one." })),
+		objective: Type.String({ description: "Full objective; preserve ordered steps and done criteria." }),
+		mode: Type.Optional(StringEnum(["regular", "sisyphus"] as const, { description: "Default regular; sisyphus only if requested." })),
+		token_budget: Type.Optional(Type.Integer({ minimum: 1, description: "Whole-token budget, only if supplied by the user." })),
 	}, { additionalProperties: false }),
 	executionMode: "sequential",
 	async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
@@ -311,7 +311,7 @@ pi.registerTool(defineTool({
 	const goalAtBlock = core.state.goal;
 	const focusToken = core.focusedOperationToken(goalAtBlock.id);
 	const fingerprint = buildBlockerFingerprint(goalAtBlock, reason);
-	const consult = oracleStateForFingerprint(readGoalLedger(ctx).events, goalAtBlock.id, fingerprint);
+	const consult = goalOracleState(ctx, goalAtBlock.id, fingerprint);
 
 	// One actionable result already exists.
 	if (consult.result?.disposition === "actionable") {
@@ -508,21 +508,15 @@ async function runGoalAgentPauseFlow(ctx: ExtensionContext, reason: string | und
 pi.registerTool(defineTool({
 	name: "update_goal",
 	label: "Update Goal",
-	description: "Report a terminal or pausing outcome for the current run: \"complete\" runs the independent completion auditor (completion_summary is an untrusted claim only); \"blocked\" records a distinct agent-blocked state and stops continuation per the active-goal policy; \"paused\" pauses immediately with a required reason. Never archive or abandon a goal yourself — ask the user to run /goal-clear.",
-	promptSnippet: "Report the current run as complete (audited) or blocked per the active-goal lifecycle policy; paused is immediate with a required reason.",
-	promptGuidelines: [
-		// PR E §54: capability + hard boundary here; the WHEN rules (evidence,
-		// third-identical-blocker, objective immutability) live once in the
-		// canonical active-goal policy block — do not restate them in all four
-		// schema surfaces.
-		"An optional completion_summary is passed to the auditor as an UNTRUSTED claim — it is never evidence and can never substitute for real artifacts.",
-	],
+	description: "Report complete (independently audited), blocked (three consecutive identical blockers), or paused (immediate). reason is required for blocked/paused; completion_summary is an untrusted claim.",
+	promptSnippet: "Complete, block, or pause the focused goal.",
+	promptGuidelines: [],
 	parameters: Type.Object({
-		status: StringEnum(["complete", "blocked", "paused"] as const, { description: "complete runs the independent auditor; blocked records a distinct agent-blocked state; paused is an immediate agent pause with a required reason." }),
+		status: StringEnum(["complete", "blocked", "paused"] as const, { description: "Run outcome." }),
 		reason: Type.Optional(Type.String({ description: "Required when status is paused or blocked: describe the concrete blocker." })),
-		attempted_actions: Type.Optional(Type.Array(Type.String({ maxLength: 240 }), { maxItems: 8, description: "Optional: up to 8 concrete actions already attempted against this blocker." })),
+		attempted_actions: Type.Optional(Type.Array(Type.String({ maxLength: 240 }), { maxItems: 8, description: "Actions attempted against the blocker." })),
 		suggested_action: Type.Optional(Type.String({ description: "Optional suggested next step when status is paused." })),
-		completion_summary: Type.Optional(Type.String({ description: "Optional untrusted executor claim shown to the auditor; never evidence." })),
+		completion_summary: Type.Optional(Type.String({ description: "Untrusted completion claim; never evidence." })),
 	}, { additionalProperties: false }),
 	executionMode: "sequential",
 	async execute(_toolCallId, params, _signal, _onUpdate, ctx) {