pi-goal-list-loop-audit 0.38.98 → 0.38.104

package/CHANGELOG.md

@@ -1,5 +1,154 @@
 # Changelog
 
+## Unreleased
+
+Untagged work since 0.38.104. It stays under this heading until the release
+commit renames it (docs/RELEASING.md); these are descriptive milestones, not
+invented version headers.
+
+## 0.38.104 — prose stops grinding the audit (2026-09-29)
+
+### The audit cap covers every round that failed to settle the goal
+
+- The regression shield (auditor approved, evidence contract unmet) and an
+  aggressive `IMPOSIBLE(partial)` verdict both re-activate the goal without
+  disapproving it, so the v0.38.107 hard cap — which counts `disapproved`
+  rounds — returned 0 for both and let them cycle forever. They now pause on
+  the same `auditCapHard`, offering accept / resume / tweak / cancel.
+- `countTrailingUnsettledRounds` is the shared primitive: every trailing round
+  that failed to *settle* the goal, across all verdict classes. An approval and
+  an infra error break the streak; mechanical pre-audit gate rows stay
+  transparent.
+- An alternating primary/fallback auditor ladder no longer defeats the cap by
+  re-baselining the comparable streak to 1 every round. The guard that detects
+  this (`trailingStreakGraderStable`) had no production caller; it is wired
+  now, and the pause reason says which count it used.
+
+### Honesty fixes found by the same pass
+
+- `/goal timeline` counted objections with a raw `superseded` filter while the
+  runtime reads them through a migrate-on-read backfill, so it could tell the
+  user to re-submit work the loop had already accepted.
+- The continuation self-heal budget could never be refilled: the turn-start
+  reset was gated on a live timer, but exhaustion nulls the timer without
+  clearing the counter — so the next stuck episode reported an already-spent
+  budget with zero re-probes.
+- A blank subtask title reached `taskList` persistence and made the goal's own
+  state file fail the published schema. Rejected at the boundary now.
+- `INSTALL.md` said the auditor runs extension-less by default; the mirror is
+  on by default, as `README.md` correctly said.
+- The published schema now types the five completion-claim fields the terminal
+  render actually writes, plus the task deferral stamp, and drops
+  `wallDeadlineAt` — a field no GLLA code has ever written.
+
+### Provider walls: honest classification and bounded redaction
+
+- An empty provider response is a transient glitch, not a quota wall, and a
+  real `Retry-After` reset outranks the eager first-retry path instead of being
+  shortened to 5s.
+- The numeric `5xx` match is anchored, and the redaction cascade is bounded by
+  a fraction of the report's lines so sanitising cannot destroy the evidence.
+- The between-tasks compaction threshold is a named token budget
+  (`runProactiveCompactionIfDue`), not an "emergency" that could fire on any
+  threshold.
+
+### Durable state: writes that either land or say they did not
+
+- A retried continuation dispatch is built as a copy and adopted only after
+  `persistDispatchRecord` succeeds, so an unwritable `.pi-glla` can no longer
+  re-send an identical payload from a durable `retryCount = 0`.
+- The subagent RPC registry releases its listeners instead of retaining every
+  rebound session's bus for the life of the process.
+- A finished `result.json` classifies its job dir as dead even when the parent
+  PID was reused, so a proven-finished dir is reaped instead of leaking.
+- `mainModelRetryMinutes`, `auditFeedbackChars` and the thinking-level pins are
+  normalized at load, so no surface can display a value the runtime ignores.
+- Summary and widget clipping is code-point safe, and `complete_goal`'s
+  `newObjective` path goes through `updateGoal` with an explicit revision.
+
+### A park is not terminal
+
+- The bounded-horizon and identical-failure auditor parks re-probe themselves
+  instead of dead-ending the goal.
+- An unacknowledged continuation turn start self-heals on a doubling,
+  probe-bounded cadence; the loop's live event log is no longer tracked.
+
+### The treadmill ceiling reaches the path the field actually takes
+
+- The disapproval hard cap (0.38.103) was wired only into `complete_goal`'s
+  inline settlement. Real audits settle through the detached driver minutes or
+  hours later, which had no cap — under aggressive mode (the default) every hit
+  became a TODO and the goal ground forever (hellhunter 12 rounds, junk-runner
+  9, zero cap pauses). The detached path now pauses on the same
+  comparable-disapproval streak. See `audit/STUCK-AT-LAST-PART-2026-09-28.md`.
+
+### Tests: observable, hang-proof, orphan-free
+
+- `scripts/run-tests.mjs` wraps the serialized suite with a progress
+  heartbeat, a bounded stall watchdog, and a teardown that takes the suite
+  down with it instead of leaving a runaway. The suite child is spawned
+  detached, so the documented process-group kill is real rather than an
+  ESRCH-swallowed no-op; `test:all` and both CI jobs run through the wrapper
+  and are bounded by `timeout-minutes`.
+
+### Prose stops grinding the audit (field bugs 2026-09-29)
+
+- A verification contract with list structure now defines its checkable items
+  by the list: a wrapped prose preamble is commentary, not criteria. The
+  dracon-log contract's parenthetical preamble had split into "items" no
+  evidence could reference, so the shield blocked two genuine approvals
+  forever. Shapeless contracts keep the every-line behavior.
+- Mechanical extraction no longer gates on prohibited commands: backticked
+  commands under negation ("no longer uses `bun run dev`") are skipped, and
+  never-exiting server-mode commands (`bun run dev`, `npm run serve`,
+  `*server.py`, …) are rejected at extraction instead of burning the round's
+  time budget. The AI auditor judges those items instead.
+- The detached worker's stderr capture accumulates instead of last-chunk-wins
+  and strips control characters, so a trailing BEL flush can no longer
+  overwrite the real failure — the 90+ field errors recorded as `error: BEL`
+  will carry their true cause next time
+  (`scripts/auditor-stderr-diagnostic.mjs`).
+
+### Audit pass 2026-09-28 (findings + fixes in this section's range)
+
+- An approved audit no longer falls through the settlement driver into the
+  residual-failure tail, which wrote a false "infrastructure error" warning and
+  a contradictory `approved: false` evidence record after a successful
+  completion.
+- `/goal verify` checks for an owed settlement before writing its manual claim,
+  so an approved-but-unarchived goal keeps its approval instead of being
+  re-audited from scratch.
+- A branch-changed loop park names the loop surface and is resumable, so the
+  loop's iteration, best value and history stay reachable.
+- The settings menu no longer promises a 24h recovery ceiling the default
+  aggressive mode removes, and renders the legal retention value `0` as a value
+  instead of "?".
+
+## 0.38.103 — the treadmill gets a ceiling: inconclusive gates and a hard disapproval cap (2026-09-27)
+
+- **A mechanical gate the host kills is no longer a disapproval.** Timeout/kill/output-limit/abort outcomes now classify `inconclusive` and enter the durable infra-retry plan instead of the rework loop — a killed gate is evidence of nothing about the work. Gate budgets also scale with host load (1× at load ≤ cpus, capped 2× past it; `mechanicalLoadScale`, default on, global-only).
+- **Consecutive disapprovals hit a hard ceiling in every mode.** `auditCapHard` (default 8: soft cap 5 + three grace rounds, `0` = unlimited) pauses with a decision even under aggressiveMode keep-going. Cap pauses now offer **Accept with follow-ups** first: archives complete with residuals while the reviewer mines the disapproval reports into `/list` items (`(/goal accept)` in the decision picker).
+- **Required fixes carry severity.** The brief mandates leading `[HIGH]`/`[MED]`/`[LOW]` tags per item plus a severity-honesty rule; each disapproval records a severity census on its objections ledger event. Advisory this release — automatic severity gating follows once field label distribution is measured.
+
+## 0.38.102 — audits converge, and the card stops burying its own gist (2026-09-27)
+
+- **The audit brief now bounds what may block approval and defines a reachable bar.** `CHANGE SCOPE` separates blocking defects (in the changed paths, an unverified contract item, a regression this change causes) from non-blocking ones (pre-existing debt outside the change, style, anything untied to a changed path); it also states that the auditor's own prior findings are inputs to re-check, not new targets — that line breaks the self-feeding loop where each round grew the 148KB findings ledger the next round then audited. `WHAT APPROVED MEANS` gives the checkable bar. `REWORK ROUND` reframes round N as “are the PRIOR objections closed?”, with a new in-scope defect still blocking. Measured 612 attempts fleet-wide: the loop was non-terminating (8/8, 13/13, and 20× consecutive disapprovals at 63h elapsed), not slow. (audit/ENDLESS-AUDIT-CONVERGENCE-2026-09-27.md)
+- **An over-budget tool no longer discards the whole audit.** A verification step that blew the 5-minute per-tool budget used to kill the worker, throwing away up to 64 completed tool calls; the goal then re-audited from zero and blew the same budget on the same loaded host. The worker now cancels that tool, resumes with a brief carrying the completed calls, and the parent holds its hard kill for `TOOL_CANCEL_GRACE_MS`. An approving verdict from a verification-incomplete attempt is refused as retryable infrastructure — never laundered into a disapproval, which would send the agent into rework for a load problem. (audit/NON-DESTRUCTIVE-AUDIT-TOOL-TIMEOUT-2026-09-26.md)
+- **A title-like goal objective no longer livelocks.** `# MONSTER MINECRAFT — a first-person voxel survival game` tripped a bare markdown-heading heuristic, so it was paused as suspicious and the queued repair never rewrote the objective; every resume re-tripped it. A heading is now suspicious only when it is a bare report-section label.
+- **A torn `progress.json` read no longer fails a healthy audit.** It is telemetry — the verdict arrives in `result.json` — so an unreadable snapshot is now tolerated on a time bound instead of costing the attempt.
+- **The terminal card stopped burying its own gist.** A `leftOut` field carrying seven scope decisions rendered as one ~900-character bullet; `Remaining` and `Next` now expand an inline `(1) … (2) …` enumeration into an indented list. In `What Changed` the outcome is the bullet and the evidence rides indented beneath it, so the reader sees what changed before reading why.
+- **New store thumbnail**: a mission-control radar with one verified target among several, replacing the generic checkmark. `aggressiveMode` semantics and the `auditCap` gate are deliberately unchanged.
+
+## 0.38.100 — the audit scopes itself to the recorded change set (2026-09-25)
+
+- Execution now records the touched paths behind the `fileWrites` counter (`telemetry.files`, first-seen order, deduped, capped at 100 with an overflow count), and the detached-audit brief opens with that change set: verify THESE first instead of exploring unboundedly. The list scopes the START of the audit, never its boundary — subagent writes, shell redirections, and deletions bypass capture, so the brief says so and the auditor still follows the evidence outward. The recorded-facts fallback summary names the paths too (bounded), replacing "changed paths were not captured" for tracked goals.
+
+## 0.38.99 — the detached audit has one legible lifecycle and one settlement (2026-09-25)
+
+- The isolated completion audit now names its state instead of guessing: **starting** (claim durable, worker not reporting yet), **running** with its last durable activity, **settling** (approved, archive owed), **approved** (settlement durable), and **recovery-needed** (parked, with a real `/goal resume` action). The widget, status line, goal markdown, and restart recovery all read the same projection, so a claim that a crash left mid-settlement no longer renders as “awaiting completion review” (audit/DETACHED-AUDIT-LIFECYCLE-2026-09-25.md).
+- An unresolved audit can no longer look finished. The approval path persists the verdict on the claim **before** any archive is attempted, keeps that approved claim when the archive fails (so the settlement stays re-drivable), and gates every terminal surface on a durable verdict plus a landed archive. A cold session that finds an approved-but-unarchived claim finishes it without re-running the auditor.
+- Last activity is durable now: the detached worker's real event stamps a throttled heartbeat on the claim, so after a restart a silent attempt is reported as no-progress instead of looking live — the in-process watchdog does not exist in a fresh session.
+
 ## 0.38.98 — audited lifecycle hardening and change-first completion (2026-09-24)
 
 - Fresh audit repairs make goal/list/loop state durable across persistence failures, session replacement, compaction failure, repair promotion, and branch-mode completion. Confirmed loop refinements now apply atomically instead of mutating live state before the spec is safely written.

