pi-better-harness 0.18.0 → 0.20.0

package/README.md

@@ -1,5 +1,7 @@
 # pi-better-harness
 
+<img src="https://raw.githubusercontent.com/1aboveio/pi-better-harness/main/docs/images/brand/logo.png" alt="Pi Better Harness logo" width="128" height="128" />
+
 `pi-better-harness` is a Pi meta package that installs the core Pi Better Harness extensions: an opt-in foreground write sandbox, delegated subagents, durable background tasks, synchronous SSH commands, goal tracking, and structured plans.
 
 ## Quick Answer
@@ -63,12 +65,13 @@ need interactive confirmation. Full policy: [pi-better-sandbox](https://github.c
 ## Minimal Tool Output
 
 The bundled harness also provides `/tool-output minimal`, `/tool-output normal`,
-and `/tool-output` (toggle). Minimal mode hides tool blocks entirely, including
-running calls, headers, results, images, summary rows, and tool spacers. Built-in,
+and `/tool-output` (toggle). Minimal mode folds each tool call into a single-line
+header, including running calls. Long headers are truncated to the terminal
+width; result bodies, images, boxes, and tool spacers are hidden. Built-in,
 extension, and MCP calls are included. Execution, sandboxing, and agent-facing
 payloads are unchanged. Ctrl+O reveals the original tool blocks; Ctrl+O again
-hides them. `/tool-output normal` restores ordinary rendering. Error results
-are also hidden in minimal mode and remain available when revealed.
+folds them. `/tool-output normal` restores ordinary rendering. Error result
+bodies are also hidden in minimal mode and remain available when expanded.
 
 Normal mode is the default. The preference is saved in the current session,
 including resume/reload. This is a version-sensitive internal TUI adapter,

package/extensions/minimal-output/hook.ts

@@ -1,9 +1,14 @@
+import { truncateToWidth, type Component } from "@earendil-works/pi-tui";
 import { readFileSync, realpathSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
+import { stripVTControlCharacters } from "node:util";
 
 interface ToolComponent {
+  toolName: string;
+  args: unknown;
+  callRendererComponent?: Component;
   expanded: boolean;
   showImages: boolean;
   resultRendererComponent?: unknown;
@@ -37,6 +42,20 @@ export interface MinimalOutputHook {
 const HOOK = Symbol.for("pi-better-harness.minimal-output-hook");
 const emptyResult = () => ({ render: () => [] as string[], invalidate() {} });
 
+function compactCall(component: ToolComponent, width: number): string[] {
+  if (width <= 0) return [];
+  // Render the call alone at a wider width so terminal wrapping becomes truncation.
+  const header = component.callRendererComponent?.render(Math.max(4096, width + 1))
+    .map((line) => stripVTControlCharacters(line).trim())
+    .find((line) => line.length > 0);
+  let text = header;
+  if (!text) {
+    const args = JSON.stringify(component.args);
+    text = `${component.toolName}${args && args !== "{}" ? ` ${args}` : ""}`;
+  }
+  return [truncateToWidth(text, width)];
+}
+
 function hostRequire(): NodeRequire {
   let require = createRequire(import.meta.url);
   if (process.argv[1]) {
@@ -145,7 +164,7 @@ export function installMinimalOutputHook(prototype: ToolPrototype): MinimalOutpu
         return current.enabled && !this.expanded ? "" : originals.getTextOutput.apply(this, args);
       },
       render(this: ToolComponent, width: number): string[] {
-        return current.enabled && !this.expanded ? [] : originals.render.call(this, width);
+        return current.enabled && !this.expanded ? compactCall(this, width) : originals.render.call(this, width);
       },
     };
     Object.assign(prototype, wrappers);

package/extensions/minimal-output/index.ts

@@ -56,11 +56,11 @@ export default function minimalOutputExtension(pi: ExtensionAPI): void {
   });
 
   pi.registerCommand("tool-output", {
-    description: "[minimal|normal] — Hide tool blocks entirely, or restore normal output. No argument toggles. Display only.",
+    description: "[minimal|normal] — Fold tool output into single-line call headers, or restore normal output. No argument toggles. Display only.",
     getArgumentCompletions: (argumentPrefix) => {
       const prefix = argumentPrefix.trimStart().toLowerCase();
       const matches = [
-        { value: "minimal", label: "minimal", description: "Hide all tool blocks, including running tools" },
+        { value: "minimal", label: "minimal", description: "Show compact call headers without result bodies" },
         { value: "normal", label: "normal", description: "Restore ordinary tool output" },
       ].filter((option) => option.value.startsWith(prefix));
       return matches.length > 0 ? matches : null;
@@ -78,7 +78,7 @@ export default function minimalOutputExtension(pi: ExtensionAPI): void {
       pi.appendEntry(ENTRY, { version: 1, enabled });
       status(ctx);
       ctx.ui.notify(enabled
-        ? "Minimal tool output on. Tool blocks are hidden. Ctrl+O reveals them."
+        ? "Minimal tool output on. Compact call headers remain visible. Ctrl+O reveals results."
         : "Normal tool output restored.", "info");
     },
   });

package/node_modules/pi-better-background-tasks/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-background-tasks",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "Pi extension for durable background shell tasks, watchers, logs, and status inspection.",
   "license": "MIT",
   "type": "module",

package/node_modules/pi-better-background-tasks/src/shared-failure-observations.ts

@@ -2,6 +2,7 @@
 import { appendFileSync, closeSync, existsSync, openSync, readFileSync, mkdirSync, statSync } from "node:fs";
 import { dirname } from "node:path";
 import { createHash } from "node:crypto";
+import { isPermissionBlocker, permissionBlockerKey, type PermissionBlocker } from "./shared-permission-blocker.ts";
 
 /**
  * Explicit, append-only incident dispositions (#315).
@@ -30,6 +31,7 @@ export interface FailureEvent {
   disposition?: IncidentDisposition;
   /** Disposition events only: why the incidents are classified this way. */
   reason?: string;
+  permissionBlockers?: PermissionBlocker[];
 }
 export interface DispositionRecord {
   eventId: string;
@@ -38,6 +40,7 @@ export interface DispositionRecord {
   reason: string;
   evidence?: string;
   at: number;
+  permissionBlockers?: PermissionBlocker[];
 }
 export interface FailureObservation {
   id: string;
@@ -56,6 +59,8 @@ export interface FailureObservation {
   resolvedAt?: number;
   /** Latest explicit disposition applied to this incident. */
   disposition?: DispositionRecord;
+  /** Retained even after recovery; active surfaces filter by current actionability. */
+  permissionBlockers?: PermissionBlocker[];
 }
 export interface FailureState {
   version: 1;
@@ -247,12 +252,26 @@ export function validateDisposition(state: FailureState, event: FailureEvent): s
     if (current.status !== "unresolved") return `Incident ${id} is already disposed (${failureLabel(current).toLowerCase()})`;
     if (event.disposition === "open" && current.disposition?.disposition === "open") return `Incident ${id} is already open`;
   }
+  if (event.permissionBlockers !== undefined) {
+    if (event.disposition !== "open" || !Array.isArray(event.permissionBlockers) || !event.permissionBlockers.length ||
+      event.permissionBlockers.length > 20 || !event.permissionBlockers.every(isPermissionBlocker)) return "Invalid permission blocker metadata";
+    const bound = new Set<string>();
+    for (const blocker of event.permissionBlockers) {
+      const current = blocker.incidentId ? findIncident(state, blocker.incidentId) : undefined;
+      if (!current || !ids.includes(current.id) || current.category !== "tool" || current.operation !== blocker.operation ||
+        blocker.context !== "worker" || blocker.basis !== "agent-reported" || blocker.remoteOutcome !== "unknown" ||
+        blocker.policySnapshotId !== undefined || bound.has(current.id)) return "Permission blocker must name an unresolved failed worker attempt";
+      bound.add(current.id);
+    }
+    if (bound.size !== ids.length) return "Permission blocker metadata must cover every target";
+  }
   return undefined;
 }
 
 /** Pure transition. Lifecycle is deliberately not an input or an output. */
 export function reduceFailure(state: FailureState, event: FailureEvent, observedAt: number): FailureState {
   if (state.seen.includes(event.id)) return state;
+  if (event.permissionBlockers !== undefined && event.kind !== "disposition") return state;
   // Invalid dispositions fail closed: nothing changes and the id is not consumed.
   if (event.kind === "disposition" && validateDisposition(state, event)) return state;
   const next: FailureState = { ...state, seen: [...state.seen, event.id],
@@ -265,11 +284,13 @@ export function reduceFailure(state: FailureState, event: FailureEvent, observed
     const at = event.at ?? observedAt;
     const record: DispositionRecord = { eventId: event.id, disposition: event.disposition!, incidents: [...event.incidents!],
       reason: text(event.reason, ""), ...(event.evidence ? { evidence: text(event.evidence, "") } : {}), at };
+    if (event.permissionBlockers) record.permissionBlockers = event.permissionBlockers.map(x => ({ ...x }));
     for (const id of record.incidents) {
       const [key, current] = Object.entries(next.observations).find(([, item]) => item.id === id)!;
       const status = record.disposition === "recovered" ? "resolved" : record.disposition === "superseded" ? "superseded"
         : record.disposition === "expected" ? "expected" : current.status;
       next.observations[key] = { ...current, status, disposition: record,
+        ...(record.permissionBlockers ? { permissionBlockers: record.permissionBlockers.filter(x => x.incidentId === id) } : {}),
         ...(status === "resolved" || status === "superseded" ? { resolvedAt: at } : {}) };
       if (status === "resolved" || status === "superseded") next.resolved = { ...next.resolved, [id]: at };
     }
@@ -298,6 +319,7 @@ export function reduceFailure(state: FailureState, event: FailureEvent, observed
     lastObservedAt: observedAt, lastSequence: next.seen.length, at: event.at,
     count: active ? previous.count + 1 : 1,
     ...(active && previous.disposition ? { disposition: previous.disposition } : {}),
+    ...(active && previous.permissionBlockers ? { permissionBlockers: previous.permissionBlockers } : {}),
   };
   return next;
 }
@@ -315,6 +337,16 @@ export function activeFailures(state: FailureState): FailureObservation[] {
 export function actionableFailures(state: FailureState): FailureObservation[] {
   return activeFailures(state).filter(needsAction);
 }
+/** Only currently actionable reports, not closed history or arbitrary tool-result claims. */
+export function actionablePermissionBlockers(state: FailureState): PermissionBlocker[] {
+  const unique = new Map<string, PermissionBlocker>();
+  for (const incident of actionableFailures(state)) {
+    for (const blocker of incident.permissionBlockers ?? []) {
+      if (isPermissionBlocker(blocker)) unique.set(permissionBlockerKey(blocker), { ...blocker });
+    }
+  }
+  return [...unique.values()];
+}
 function closedOrder(a: FailureObservation, b: FailureObservation): number {
   return (b.lastSequence ?? 0) - (a.lastSequence ?? 0) || b.lastObservedAt - a.lastObservedAt;
 }
@@ -449,12 +481,20 @@ export function shortEvidence(evidence: string): string {
 function failureRow(x: FailureObservation, detail: IncidentDetail = "compact"): string {
   const time = x.at === undefined ? `observed ${new Date(x.firstObservedAt).toISOString()}` : new Date(x.at).toISOString();
   const compact = detail !== "full";
+  const permission = Boolean(x.permissionBlockers?.length);
+  let annotation = "";
+  if (x.permissionBlockers?.length) {
+    const resources = x.permissionBlockers.map(b => b.resource).join(", ");
+    annotation = ` · Worker permission blocker: ${resources} (agent-reported; remote outcome unknown; not a foreground denial). No remote authorization or successful validation inferred.`;
+    if (needsAction(x)) annotation += " Changed worker settings require a fresh launch.";
+  }
   // Full rows (raw evidence) show the journal summary verbatim; compact rows unwrap and cap it.
-  const summary = compact ? capUtf8(dropLoneSurrogates(unwrapToolResultText(x.summary)).replace(/\s+/g, " ").trim(), COMPACT_EXCERPT_BYTES) : x.summary;
+  const summary = compact && permission ? "Permission access failure" : compact ? capUtf8(dropLoneSurrogates(unwrapToolResultText(x.summary)).replace(/\s+/g, " ").trim(), COMPACT_EXCERPT_BYTES) : x.summary;
   const reason = x.disposition ? text(x.disposition.reason, "") : "";
-  const disposition = x.disposition ? ` · ${x.disposition.disposition}: ${compact ? capUtf8(reason, COMPACT_EXCERPT_BYTES) : reason}` : "";
-  const evidence = x.evidence ? text(x.evidence, "") : "";
-  return `${failureLabel(x)} · ${time} · ${summary}${x.count > 1 ? ` (${x.count} occurrences)` : ""}${disposition}${evidence ? ` · evidence: ${compact ? shortEvidence(evidence) : evidence}` : ""}`;
+  const disposition = x.disposition ? ` · ${x.disposition.disposition}${compact && permission ? "" : `: ${compact ? capUtf8(reason, COMPACT_EXCERPT_BYTES) : reason}`}` : "";
+  const evidence = x.evidence && !(compact && permission) ? text(x.evidence, "") : "";
+  const proof = !compact && permission && x.disposition?.evidence ? ` · disposition evidence: ${text(x.disposition.evidence, "")}` : "";
+  return `${failureLabel(x)} · ${time} · ${summary}${x.count > 1 ? ` (${x.count} occurrences)` : ""}${disposition}${evidence ? ` · evidence: ${compact ? shortEvidence(evidence) : evidence}` : ""}${proof}${annotation}`;
 }
 
 /**
@@ -573,13 +613,15 @@ export interface FailureIncidentPage {
  */
 export function failureRevision(state: FailureState): string {
   return failureIdentity(Object.values(state.observations)
-    .map((item) => [item.id, item.status, item.category, item.count, item.lastSequence ?? 0, item.summary, item.evidence ?? ""])
+    .map((item) => [item.id, item.status, item.category, item.count, item.lastSequence ?? 0, item.summary, item.evidence ?? "",
+      ...(item.permissionBlockers ? [item.permissionBlockers.map(permissionBlockerKey).sort()] : [])])
     .sort((a, b) => String(a[0]).localeCompare(String(b[0]))));
 }
 
 /** Digest of the rows a cursor pages. Scope and detail are part of it: the same incidents render different bytes. */
 function incidentRevision(state: FailureState, scope: IncidentScope = "actionable", detail: IncidentDetail = "compact"): string {
-  return failureIdentity(scope, detail, scopedFailures(state, scope).map((item) => [item.id, item.status, item.count, item.summary, item.evidence ?? ""])).slice(0, 16);
+  return failureIdentity(scope, detail, scopedFailures(state, scope).map((item) => [item.id, item.status, item.count, item.summary, item.evidence ?? "",
+    ...(item.permissionBlockers ? [item.permissionBlockers.map(permissionBlockerKey).sort()] : [])])).slice(0, 16);
 }
 
 /** Cursors carry a digest of their resource/scope, not the scope text. */
@@ -999,6 +1041,8 @@ function readStoredState(path: string): FailureState {
           !Number.isFinite(row.observedAt) || Math.abs(row.observedAt) > 8.64e15 ||
           (e.at !== undefined && (!Number.isFinite(e.at) || Math.abs(e.at) > 8.64e15)) ||
           (e.incidents !== undefined && (!Array.isArray(e.incidents) || !e.incidents.every((id: unknown) => typeof id === "string"))) ||
+          (e.permissionBlockers !== undefined && (e.kind !== "disposition" ||
+            (!state.seen.includes(e.id) && validateDisposition(state, e) !== undefined))) ||
           [e.summary, e.category, e.evidence, e.reason].some((v) => v !== undefined && typeof v !== "string")) throw new Error("invalid record");
       state = reduceFailure(state, e, row.observedAt);
     } catch { state = storageProblem(state, "Failure journal contains unreadable records; observations may be incomplete"); }
@@ -1021,6 +1065,7 @@ export function observeFailures(path: string, events: readonly FailureEvent[], n
     }
     // Rejected dispositions are never journaled or marked seen.
     if (raw.kind === "disposition" && validateDisposition(state, raw)) continue;
+    if (raw.permissionBlockers !== undefined && raw.kind !== "disposition") continue;
     const event = { ...raw, ...(raw.summary ? { summary: text(raw.summary, "") } : {}),
       ...(raw.evidence ? { evidence: text(raw.evidence, "") } : {}), ...(raw.reason ? { reason: text(raw.reason, "") } : {}) };
     try {

package/node_modules/pi-better-background-tasks/src/shared-permission-blocker.ts

@@ -0,0 +1,48 @@
+// Generated from packages/failure-observations/permission-blocker.ts. Do not edit directly.
+/** Privacy-safe wire contract. Context and identity must be assigned by a trusted adapter. */
+export const PERMISSION_RESOURCES = Object.freeze([
+  "credential-files", "process-inspection", "project-files", "outside-project-files",
+  "runtime-control-files", "command-execution", "network-access", "unknown",
+] as const);
+export type PermissionResource = typeof PERMISSION_RESOURCES[number];
+export interface PermissionBlocker {
+  version: 1;
+  kind: "permission-blocker";
+  context: "worker" | "foreground";
+  resource: PermissionResource;
+  basis: "policy-refusal" | "os-permission-error" | "agent-reported";
+  /** A stable hash or bounded logical identifier, never a command or path. */
+  operation: string;
+  remoteOutcome: "unknown" | "not-started";
+  incidentId?: string;
+  runId?: string;
+  policySnapshotId?: string;
+}
+const FIELDS = new Set(["version", "kind", "context", "resource", "basis", "operation", "remoteOutcome", "incidentId", "runId", "policySnapshotId"]);
+const LOGICAL_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,199}$/;
+// Responses SDK references join call_id and item_id with "|"; these are opaque evidence ids,
+// not caller-chosen logical operations. Keep the same bound and exclude paths and prose.
+const INCIDENT_REFERENCE = /^[A-Za-z0-9][A-Za-z0-9._:|\-]{0,199}$/;
+export function isPermissionResource(value: unknown): value is PermissionResource {
+  return typeof value === "string" && (PERMISSION_RESOURCES as readonly string[]).includes(value);
+}
+/** Pure and strict: no coercion, unknown fields, paths, argv, or free-form prose. */
+export function isPermissionBlocker(value: unknown): value is PermissionBlocker {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return false;
+  if (Reflect.ownKeys(value).some(key => typeof key !== "string" || !FIELDS.has(key))) return false;
+  const v = value as Record<string, unknown>;
+  if (v.version !== 1 || v.kind !== "permission-blocker" || !["worker", "foreground"].includes(v.context as string) ||
+    !isPermissionResource(v.resource) || !["policy-refusal", "os-permission-error", "agent-reported"].includes(v.basis as string) ||
+    !["unknown", "not-started"].includes(v.remoteOutcome as string) ||
+    typeof v.operation !== "string" || v.operation.length > 64 || !LOGICAL_ID.test(v.operation)) return false;
+  if (Object.hasOwn(v, "incidentId") && (typeof v.incidentId !== "string" || !INCIDENT_REFERENCE.test(v.incidentId))) return false;
+  return ["runId", "policySnapshotId"].every(key => !Object.hasOwn(v, key) ||
+    (typeof v[key] === "string" && LOGICAL_ID.test(v[key] as string)));
+}
+/** Order-independent identity without I/O or a platform-specific crypto dependency. */
+export function permissionBlockerKey(blocker: PermissionBlocker): string {
+  return JSON.stringify([blocker.version, blocker.kind, blocker.context, blocker.resource, blocker.basis,
+    blocker.operation, blocker.remoteOutcome, blocker.incidentId ?? null, blocker.runId ?? null, blocker.policySnapshotId ?? null]);
+}

package/node_modules/pi-better-background-tasks/src/shared-sandbox-core.ts

@@ -60,6 +60,8 @@ export type SandboxPermissions = {
     storedCredentials: "off" | "read" | "read-write";
     commands: boolean;
     network: boolean;
+    /** Fixed process_list adapter only; omitted legacy profiles keep it Off. */
+    processAccess?: "off" | "read";
 };
 
 /** Whether a file access level allows creating and overwriting files. */

package/node_modules/pi-better-goal/README.md

@@ -13,8 +13,8 @@ Use `pi-better-goal` when a Pi session should keep an explicit objective visible
 ## Core Features
 
 - `/goal` runtime for starting, pausing, resuming, completing, and clearing the current objective.
-- `/goal settings` opens an interactive settings page in the TUI. Select a row with Up/Down and toggle with Space/Enter; changes save immediately, and Escape closes the page. Both controls default to `on`. Automatic continuation controls idle and background-drain wakes; conversational resume controls the agent's Escape-pause resume tool. Goal kickoff, `/goal resume`, and `alt+g` remain available with either control off. For scripts or non-interactive sessions, use `/goal settings auto-continue on|off` and `/goal settings conversational-resume on|off`; bare `/goal settings` prints the saved values outside the TUI.
-- `escape` pauses the active goal, and it stays paused while you talk to the agent. With conversational resume enabled, say "go" (the agent then calls `goal_resume`), or use `/goal resume` or `alt+g`. `/goal pause` resumes only through `/goal resume` or `alt+g`. The status line shows the available resume path, and paused goals are never poked. On a macOS terminal without Option-as-Meta, `alt+g` types `©`; use `/goal resume` there.
+- `/goal settings` opens an interactive settings page in the TUI. Select a row with Up/Down and toggle with Space/Enter; changes save immediately, and Escape closes the page. All three controls default to `on`. Automatic continuation controls idle and background-drain wakes; conversational resume controls the agent's Escape-pause resume tool; **Pause on Esc** controls whether editor Escape pauses the active goal. Goal kickoff, `/goal resume`, and `alt+g` remain available with these controls off. For scripts or non-interactive sessions, use `/goal settings auto-continue on|off`, `/goal settings conversational-resume on|off`, and `/goal settings pause-on-escape on|off`; bare `/goal settings` prints the saved values outside the TUI.
+- `escape` pauses the active goal by default, and it stays paused while you talk to the agent. With **Pause on Esc** off, observed editor Escape leaves the goal active while preserving native streaming interruption and menu/dialog cancellation. Automatic continuation remains independent. Hosts without terminal/focus inspection and unknown custom editors retain generic abort-to-pause behavior because they cannot identify Escape reliably. With conversational resume enabled, say "go" (the agent then calls `goal_resume`), or use `/goal resume` or `alt+g`. `/goal pause` resumes only through `/goal resume` or `alt+g`. The status line shows the available resume path, and paused goals are never poked. On a macOS terminal without Option-as-Meta, `alt+g` types `©`; use `/goal resume` there.
 - Background work that finishes while an `ask_user_question` is pending is handed to the agent right after the answer.
 - A compact goal widget that does not replace Pi's footer.
 - Background activity tracking for subagents and other registered providers.

package/node_modules/pi-better-goal/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-goal",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "Pi extension for goal tracking with background-aware continuation.",
   "license": "MIT",
   "type": "module",

package/node_modules/pi-better-goal/src/continuation.ts

@@ -53,6 +53,10 @@ function resultContent(content: unknown): unknown[] {
 export function continuationEvidence(messages: readonly unknown[]): ContinuationEvidence {
   const records: unknown[] = [];
   const toolNames: string[] = [];
+  const hasActions = messages.some((candidate) => isRecord(candidate) && (
+    candidate.role === "toolResult" || (candidate.role === "assistant" && Array.isArray(candidate.content) &&
+      candidate.content.some((block) => isRecord(block) && block.type === "toolCall"))
+  ));
 
   for (const candidate of messages) {
     if (!isRecord(candidate)) {
@@ -67,7 +71,7 @@ export function continuationEvidence(messages: readonly unknown[]): Continuation
         toolNames.push(block.name);
         return [{ name: block.name, arguments: block.arguments }];
       });
-      const text = message.content.flatMap((block) =>
+      const text = hasActions ? [] : message.content.flatMap((block) =>
         isRecord(block) && block.type === "text" ? [{ text: block.text }] : [],
       );
       if (actions.length > 0 || text.length > 0) {

package/node_modules/pi-better-goal/src/goal-state.ts

@@ -66,7 +66,7 @@ function isGoalStatus(value: unknown): value is GoalStatus {
 }
 
 function isPauseReason(value: unknown): value is GoalPauseReason {
-  return value === "interrupt";
+  return value === "interrupt" || value === "permission-blocker";
 }
 
 function isGoalLike(value: unknown): value is GoalLike {