pi-goal-x 0.31.0 → 0.31.2

package/README.md

@@ -3,477 +3,124 @@
 </div>
 
 <div align="center">
-  <a href="https://pi.dev/packages" target="_blank" rel="noopener noreferrer">
+  <a href="https://pi.dev/packages?type=extension" target="_blank" rel="noopener noreferrer">
     <picture>
       <source media="(prefers-color-scheme: dark)" srcset="assets/badge-dark.svg">
-      <img src="assets/badge-light.svg" alt="TOP 1% of Pi coding agent packages: #45 of 5,380 by downloads, as of Aug 2026" width="420">
+      <img src="assets/badge-light.svg" alt="TOP 0.3% of Pi coding agent extensions: #7 of 3,216 by downloads · Sep 8, 2026 (best recorded rank)" width="480">
     </picture>
   </a>
 </div>
 
 # pi-goal-x
 
-`pi-goal-x` is a goal-management extension for [pi](https://github.com/earendil-works/pi-coding-agent).
+Adds `/goal` functionality to [pi](https://github.com/earendil-works/pi-coding-agent). The agent helps you define a goal and plan, continues working on it automatically, and submits the result to an optional independent completion auditor.
 
-It gives the agent a persistent objective, a structured plan, visible progress, and an independent completion review. Goals remain available across sessions, so the agent can continue working with the same objective and progress record.
-
-## Features
-
-### Regular goals
-
-Regular goals describe an outcome for the agent to achieve. The agent can investigate the work, choose an appropriate sequence, create tasks, and adapt its plan as it progresses.
-
-Regular goals work well for research, implementation, debugging, documentation, and other work where the desired result is clear and the execution path can be determined during the task.
-
-### Sisyphus goals
-
-Sisyphus goals describe work that should be completed in a specific order. The agent follows the listed sequence one step at a time and preserves dependencies between steps.
-
-Sisyphus goals work well for migrations, staged refactors, release procedures, data-processing workflows, and other tasks where each step prepares the way for the next.
-
-### Guided goal creation
-
-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.
-
-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
-
-The `/goal-direct` and `/sisyphus-direct` commands create a goal immediately from a complete objective.
-
-### Persistent progress
-
-Open goals are stored in `.pi/goals/`. Their objectives, tasks, status, and progress remain available across sessions and context changes.
-
-### Multiple open goals
-
-A project can contain several open goals. Each session focuses on one goal at a time, and you can switch between them with `/goal-focus`.
-
-### Tasks and subtasks
-
-Goals can include structured tasks and subtasks. The agent updates their status and records completion evidence as work progresses.
-
-### Verification contracts
-
-Goals and tasks can include plain-text completion requirements, such as:
-
-```text
-Run npm test with zero failures.
-```
-
-The completion auditor checks these requirements against evidence from the workspace.
-
-### Independent completion review
-
-When the agent reports a goal as complete, a separate pi agent reviews the objective, tasks, verification requirements, and workspace.
-
-Approved goals are archived as complete. Goals requiring additional work remain open with review feedback.
-
-### Visible status
-
-An above-editor widget shows the focused goal: its status, focus state, other open goals, time and token usage, task progress, the current task, and the goal file path.
-
-Press `Ctrl+Shift+T` to expand the widget into the full unified dashboard — the complete task tree with the current task highlighted, the current task's verification contract and evidence, the goal-level verification contract, and a recent-activity feed derived from the durable goal ledger. Press `Esc` or `Ctrl+Shift+T` again to collapse it.
-
-During an independent completion audit the widget shows a structured audit dashboard (five review stages and a progress bar); after the audit it shows the approval or changes-required result, then returns to the normal view.
-
-### Goal controls
-
-Slash commands let you pause, resume, revise, select, unfocus, and archive goals.
-
-### Configurable behaviour
-
-The settings menu controls task support, verification contracts, subtask depth, goal selection, and the completion auditor.
+The extension saves goal objectives, tasks, and progress across sessions. You can pause, resume, revise, or switch goals as your work changes.
 
 ## Install
 
-Install from npm:
-
 ```bash
 pi install npm:pi-goal-x
 ```
 
-Install from a local checkout:
-
-```bash
-pi install .
-```
-
-Run it once from a local checkout:
+## Create a goal
 
-```bash
-pi -e .
+```text
+/goal Add CSV export to the reports page, with documentation and tests.
 ```
 
-## Choose a goal style
+The agent discusses the goal with you, asks focused questions where needed, and proposes an objective, task plan, and completion requirements. You review the proposal and choose whether to use the completion auditor. Once you confirm, the agent starts working and continues automatically while the goal is active.
 
-Use a **regular goal** when you have a clear outcome and want the agent to determine how to reach it.
+You can specify completion requirements, such as passing the test suite or producing a report with every required section. The agent tracks tasks and subtasks, records evidence, and works toward those requirements. If it gets blocked and needs your input, you can resolve the issue and resume.
 
-For example:
+If you already have a complete objective, use `/goal-direct <objective>` to create the goal and start immediately without drafting.
 
-```text
-/goal Add account deletion to the application, including the user interface, data cleanup, documentation, and tests.
-```
+## Goal types
 
-The agent can decide how to investigate the application, divide the work, and order the implementation.
+| Type | Behaviour | Example uses |
+| --- | --- | --- |
+| **Regular** — `/goal` | An outcome to achieve, with the agent choosing and adapting the plan. | Features, debugging, research, and documentation. |
+| **Sisyphus** — `/sisyphus` | An ordered plan that the agent follows one step at a time. | Migrations, staged refactors, and release procedures. |
 
-Use a **Sisyphus goal** when you already know the required sequence and want the agent to follow it step by step.
-
-For example:
+For an ordered goal, you can provide the steps or define them with the agent:
 
 ```text
 /sisyphus Migrate authentication in this order:
 1. Add the new token validator.
-2. Update login to use it.
-3. Update session refresh to use it.
-4. Remove the old validator.
-5. Run the authentication test suite.
-```
-
-The agent completes the migration in the stated order, preserving the dependency between each stage.
-
-## Create a guided goal
-
-Start a guided regular goal:
-
-```text
-/goal add structured logging to the authentication module
-```
-
-The agent can ask questions and propose a complete objective and task plan. Confirm the proposal to create the goal and begin work.
-
-The questionnaire dialog never truncates the question; when it is taller than the terminal it stays within the height and scrolls — `PgUp`/`PgDn` page and `Ctrl+↑/↓` line-scroll without moving the selection, `↑/↓` selection auto-follows into view, and a `▲`/`… +N more` edge indicator shows what is clipped.
-
-Start a guided Sisyphus goal:
-
-```text
-/sisyphus prepare and perform the customer-data migration
-```
-
-The agent can help define the ordered steps and present them for confirmation.
-
-## Create a goal directly
-
-Use `/goal-direct` when the objective already describes a complete outcome:
-
-```text
-/goal-direct Add a health-check endpoint that verifies database connectivity, returns the service status as JSON, documents the endpoint, and includes passing tests.
-```
-
-This creates and focuses the regular goal immediately.
-
-Use `/sisyphus-direct` when the objective already contains the complete ordered process:
-
-```text
-/sisyphus-direct Upgrade the payment integration in this order:
-1. Add support for the new API version.
-2. Update payment creation.
-3. Update refund handling.
-4. Migrate the test fixtures.
-5. Run the payment test suite.
-6. Remove the old API integration.
-```
-
-This creates and focuses the ordered goal immediately.
-
-## Manage goals
-
-List open goals:
-
-```text
-/goal-list
+2. Update login and session refresh to use it.
+3. Remove the old validator.
+4. Run the authentication tests.
 ```
 
-Show the focused goal:
-
-```text
-/goal-status
-```
+Use `/sisyphus-direct <objective>` to start an ordered goal without drafting.
 
-Run read-only storage/runtime health checks:
+## Tasks and subtasks
 
-```text
-/goal-status health
-```
+The agent can divide a goal into tasks and subtasks, each describing part of the work required to complete it. During guided goal creation, you review the proposed plan before work begins.
 
-Re-read goal storage caches (pool, ledger, settings) from disk and report what changed — picks up external edits to `.pi` files without file watchers:
+For example, a CSV export goal could have this task plan:
 
 ```text
-/goal-refresh
+Add CSV export to reports
+├─ Review the report data and active filters
+├─ Implement CSV export
+│  ├─ Generate the CSV from filtered results
+│  └─ Add a download button
+├─ Test the export
+└─ Document how to use it
 ```
 
-Select an open goal for the current session:
+As work progresses, the agent marks the current task, records completed work, and explains any skipped tasks. The dashboard shows what is done and what remains, including progress within subtasks. Task progress is saved when you pause and remains available in later sessions.
 
-```text
-/goal-focus
-```
+Tasks can also have their own completion requirements—for example, “The download contains only rows matching the active filters.” The agent records evidence against those requirements, and the completion auditor uses that evidence when reviewing the overall result.
 
-Remove the current session’s focus while keeping the goal open:
+Use `/goal-tweak <change>` to discuss revisions to the goal and its plan. Task tracking, completion requirements, and subtask depth are configurable in `/goal-settings`.
 
-```text
-/goal-unfocus
-```
+## Completion auditor
 
-Revise the focused objective and task plan:
+When enabled, a separate agent reviews the work before the goal is accepted as complete. It checks the objective, tasks, recorded evidence, completion requirements, and workspace.
 
-```text
-/goal-tweak <change>
-```
+If the auditor approves, the goal is archived as complete. If it identifies unmet requirements, the goal remains open with feedback describing the work still needed. You can choose the auditor model in `/goal-settings` and toggle auditing for the focused goal with `Ctrl+Shift+A`.
 
-Pause or resume the focused goal:
+## Progress and goal controls
 
-```text
-/goal-pause
-/goal-resume
-```
+The dashboard above the editor shows the goal's status, task progress, current task, elapsed time, and token usage. Press `Ctrl+Shift+T` to expand it for the full task tree, completion requirements, evidence, and recent activity. Audit progress and results appear there too.
 
-Archive the focused goal:
-
-```text
-/goal-clear
-```
-
-Cancel an unconfirmed guided draft:
-
-```text
-/goal-cancel
-```
-
-Open the settings menu:
-
-```text
-/goal-settings
-```
-
-Pressing `Esc` during active work pauses the goal.
-
-## Tasks and verification
-
-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:
-
-```text
-Run npm test with zero failures.
-```
-
-```text
-Confirm the new command appears in the help menu.
-```
-
-```text
-Verify that the generated report contains every required section.
-```
-
-## Unified dashboard
-
-`pi-goal-x` renders one dashboard component in two modes; the above-editor widget, `/goal-status`, and the completion flow all derive from the same presentation model, so they can never disagree about the data.
-
-### Compact mode
-
-Always visible above the editor while a goal is focused:
-
-```text
-╭─ pi-goal-x ─ Add CSV export to reports ────────────────────────────╮
-│ goal: running [12m47s 18.2K] (+2 open)                             │
-├─ Tasks · ✓3 done · 2 open ──────────── [█████░░░] · Sub 2/3 [██░░] ┤
-│ ✓ t1  Review reports page and data source                          │
-│ ✓ t2  Implement filtered CSV export                                │
-│ ▸ t3  Add the download button ☑ ▸ 2/3                              │
-│ · t4  Add documentation                                            │
-│ … +1 more task                                                     │
-│ Current  t3 · Add the download button                              │
-│ Verify   Run npm test with zero failures.                          │
-│ File     .pi/goals/active_goal_...                                 │
-╰─ Ctrl+Shift+T: expand tasks─────── Ctrl+Shift+A: toggle auditor ● ─╯
-```
-
-The green/gray `●` at the bottom-right of the border is the focused goal's
-independent-auditor status (green = on, gray = off). Wide/medium footers
-right-align the `Ctrl+Shift+A: toggle auditor` note beside the dot — it
-shows the shortcut that turns the auditor on and off; narrow/minimal keep
-just the dot.
-
-### Expanded mode
-
-`Ctrl+Shift+T` expands the same component: full task tree (✓ complete, ▸ current, ~ skipped, · pending), the current-task block with its contract and evidence, goal-level verification, and recent activity.
-
-```text
-├─ Progress ──────────────────────────────────────────────────────────┤
-│ [██████░░░░] 3/5 tasks · 60%                                       │
-├─ Tasks ─────────────────────────────────────────────────────────────┤
-│ ✓ t1  Review reports page and data source                          │
-│ ✓ t2  Implement filtered CSV export                                │
-│ ▸ t3  Add the download button                                      │
-│   ✓ t3.1  Add loading state                                         │
-│   · t3.3  Add error handling                                        │
-│ · t4  Add documentation                                             │
-├─ Current task ──────────────────────────────────────────────────────┤
-│ t3 · Add the download button                                        │
-│ Subtasks [███████░░░] 2/3 · 67%                                     │
-│ Contract: The button downloads a CSV using the active filters.      │
-├─ Verification ──────────────────────────────────────────────────────┤
-│ Run npm test with zero failures.                                    │
-└─ Esc/Ctrl+Shift+T: collapse ────────────────────────────────────────┘
-```
-
-Every rendered line is width-aware: the dashboard adapts to wide, medium, narrow, and very-narrow terminals and never overflows the available width. It follows a pastel theme palette with a monochrome fallback: a light steel-gray-blue outer frame (`mdLink`) with gray interior rules, pastel-amber task rows with colour-coded markers and ids (✓ complete green, ▸ current teal, ~ skipped gray, · pending amber), accent-tinted progress and brand, and status symbols in their state color.
-
-The task list is a scrollable **window** that by default is anchored to the most recently completed task — recent completions stay visible instead of the earliest tasks. The expanded dashboard is modal and scrolls with the plain `↑/↓`, `PgUp/PgDn`, and `Home/End` keys; the compact widget keeps the editor's arrows untouched and scrolls with the free `Ctrl+Shift+↑/↓` chords (pi leaves those unbound). A new completion re-anchors the window.
-
-See [`docs/unified-dashboard.md`](docs/unified-dashboard.md) for the full layout specification, status states, scrolling behavior, and migration behavior.
-
-## Completion review
-
-When the agent reports a goal as complete, `pi-goal-x` starts an independent completion review.
-
-The auditor examines:
-
-* The objective
-* The task plan and recorded evidence
-* Verification contracts
-* The current workspace
-
-An approved goal is archived as complete, and the archive path is reported. Review feedback is added to any goal that requires further work, and the dashboard shows the changes-required result before returning to the normal view.
-
-Press `Esc` to stop an active audit (completing without audit is recorded explicitly and never presented as independently approved).
-
-## Goal storage
-
-Open goals are stored in:
-
-```text
-.pi/goals/
-```
-
-Completed and cleared goals are stored in:
-
-```text
-.pi/goals/archived/
-```
-
-Each session can focus on one goal while the project keeps other goals open.
-
-## Session checkpoint recovery
-
-Auto-continue checkpoints are tiny structured markers (≤160 chars) that
-trigger the next turn; the full goal state is injected once per turn by the
-extension and is never persisted into checkpoints. Sessions created by older
-versions may still contain large "legacy" full-prompt checkpoints.
-
-Check `/goal-recovery` or `/goal-status health` for a read-only report:
-
-```text
-Session checkpoints:
-  total: 851
-  legacy full checkpoints: 851
-  checkpoint content: 5.4 MB
-  projected content after recovery: 92 KB
-```
-
-To repair an affected session file, close Pi first (the tool refuses to run
-while a live session could be open), then:
-
-```bash
-# Report only — writes nothing:
-pi-goal-x-recover --session <session.jsonl>
-
-# Repair (creates a timestamped backup, rewrites only checkpoint entries):
-pi-goal-x-recover --session <session.jsonl> --apply --confirm-pi-closed
-```
-
-Recovery preserves every entry id and parent link, keeps all non-goal lines
-byte-identical (including malformed lines), and is idempotent. Rollback is
-the timestamped `.backup-*` file created next to the session.
+A project can have several open goals, with one focused goal per session. Switch with `/goal-focus`, pause with `/goal-pause`, or use `/goal-tweak` to discuss changes to the current goal. Pressing `Esc` during active work also pauses the goal; in the expanded dashboard, it collapses the view.
 
 ## Commands
 
-```text
-/goal [seed]                 Start a guided regular goal
-/sisyphus [seed]             Start a guided ordered goal
-/goal-direct <objective>     Create a regular goal immediately
-/sisyphus-direct <objective> Create an ordered goal immediately
-/goal-list                   List open goals
-/goal-status                 Show the focused goal (unified dashboard)
-/goal-status verbose         Show the focused goal with full diagnostic detail
-/goal-status health          Check goal storage/runtime health (read-only)
-/goal-refresh                Re-read storage caches and report external changes
-/goal-recovery               Read-only recovery report; `/goal-recovery repair` fixes stale locks + snapshot after confirmation
-/goal-focus                  Select an open goal
-/goal-unfocus                Remove the session’s focus
-/goal-tweak <change>         Revise the focused goal
-/goal-pause                  Pause the focused goal
-/goal-resume                 Resume a paused or blocked goal
-/goal-settings               Open the settings menu
-/goal-clear                  Archive the focused goal
-/goal-cancel                 Cancel the current draft
-```
-
-## Configuration
-
-Settings resolve per setting in this order (highest wins):
-
-```text
-environment > project layer > global layer > defaults
-```
-
-Files:
-
-```text
-global:  ~/.pi/pi-goal-x-settings.json   (or $PI_CODING_AGENT_DIR, or $PI_GOAL_GLOBAL_SETTINGS_FILE)
-project: <cwd>/.pi/pi-goal-x-settings.json   (or $PI_GOAL_SETTINGS_FILE)
-```
-
-Define shared configuration once in the global file and override per project. Explicit `false`/`0` values in a lower layer override inherited values; nested `keybindings` inherit per key. `/goal-settings` shows each row's effective value and source, can switch the edited scope, and can remove a local override to return to inheritance.
-
-Use `/goal-settings` to configure task lists, verification contracts, subtask depth, automatic goal selection, and completion auditing. Goal objectives have no hard length limit by default; set `objectiveMaxChars` (or `PI_GOAL_OBJECTIVE_MAX_CHARS`, `0` = no limit) to cap objective length across `create_goal`, `propose_goal_draft`, and `/goal-tweak`.
-
-Configure the task shortcuts in the same file when the terminal captures the defaults:
-
-```json
-{
-  "keybindings": {
-    "dashboard": {
-      "toggleExpand": "ctrl+shift+t",
-      "scrollUp": "ctrl+shift+up",
-      "scrollDown": "ctrl+shift+down"
-    }
-  }
-}
-```
-
-The default task bindings are `ctrl+shift+t`, `ctrl+shift+up`, and `ctrl+shift+down`. Use pi key names such as `ctrl+shift+up`.
-
-### Blocker Oracle (opt-in)
-
-When an active goal reports blocked, a stronger read-only model can be consulted once per distinct blocker before the goal is allowed to stop. Off by default; configure under `/goal-settings → Blocker Oracle`:
-
-```json
-{
-  "oracle": {
-    "enabled": true,
-    "provider": "anthropic",
-    "model": "<a stronger model>",
-    "maxFailedAttemptsPerBlocker": 2
-  }
-}
-```
+| Command | What it does |
+| --- | --- |
+| `/goal [idea]` | Discuss, plan, and confirm a regular goal. |
+| `/sisyphus [idea]` | Discuss, plan, and confirm an ordered goal. |
+| `/goal-direct <objective>` | Create and start a regular goal immediately. |
+| `/sisyphus-direct <objective>` | Create and start an ordered goal immediately. |
+| `/goal-list` | List open goals. |
+| `/goal-status` | Show the focused goal and its progress. |
+| `/goal-focus` | Choose an open goal to work on. |
+| `/goal-unfocus` | Leave the current goal open without focusing on it. |
+| `/goal-tweak <change>` | Revise the current goal with the agent. |
+| `/goal-pause` | Pause work on the focused goal. |
+| `/goal-resume` | Resume a paused or blocked goal. |
+| `/goal-clear` | Archive the focused goal after confirmation. |
+| `/goal-cancel` | Cancel an unconfirmed draft. |
+| `/goal-settings` | Configure goal behaviour and the auditor. |
+
+For troubleshooting, use `/goal-status verbose` for more detail, `/goal-status health` or `/goal-recovery` to check for problems, and `/goal-refresh` to reload saved goals and settings after external changes. `/goal-recovery repair` offers repairs after confirmation.
+
+## Settings
+
+Open `/goal-settings` to change these options. You can save defaults for all projects, override them for the current project, or remove an override to use the inherited value.
+
+| Setting | What it controls |
+| --- | --- |
+| Task tracking (`disableTasks`) | Turn task lists on or off. Set to `true` to disable them. |
+| Subtask depth (`subtaskDepth`) | Limit how many levels of subtasks the agent can create. |
+| Completion requirements (`disableContracts`) | Turn explicit goal and task completion requirements on or off. Set to `true` to disable them. |
+| Auditor disabled | Turn off independent completion review. |
+| Auditor provider, model, and thinking level | Choose which model reviews completed work and its reasoning effort. |
 
-Both `provider` and `model` must be set explicitly — the executor model is never used as a silent fallback. The Oracle session can only read files (`read`, `grep`, `find`, `ls`) and returns structured advice. Actionable advice keeps the goal running until you attempt it; advice that needs human input lets the goal block immediately.
 
 ## License
 

package/assets/badge-dark.svg

@@ -0,0 +1,18 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="480" height="54" viewBox="0 0 480 54" role="img" aria-label="TOP 0.3% of Pi coding agent extensions: #7 of 3,216 by downloads · Sep 8, 2026 (best recorded rank)">
+  <!-- Dark mode -->
+  <style>
+    .frame { fill: #14181f; stroke: #2a3040; stroke-width: 1; }
+    .rank { font: 700 15px ui-monospace, 'SF Mono', Menlo, Consolas, monospace; letter-spacing: 0.04em; fill: #d4a656; }
+    .label { font: 400 13px ui-monospace, 'SF Mono', Menlo, Consolas, monospace; fill: #e8e6df; }
+    .meta { font: 400 11px ui-monospace, 'SF Mono', Menlo, Consolas, monospace; fill: #7d8494; }
+    .divider { stroke: #2a3040; stroke-width: 1; }
+    .link { text-decoration: none; }
+  </style>
+  <a class="link" href="https://pi.dev/packages?type=extension" target="_blank" rel="noopener noreferrer">
+    <rect class="frame" x="0.5" y="0.5" width="479" height="53" rx="6"/>
+    <text class="rank" x="18" y="34">TOP 0.3%</text>
+    <line class="divider" x1="128" y1="13" x2="128" y2="41"/>
+    <text class="label" x="143" y="25">of Pi coding agent extensions</text>
+    <text class="meta" x="143" y="41">#7 of 3,216 by downloads · Sep 8, 2026</text>
+  </a>
+</svg>

package/assets/badge-light.svg

@@ -0,0 +1,18 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="480" height="54" viewBox="0 0 480 54" role="img" aria-label="TOP 0.3% of Pi coding agent extensions: #7 of 3,216 by downloads · Sep 8, 2026 (best recorded rank)">
+  <!-- Light mode -->
+  <style>
+    .frame { fill: #f6f8fa; stroke: #d0d7de; stroke-width: 1; }
+    .rank { font: 700 15px ui-monospace, 'SF Mono', Menlo, Consolas, monospace; letter-spacing: 0.04em; fill: #9a6700; }
+    .label { font: 400 13px ui-monospace, 'SF Mono', Menlo, Consolas, monospace; fill: #1f2328; }
+    .meta { font: 400 11px ui-monospace, 'SF Mono', Menlo, Consolas, monospace; fill: #59636e; }
+    .divider { stroke: #d0d7de; stroke-width: 1; }
+    .link { text-decoration: none; }
+  </style>
+  <a class="link" href="https://pi.dev/packages?type=extension" target="_blank" rel="noopener noreferrer">
+    <rect class="frame" x="0.5" y="0.5" width="479" height="53" rx="6"/>
+    <text class="rank" x="18" y="34">TOP 0.3%</text>
+    <line class="divider" x1="128" y1="13" x2="128" y2="41"/>
+    <text class="label" x="143" y="25">of Pi coding agent extensions</text>
+    <text class="meta" x="143" y="41">#7 of 3,216 by downloads · Sep 8, 2026</text>
+  </a>
+</svg>

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,7 +1,7 @@
 {
   "name": "pi-goal-x",
-  "version": "0.31.0",
-  "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.",
+  "version": "0.31.2",
+  "description": "Adds /goal to pi: conversational goal planning, flexible or ordered goals, persistent progress, and an independent completion auditor.",
   "license": "MIT",
   "author": "pi-goal-x contributors",
   "type": "module",
@@ -36,7 +36,9 @@
     "docs/architecture.md",
     "docs/pi-autoresearch-survey.md",
     "docs/pi-goal-x-unified-dashboard-plan.md",
-    "docs/unified-dashboard.md"
+    "docs/unified-dashboard.md",
+    "assets/badge-light.svg",
+    "assets/badge-dark.svg"
   ],
   "pi": {
     "extensions": [