package/INSTALL.md

@@ -193,11 +193,12 @@ re-fired behind your back.
 
 ## Auditor model requirement
 
-The completion auditor runs in a detached fresh pi RPC process with no
-extensions, skills, prompt templates, themes, or context files by default. Its
-model therefore needs to work with a built-in pi provider in an extension-less
-session. If your normal session model comes from an extension provider, select
-a compatible model in `/glla` under the Auditor settings.
+The completion auditor runs in a detached fresh pi RPC process. By default it
+mirrors your session's extension packages (so an extension-provided model
+works in the auditor too), but it loads no skills, prompt templates, themes, or
+context files. If you would rather the auditor run against only built-in pi
+providers, set **Auditor mirror session extensions** to off in `/glla` and then
+select a compatible model under the Auditor settings.
 
 The worker resolves `pi` from `PATH` and inherits normal provider configuration.
 If required, point it at a specific binary:

package/docs/DESIGN-long-running-supervision.md

@@ -125,14 +125,14 @@ and the status/history surfaces. The human layer follows two different purposes:
   Verification Summary table (Quality Gate | Command | Scope | Status | Notes
   when supplied), and Final Repository State.
 
-Both surfaces retain the independent auditor verdict and the full six-label
+Both surfaces retain the independent completion review and the full six-label
 machine recap. A lone approval may be promoted to the chat headline because
-it is a durable verdict fact, not because tests passed. Width-bound and
+it is a durable review fact, not because tests passed. Width-bound and
 external surfaces use the compact single-line projection of all six labels.
 Every terminal goal notification, including version-bearing already-shipped
 claims and explicit cancellation, carries the change-first human view or the
 compact projection; loop notifications do the same. The executor recap and
-independent auditor verdict stay separate: an approval is not manufactured from
+independent completion review stay separate: an approval is not manufactured from
 the presence of a summary.
 
 Metric-loop stops use the same six-label contract in their durable loop state

package/docs/DESIGN.md

@@ -499,20 +499,24 @@ This is a **clean break** by decision of the user. We do not interop with `pi-go
 > **Superseded by consolidation (v0.8.0).** The planned per-loop files below
 > never shipped: loops 1+2 live together in `extensions/loops/goal.ts`
 > (one state machine, one loop driver), loop 3's helpers in
-> `extensions/loops/forever.ts`, rendering in `goal-loop-display.ts`,
-> drafting inline in `goal.ts` + `prompts/`. Kept for history.
+> `extensions/goal-loop-forever.ts`, rendering in `goal-loop-display.ts`,
+> drafting inline in `goal.ts` + `prompts/`. Kept for history. v0.38.108: the
+> "Lines" column below is a snapshot of that plan, not a claim about today's
+> tree — where the plan and the shipped path disagree, the shipped path is
+> `extensions/goal-loop-forever.ts` and the auditor prompt is built in
+> `extensions/goal-loop-auditor.ts` (there is no prompt file).
 
 | File | Purpose | Lines |
 |---|---|---|
 | `extensions/loops/goal.ts` | Loops 1+2 (single goal + list of goals) | shipped |
-| `extensions/loops/forever.ts` | Loop 3 (metric loop helpers) | shipped |
+| `extensions/loops/forever.ts` | Loop 3 (metric loop helpers) — plan name; shipped as `extensions/goal-loop-forever.ts` | planned |
 | `extensions/goal-loop-core.ts` | Shared state machine, types, JSONL | shipped |
 | `extensions/goal-loop-auditor.ts` | Auditor prompt + compatibility helper | shipped |
 | `extensions/goal-loop-auditor-process.ts` | Detached worker protocol, IPC, and shield revalidation | shipped |
 | `scripts/goal-auditor-worker.mjs` | Extension-less RPC auditor child | shipped |
 | `extensions/goal-loop-display.ts` | Status line + /goal status rendering | shipped |
 | `prompts/goal-loop-continuation.md` | Templated continuation prompt | ~80 |
-| `prompts/goal-loop-auditor.md` | Templated auditor prompt | ~80 |
+| `prompts/goal-loop-auditor.md` | Templated auditor prompt — never shipped; the prompt is built in `extensions/goal-loop-auditor.ts` | planned |
 | `prompts/goal-loop-draft.md` | Templated drafting prompt | v0.2.0 |
 | `schemas/goal.schema.json` | JSON Schema for goal state | ~50 |
 

package/docs/INDEX.md

@@ -16,7 +16,7 @@ Policy contracts and recent changes live in the `audit/` directory of the
   failback; v0.35.9 hardened cross-version npm tarball checks; v0.35.10
   handles multi-entry npm dry-run reports; v0.35.11 accepts both npm report
   shapes; v0.35.12 supports npm 12's keyed pack reports; v0.35.13 fixes stale-API recovery loops.
-  v0.35.14–v0.38.98 continue through the supervisor freeze (`/glla pause`),
+  v0.35.14–v0.38.104 continue through the supervisor freeze (`/glla pause`),
   load hold, auditor picker parity, Windows launch fix, zombie-watchdog
   subagent carve-out, due-wait backstop, the `/glla agents` visibility panel,
   durable state-root selection, blank-until-resume auditor context, frozen

package/docs/SETTINGS.md

@@ -32,6 +32,11 @@ copies are ignored (the recovery runtime reads the global file):
 `auditorModelFallbacks`, `auditorToolTimeoutMs`, `auditorStallMs`,
 `auditJobRetentionMs`, `auditSpotCheckRate`, `auditorInspection`.
 
+This list is `GLOBAL_ONLY_KEYS` in `extensions/goal-settings.ts`, and a
+project-scope write to any of them is stripped on read. Every other key —
+including `auditCapHard` and `mechanicalLoadScale` — is project-settable and
+a project file wins over the global one.
+
 ## Keys
 
 | Key | Default | Meaning |
@@ -69,12 +74,15 @@ copies are ignored (the recovery runtime reads the global file):
 | `carryover` | `"pause"` | Stale carryover on new activation: `"pause"` / `"clear"` / `"resume"`. |
 | `autoAcceptDrafts` | `false` | Drafts activate without the Confirm dialog (unattended rigs). |
 | `auditCap` | `5` (10 aggressive) | Pause after N consecutive auditor disapprovals (`0` = unlimited). |
+| `auditCapHard` | `8` | Hard ceiling on consecutive disapprovals — pauses with a decision even in aggressive mode (`0` = unlimited). Project-settable. |
+| `mechanicalLoadScale` | `true` | Scale mechanical gate budgets with host load up to 2× (`false` = fixed budgets). Project-settable. |
 | `auditFeedbackChars` | `0` (full) | Max auditor-report chars returned after disapproval (`0` = full). |
 | `auditorSilent` | `true` | Auditor report renders final-only, no word-by-word HUD. |
 | `auditorProgressSignals` | `true` | Silent audits show phase label + byte counter. |
 | `hourlyRetryProbe` | `true` | Extra blind retry at :00:30 every hour while parked. Global-only. |
 | `subagentModelStrategy` | `"inherit-parent"` | Default subagent model policy for new sessions. |
 | `subagentModelOverrides` | unset | Per-agent-type model pin; always wins over strategy. |
+| `subagentThinkingOverrides` | unset | Per-agent-type thinking pin (`off`–`max`); unset per type = session inherit. |
 | `subagentFallbacks` | unset | Per-role fallback chains (first eligible ref wins). |
 | `subagentDisplayRichness` | `"quiet"` | Ambient worker UI: `"quiet"` (default, troubled workers + count line) / `"compact"` / `"rich"`. |
 | `aggressiveMode` | `true` | Keep-going defaults (`false` = pause-first policy). |

package/extensions/action-reminder.ts

@@ -0,0 +1,265 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Box, Text } from "@earendil-works/pi-tui";
+
+export const ACTION_REMINDER_CUSTOM_TYPE = "glla-action-reminder";
+
+export type ActionReminderKind = "decision" | "blocked" | "error" | "wait" | "standby";
+
+export type ActionReminderParkState = "stopped" | "automatic" | "redirect";
+
+export interface ActionReminderDetails {
+  kind: ActionReminderKind;
+  reason: string;
+  action: string;
+  resumeCommand: string;
+  resumeAt?: string;
+  diagnostic?: string;
+  parkState: ActionReminderParkState;
+  /** The persisted goal is safe in every pause state. `parkState` separately
+   * distinguishes a stopped turn, automatic wait, or redirect continuation. */
+  safelyParked: true;
+}
+
+export interface ActionReminderPresentation {
+  heading: string;
+  why: string;
+  next: string;
+  resumeCommand?: string;
+  resumeAt?: string;
+  parkState: ActionReminderParkState;
+}
+
+export interface ActionReminderCopy {
+  content: string;
+  details: ActionReminderDetails;
+  presentation: ActionReminderPresentation;
+}
+
+export interface PauseAbortMarker {
+  ownerSession: unknown;
+  goalId: string;
+  kind: ActionReminderKind;
+  reason: string;
+  action?: string;
+  resumeCommand: string;
+  resumeAt?: string;
+}
+
+let pauseAbortMarker: PauseAbortMarker | null = null;
+let pauseTurnStartedAt = 0;
+let pauseTurnGeneration = 0;
+let pauseMarkerGeneration: number | null = null;
+
+/** Bind the exact pause state and host owner to the turn pause_goal is about
+ * to abort. A session/goal mismatch expires the marker instead of letting it
+ * rewrite some later abort. */
+export function markPauseAbort(marker: PauseAbortMarker): void {
+  pauseAbortMarker = { ...marker };
+  // Keep the public marker contract focused on the pause payload. A monotonic
+  // generation captured at agent_start is the fence: consuming requires the
+  // marker and its owner/goal to still belong to this exact turn.
+  pauseMarkerGeneration = pauseTurnStartedAt === 0 ? null : pauseTurnGeneration;
+}
+
+export function markActionReminderTurnStart(): void {
+  pauseTurnStartedAt = Date.now();
+  pauseTurnGeneration++;
+  pauseAbortMarker = null;
+  pauseMarkerGeneration = null;
+}
+
+export function clearPauseAbort(): void {
+  pauseAbortMarker = null;
+  pauseTurnStartedAt = 0;
+  pauseMarkerGeneration = null;
+}
+
+/** Consume a pending pause marker only when this exact owner, goal, and turn
+ * still match. `aborted` distinguishes the expected assistant abort from any
+ * other message_end that happens to arrive first. */
+export function consumePauseAbort(input: {
+  ownerSession: unknown;
+  goalId?: string;
+  aborted: boolean;
+}): PauseAbortMarker | null {
+  const marker = pauseAbortMarker;
+  if (!marker) return null;
+  if (
+    !input.aborted
+    || marker.ownerSession !== input.ownerSession
+    || marker.goalId !== input.goalId
+    || pauseTurnStartedAt === 0
+    || pauseMarkerGeneration === null
+    || pauseMarkerGeneration !== pauseTurnGeneration
+  ) {
+    return null;
+  }
+  pauseAbortMarker = null;
+  pauseMarkerGeneration = null;
+  return marker;
+}
+
+export function buildAbortedAssistantNotice(input: {
+  kind: ActionReminderKind;
+  reason: string;
+  action?: string;
+  resumeCommand: string;
+  resumeAt?: string;
+}): string {
+  const reminder = buildActionReminder(input);
+  return `GLLA paused this turn safely — ${reminder.presentation.why} ${reminder.presentation.next}`;
+}
+
+/** Build the durable, user-facing explanation for a GLLA pause. Pi's core
+ * abort renderer may still print its generic transport line; this message is
+ * the GLLA-owned card that tells the user what happened and what to do next. */
+export function buildActionReminder(input: {
+  kind: ActionReminderKind;
+  reason: string;
+  action?: string;
+  resumeCommand: string;
+  resumeAt?: string;
+  diagnostic?: string;
+  parkState?: ActionReminderParkState;
+}): ActionReminderCopy {
+  const reason = input.reason.trim() || "The current turn cannot continue safely.";
+  const suppliedAction = input.action?.trim();
+  const action = suppliedAction || input.resumeCommand;
+  const parkState = input.parkState ?? (
+    input.kind === "wait" || input.kind === "standby" ? "automatic" : "stopped"
+  );
+  const presentation = buildPausePresentation({
+    kind: input.kind,
+    reason,
+    action: input.kind === "decision" && !suppliedAction ? "" : action,
+    resumeCommand: input.resumeCommand,
+    resumeAt: input.resumeAt,
+    parkState,
+  });
+  const diagnostic = input.diagnostic?.trim();
+  const content = [
+    presentation.heading,
+    `Why: ${presentation.why}`,
+    parkState === "redirect"
+      ? "The saved goal is held while the current turn handles the new request."
+      : parkState === "automatic"
+        ? "Your saved work is intact; no manual action is needed."
+        : "Your saved work is intact; this turn stopped before more work could be lost.",
+    presentation.next,
+    ...(diagnostic ? [`Diagnostic: ${diagnostic}`] : []),
+  ].join("\n");
+  return {
+    content,
+    details: {
+      kind: input.kind,
+      reason,
+      action,
+      resumeCommand: input.resumeCommand,
+      resumeAt: input.resumeAt,
+      diagnostic,
+      parkState,
+      safelyParked: true,
+    },
+    presentation,
+  };
+}
+
+/** Normalize all reminder states into one hierarchy used by both transcript
+ * copy and the TUI renderer. Raw transport/provider diagnostics stay outside
+ * this model; callers may append them only after the actionable lines. */
+export function buildPausePresentation(input: {
+  kind: ActionReminderKind;
+  reason: string;
+  action: string;
+  resumeCommand: string;
+  resumeAt?: string;
+  parkState: ActionReminderParkState;
+}): ActionReminderPresentation {
+  const why = input.reason.trim() || "The current turn cannot continue safely.";
+  if (input.parkState === "redirect") {
+    return {
+      heading: "Goal safely parked — handling your new request now",
+      why,
+      next: `Next: ${input.action || input.resumeCommand}`,
+      resumeCommand: input.resumeCommand,
+      parkState: input.parkState,
+    };
+  }
+  if (input.kind === "standby") {
+    return {
+      heading: "Waiting — work is safely parked",
+      why,
+      next: "No action is needed; the background completion will wake this work automatically.",
+      parkState: input.parkState,
+    };
+  }
+  if (input.kind === "wait") {
+    return {
+      heading: "Waiting — work is safely parked",
+      why,
+      next: input.resumeAt
+        ? `The wait resumes automatically at ${input.resumeAt}.`
+        : "The wait resumes automatically when its condition clears.",
+      parkState: input.parkState,
+    };
+  }
+  if (input.kind === "decision") {
+    return {
+      heading: "Decision needed — work is safely parked",
+      why,
+      next: input.action
+        ? `Next: ${input.action}`
+        : "Choose an option in the decision card, then resume.",
+      resumeCommand: input.resumeCommand,
+      parkState: input.parkState,
+    };
+  }
+  return {
+    heading: "Action needed — work is safely parked",
+    why,
+    next: `Next: ${input.action || input.resumeCommand}`,
+    resumeCommand: input.resumeCommand,
+    parkState: input.parkState,
+  };
+}
+
+export function registerActionReminderRenderer(pi: ExtensionAPI): void {
+  pi.registerMessageRenderer(ACTION_REMINDER_CUSTOM_TYPE, (message, { outputPad }, theme) => {
+    const details = message.details as Partial<ActionReminderDetails> | undefined;
+    const diagnostics = details?.diagnostic?.trim();
+    const kind = details?.kind ?? "blocked";
+    const color = kind === "error" ? "error" : kind === "decision" ? "accent" : "warning";
+    const parkState = details?.parkState ?? (kind === "wait" || kind === "standby" ? "automatic" : "stopped");
+    const presentation = buildPausePresentation({
+      kind,
+      reason: details?.reason ?? "",
+      action: details?.action ?? details?.resumeCommand ?? "",
+      resumeCommand: details?.resumeCommand ?? "",
+      resumeAt: details?.resumeAt,
+      parkState,
+    });
+    const heading = parkState === "redirect"
+      ? `↪ GLLA ${presentation.heading}`
+      : kind === "wait" || kind === "standby"
+        ? `⏳ GLLA ${presentation.heading}`
+        : `⏸ GLLA ${presentation.heading}`;
+    const box = new Box(outputPad, 1, (t) => theme.bg("customMessageBg", t));
+    box.addChild(new Text(theme.fg(color, heading), 0, 0));
+    box.addChild(new Text(theme.fg("dim", `Why: ${presentation.why}`), 0, 0));
+    if (presentation.next) box.addChild(new Text(theme.fg("accent", presentation.next), 0, 0));
+    if (presentation.parkState === "redirect") {
+      box.addChild(new Text(theme.fg("dim", "The saved goal is held while the current turn handles the new request."), 0, 0));
+    } else if (presentation.parkState === "automatic") {
+      box.addChild(new Text(theme.fg("dim", "Your saved work is intact; no manual action is needed."), 0, 0));
+    } else {
+      box.addChild(new Text(theme.fg("dim", "Your saved work is intact; this turn stopped before more work could be lost."), 0, 0));
+    }
+    if (presentation.resumeCommand && presentation.parkState !== "automatic") {
+      box.addChild(new Text(theme.fg("dim", `Resume: ${presentation.resumeCommand}`), 0, 0));
+    }
+    if (diagnostics) {
+      box.addChild(new Text(theme.fg("dim", `Diagnostic: ${diagnostics}`), 0, 0));
+    }
+    return box;
+  });
+}