pi-better-harness 0.29.0 → 0.29.2

package/README.md

@@ -69,8 +69,8 @@ The bundled harness provides **Tool output: Normal / Minimal** in
 `/tool-output` (toggle) remain compatibility shortcuts to the same preference.
 Minimal mode folds each tool call into a single-line header, including running
 calls. The tool-specific icon and tool name share a state color: accent while
-running, muted when completed, and error-colored when failed. In fullscreen Pi, a soft highlight travels through visible running names; inline
-command/path arguments stay dim. Scrollback terminals keep static state colors.
+running, muted when completed, and error-colored when failed. In fullscreen Pi, a soft highlight travels through the entire visible running tool name and its
+inline command/path details; details stay dim between highlight passes. Scrollback terminals keep static state colors.
 Choose **Tool animation: Off** in `/harness-settings` for static running headers.
 Running and failed calls retain text labels so state never depends on color or
 motion alone. Tool rows are indented two columns past

package/extensions/minimal-output/hook.ts

@@ -174,8 +174,10 @@ function compactCall(component: ToolComponent, width: number, theme?: Theme, ind
   const suffix = failed ? " (failed)" : running ? " (running)" : "";
   const icon = TOOL_ICONS[component.toolName] ?? "\u25c7";
   const title = ` ${icon} ${label}`;
+  const visibleDetail = animationTime === undefined ? detail : truncateToWidth(detail,
+    Math.max(0, width - Math.min(indent, Math.max(0, width - 1)) - visibleWidth(title) - 2));
   const styled = theme
-    ? ` ${toolIdentity(icon, label, failed ? "error" : running ? "accent" : "muted", theme, animationTime)}${detail ? `  ${theme.fg("dim", detail)}` : ""}${theme.fg(failed ? "error" : "dim", suffix)}`
+    ? ` ${toolIdentity(icon, label, failed ? "error" : running ? "accent" : "muted", theme, animationTime, visibleDetail)}${theme.fg(failed ? "error" : "dim", suffix)}`
     : `${title}${detail ? `  ${detail}` : ""}${suffix}`;
   return [truncateToWidth(`${" ".repeat(Math.min(indent, Math.max(0, width - 1)))}${styled}`, width)];
 }

package/extensions/minimal-output/tool-identity.ts

@@ -6,7 +6,7 @@ const concreteColors = (theme: Theme) => (theme as Theme & { colors?: Record<str
 const PERIOD = 2400;
 const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 
-function themeRgb(theme: Theme, token: "accent" | "text"): RGB | undefined {
+function themeRgb(theme: Theme, token: "accent" | "text" | "dim"): RGB | undefined {
   const color = concreteColors(theme)?.[token];
   if (color?.kind === "rgb" && color.r !== undefined && color.g !== undefined && color.b !== undefined) {
     return [color.r, color.g, color.b];
@@ -43,23 +43,27 @@ function foreground(color: RGB, mode: "truecolor" | "256color"): string {
   return `\x1b[38;5;${index}m`;
 }
 
-export function toolIdentity(icon: string, label: string, tone: "accent" | "muted" | "error", theme: Theme, time?: number): string {
-  if (tone !== "accent" || time === undefined) return theme.fg(tone, `${icon} ${label}`);
+export function toolIdentity(icon: string, label: string, tone: "accent" | "muted" | "error", theme: Theme, time?: number, detail = ""): string {
+  const staticHeader = () => theme.fg(tone, `${icon} ${label}`) + (detail ? `  ${theme.fg("dim", detail)}` : "");
+  if (tone !== "accent" || time === undefined || !supportsToolShimmer(theme)) return staticHeader();
   const base = themeRgb(theme, "accent");
   const light = themeRgb(theme, "text");
-  if (!supportsToolShimmer(theme)) return theme.fg(tone, `${icon} ${label}`);
-  const letters = Array.from(graphemes.segment(label), part => part.segment);
+  const letters = Array.from(graphemes.segment(label + (detail ? `  ${detail}` : "")), part => part.segment);
+  const nameLength = Array.from(graphemes.segment(label)).length;
   const radius = Math.max(2, Math.min(4, letters.length / 3));
   const position = (time % PERIOD) / PERIOD * (letters.length + radius * 2) - radius;
   const mode = theme.getColorMode();
+  const detailBase = detail ? themeRgb(theme, "dim") : undefined;
   const name = letters.map((letter, index) => {
+    const token = index < nameLength ? "accent" : "dim";
+    const letterBase = token === "accent" ? base : detailBase;
     const distance = Math.abs(index - position) / radius;
     const shine = distance < 1 ? (1 + Math.cos(distance * Math.PI)) * 0.48 : 0;
-    if (!base || !light) {
+    if (!base || !light || !letterBase) {
       const intensity = shine > 0.72 ? "\x1b[1m" : shine > 0.18 ? "" : "\x1b[2m";
-      return `\x1b[22m${intensity}${letter}`;
+      return `${theme.getFgAnsi(token)}\x1b[22m${intensity}${letter}`;
     }
-    const color = base.map((value, channel) => Math.round(value + (light[channel] - value) * shine)) as RGB;
+    const color = letterBase.map((value, channel) => Math.round(value + (light[channel] - value) * shine)) as RGB;
     return `${foreground(color, mode)}${letter}`;
   }).join("");
   return theme.fg(tone, `${icon} \x1b[22m${name}\x1b[22m`);

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

@@ -55,6 +55,8 @@ metadata:
 
 Invoking the alias (`/skill:resolve-issues`, or `/goal /skill:resolve-issues task`) records the target coordinator, with the target's registered path, as the workflow owner, so its task plan, continuation instructions, and plan tools behave exactly as if the target had been invoked. The target must be a registered `workflow-role: coordinator` skill; an unregistered target, a non-coordinator target, or a chain of aliases is refused with a notice.
 
+After every successful context compaction (Pi's `session_compact` event) while a coordinator owns the session, the goal extension re-injects the skill so the model sees it before its next step; the compaction summary keeps run state but not the skill's rules, and the summary itself is left unchanged. If the skill directory ships `scripts/rehydrate.mjs` (checked first) or `rehydrate.mjs`, it runs as `node <script> --cwd <session cwd>` (no shell, 10-second timeout, stderr ignored) and its trimmed stdout becomes the message; empty output injects nothing, so the script decides whether a run is in progress. Without a script, or when it fails or times out, the message is: "Your context was just compacted while you coordinate the `<name>` workflow. Before your next step, read `<SKILL.md path>` in full, with no line limit." The message is a `workflow-rehydrate` custom message: inside a running agent loop (or before an overflow retry) it steers the next model call; otherwise it is appended without starting a turn.
+
 When `pi-better-plan` is installed, it defers its prompt, checklist, and `update_plan` tool to a skill-owned task plan. Skills without this metadata retain normal goal and plan behavior. The skill itself owns its planning format and worker policy; the harness does not enumerate skills or impose a shared workflow schema. The former `pi-better-plan-workflow: coordinator` metadata remains supported for installed skills.
 
 ## Install

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

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

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

@@ -40,6 +40,7 @@ import {
 import { createRenderScheduler } from "./shared-render-scheduler.js";
 import { collectSubagentActivity } from "./subagents.js";
 import { currentWorkflowOwner, skillCommandName, workflowEntry, workflowOwnerFromSkill, WORKFLOW_ENTRY_TYPE } from "./workflow.js";
+import { workflowRehydrateMessage, WORKFLOW_REHYDRATE_MESSAGE_TYPE } from "./rehydrate.js";
 import {
   EVENT_ACTIVITY,
   EVENT_READY,
@@ -312,6 +313,8 @@ export default function (pi: ExtensionAPI): void {
   let snapshotSequence = 0;
   let lastAppliedSnapshotSequence = 0;
   let foregroundRunning = false;
+  /** True between agent_start and agent_end: the agent loop will call the model again without a new prompt. */
+  let agentLoopActive = false;
   let pollTimer: ReturnType<typeof setInterval> | undefined;
   let collecting = false;
   let collectionPending = false;
@@ -1186,6 +1189,7 @@ export default function (pi: ExtensionAPI): void {
     collectionPending = false;
     currentCtx = ctx;
     foregroundRunning = !ctx.isIdle();
+    agentLoopActive = false;
     try {
       preferences = readGoalPreferences();
     } catch (error) {
@@ -1334,6 +1338,7 @@ export default function (pi: ExtensionAPI): void {
     agentGeneration = executionGeneration;
     currentCtx = ctx;
     foregroundRunning = true;
+    agentLoopActive = true;
     clearIdleContinuation();
     continuationQueuedFor = null;
     lastAgentEvidence = null;
@@ -1355,6 +1360,7 @@ export default function (pi: ExtensionAPI): void {
   });
 
   pi.on("agent_end", async (event, ctx) => {
+    agentLoopActive = false;
     lastAgentEvidence = agentGeneration === executionGeneration ? continuationEvidence(event.messages) : null;
     // Only an observed editor Escape with pause disabled exempts this abort.
     // Unknown interrupt sources retain the safety fallback on every host.
@@ -1483,6 +1489,29 @@ export default function (pi: ExtensionAPI): void {
     scheduleIdleContinuation(goal, ctx, "continuation", snapshot);
   });
 
+  // A compaction summary keeps run state but drops the coordinator skill's rules. Re-inject them
+  // (or the skill's own rehydrate script output) so the model sees them before its next step.
+  pi.on("session_compact", async (event, ctx) => {
+    const owner = getWorkflow(ctx);
+    if (!owner) return;
+    const content = await workflowRehydrateMessage(owner, ctx.cwd);
+    if (!content) return;
+    // Inside a running agent loop (mid-run compaction or an overflow retry) steer it into the next
+    // model call. Otherwise append it without triggering a turn: the next turn, whatever starts it,
+    // sees it. Steering after the loop ended would start an unprompted continuation.
+    const options = agentLoopActive || event.willRetry ? { deliverAs: "steer" as const } : { triggerTurn: false };
+    try {
+      pi.sendMessage({
+        customType: WORKFLOW_REHYDRATE_MESSAGE_TYPE,
+        content,
+        display: true,
+        details: { workflow: owner.name, path: owner.path, reason: event.reason },
+      }, options);
+    } catch {
+      // Best effort: never fail or block the session over a rehydrate notice.
+    }
+  });
+
   pi.on("session_shutdown", async (_event, ctx) => {
     if (typeof unsubscribeSettingsRequest === "function") unsubscribeSettingsRequest();
 

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

@@ -0,0 +1,57 @@
+import { execFile } from "node:child_process";
+import { statSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import type { WorkflowOwner } from "./workflow.js";
+
+export const WORKFLOW_REHYDRATE_MESSAGE_TYPE = "workflow-rehydrate";
+export const REHYDRATE_TIMEOUT_MS = 10_000;
+
+/** Script locations a coordinator skill may ship, in precedence order, relative to its SKILL.md directory. */
+const REHYDRATE_SCRIPTS = [join("scripts", "rehydrate.mjs"), "rehydrate.mjs"];
+
+export function rehydrateFallbackMessage(owner: WorkflowOwner): string {
+  return `Your context was just compacted while you coordinate the ${owner.name} workflow. ` +
+    `Before your next step, read ${owner.path} in full, with no line limit.`;
+}
+
+/** The first rehydrate script the owner's skill ships, or undefined when it ships none. */
+export function findRehydrateScript(owner: WorkflowOwner): string | undefined {
+  const skillDir = dirname(owner.path);
+  for (const relative of REHYDRATE_SCRIPTS) {
+    const candidate = join(skillDir, relative);
+    try {
+      if (statSync(candidate).isFile()) return candidate;
+    } catch {
+      // Missing or unreadable: try the next location.
+    }
+  }
+  return undefined;
+}
+
+function runScript(script: string, cwd: string, timeoutMs: number): Promise<string> {
+  return new Promise((resolve, reject) => {
+    execFile("node", [script, "--cwd", cwd], { cwd, timeout: timeoutMs, encoding: "utf8", windowsHide: true },
+      (error, stdout) => (error ? reject(error) : resolve(stdout)));
+  });
+}
+
+/**
+ * The message to inject after a compaction while `owner` coordinates the session, or null for none.
+ * A skill's rehydrate script decides the text (empty output means no run is in progress); without
+ * a script, or when it fails or times out, the model is told to re-read SKILL.md. Never throws.
+ */
+export async function workflowRehydrateMessage(
+  owner: WorkflowOwner,
+  cwd: string,
+  options: { timeoutMs?: number } = {},
+): Promise<string | null> {
+  try {
+    const script = findRehydrateScript(owner);
+    if (!script) return rehydrateFallbackMessage(owner);
+    const stdout = (await runScript(script, cwd, options.timeoutMs ?? REHYDRATE_TIMEOUT_MS)).trim();
+    return stdout.length > 0 ? stdout : null;
+  } catch {
+    return rehydrateFallbackMessage(owner);
+  }
+}

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

@@ -16,7 +16,7 @@ By default, you see up to five steps around the current work. The view starts at
 
 Click the plan to expand or collapse it in Pi's fullscreen mode. In regular terminal mode, use `/plan expand` or `/plan collapse`. For the full plan with details, run `/plan`.
 
-Rows show `✓` for done, `●` for active, `○` for pending, and `!` for blocked. Pi marks steps complete explicitly; the count is not an estimate of effort.
+Rows show `✓` for done, `●` for active, `○` for pending, and `!` for blocked. Pi marks steps complete explicitly; the count is not an estimate of effort. The completion count is completed items / total eligible items: canceled workflow items (`cancelled` or `canceled`) are excluded from the total, while skipped and not-applicable items remain in it. Canceled items remain visible for 30 seconds after the cancellation is first observed, then disappear from the widget and plan lists without deleting their workflow records. This delay survives session reloads; reactivating an item makes it visible again. An all-canceled plan shows `0/0` complete.
 
 Your plan and display settings survive reload and follow the session branch. A completed checklist clears after 30 seconds. A released workflow plan stays visible for reference, but cannot be edited until the workflow resumes.
 

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

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-plan",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Structured execution plans with persistent progress for Pi.",
   "license": "MIT",
   "type": "module",

package/node_modules/pi-better-plan/src/cancelled-rows.ts

@@ -0,0 +1,36 @@
+import { CANCELLED_ROW_RETENTION_MS, isRecord, type RushPlan, type WorkflowPlanBinding } from "./workflow-plan.js";
+
+export const CANCELLED_ROWS_ENTRY = "pi-better-plan-cancelled-rows";
+
+export function observeCancelledRows(
+  plan: RushPlan,
+  binding: WorkflowPlanBinding,
+  entries: Iterable<{ type: string; customType?: string; data?: unknown }>,
+  append: (type: string, data: unknown) => void,
+  now = Date.now(),
+): void {
+  // Keep display deadlines in branch history, not in the workflow-owned task plan.
+  let previous: Record<string, unknown> = {};
+  for (const entry of entries) {
+    const data = entry.data;
+    if (entry.type === "custom" && entry.customType === CANCELLED_ROWS_ENTRY && isRecord(data) &&
+        data.version === 1 && data.path === binding.path && data.runId === binding.runId &&
+        data.owner === binding.owner && isRecord(data.rows)) previous = data.rows;
+  }
+  const rows: Record<string, number> = Object.create(null);
+  for (const unit of plan.issues) {
+    if (unit.status !== "cancelled" && unit.status !== "canceled") continue;
+    const saved = previous[unit.id];
+    unit.cancelledAt = typeof saved === "number" && Number.isFinite(saved) && saved >= 0 ? saved : now;
+    rows[unit.id] = unit.cancelledAt;
+  }
+  if (JSON.stringify(rows) !== JSON.stringify(previous)) {
+    append(CANCELLED_ROWS_ENTRY, { version: 1, ...binding, rows });
+  }
+}
+
+export function cancelledRowsClearDelay(plan: RushPlan, now = Date.now()): number | null {
+  const deadlines = plan.issues.flatMap(unit => unit.cancelledAt === undefined ? [] : [unit.cancelledAt + CANCELLED_ROW_RETENTION_MS])
+    .filter(deadline => deadline > now);
+  return deadlines.length ? Math.min(...deadlines) - now : null;
+}

package/node_modules/pi-better-plan/src/index.ts

@@ -18,8 +18,9 @@ import { createPlanWidget } from "./plan-widget.js";
 import { COMPACT_PLAN_ROWS } from "./plan-presentation.js";
 import {
   createRushPlanComponent, readRushPlan, renderRushPlan, workflowBinding,
-  WORKFLOW_PLAN_ENTRY, type RushPlan, type WorkflowPlanBinding,
+  WORKFLOW_PLAN_ENTRY, visibleRushUnits, type RushPlan, type WorkflowPlanBinding,
 } from "./workflow-plan.js";
+import { cancelledRowsClearDelay, observeCancelledRows } from "./cancelled-rows.js";
 import { applyRushPlanUpdate, type RushPlanUpdate } from "./workflow-plan-update.js";
 import {
   EXTENSION_NAME,
@@ -131,18 +132,45 @@ export default function planExtension(pi: ExtensionAPI): void {
   let rushError: string | null = null;
   let refreshWidget: ((force?: boolean) => void) | undefined;
   let completedPlanClearTimer: ReturnType<typeof setTimeout> | undefined;
+  let cancelledRowsTimer: ReturnType<typeof setTimeout> | undefined;
+  let refreshFullPlan: (() => void) | undefined;
+  const cancelCancelledRowsTimer = (): void => {
+    if (cancelledRowsTimer !== undefined) clearTimeout(cancelledRowsTimer);
+    cancelledRowsTimer = undefined;
+  };
+  const scheduleCancelledRowsClear = (): void => {
+    cancelCancelledRowsTimer();
+    if (!rushPlan) return;
+    const delay = cancelledRowsClearDelay(rushPlan);
+    if (delay === null) return;
+    const timer = setTimeout(() => {
+      if (cancelledRowsTimer !== timer) return;
+      cancelledRowsTimer = undefined;
+      refresh(true);
+      scheduleCancelledRowsClear();
+    }, delay);
+    cancelledRowsTimer = timer;
+    timer.unref?.();
+  };
+  const observeCancellations = (plan: RushPlan, binding: WorkflowPlanBinding, ctx: ExtensionContext): void => {
+    observeCancelledRows(plan, binding, ctx.sessionManager.getBranch(), (type, data) => pi.appendEntry(type, data));
+  };
   const unsubscribeWorkflow = pi.events.on("pi-better-workflow:changed", (owner) => {
     displayedWorkflowOwner = owner && typeof owner === "object" && "name" in owner && typeof owner.name === "string"
       ? owner.name : null;
     if (displayedWorkflowOwner) {
+      cancelCancelledRowsTimer();
       rushBinding = null;
       rushPlan = null;
       rushError = null;
     }
-    refreshWidget?.(true);
+    refresh(true);
   });
 
-  const refresh = (force = false): void => refreshWidget?.(force);
+  const refresh = (force = false): void => {
+    refreshWidget?.(force);
+    refreshFullPlan?.();
+  };
 
   const loadRushPlan = (ctx: ExtensionContext): RushPlan | null => {
     const owner = workflowPlanOwner(ctx);
@@ -152,33 +180,39 @@ export default function planExtension(pi: ExtensionAPI): void {
     if (!rushBinding) {
       rushPlan = null;
       rushError = null;
+      cancelCancelledRowsTimer();
       return null;
     }
     try {
       const plan = readRushPlan(rushBinding.path, ctx.cwd);
       if (plan.runId !== rushBinding.runId) throw new Error("Rush run identity changed.");
+      observeCancellations(plan, rushBinding, ctx);
       rushPlan = plan;
       rushError = null;
     } catch (error) {
       rushPlan = null;
       rushError = error instanceof Error ? error.message : String(error);
     }
+    scheduleCancelledRowsClear();
     refresh(true);
     return rushPlan;
   };
 
-  const displayWorkflowPlan = (plan: RushPlan, binding: WorkflowPlanBinding, readOnly = false): void => {
+  const displayWorkflowPlan = (plan: RushPlan, binding: WorkflowPlanBinding, ctx: ExtensionContext, readOnly = false): void => {
     if (!rushBinding || rushBinding.owner !== binding.owner || rushBinding.path !== binding.path || rushBinding.runId !== binding.runId) {
       pi.appendEntry(WORKFLOW_PLAN_ENTRY, { version: 1, kind: "set", ...binding });
     }
     displayedWorkflowOwner = readOnly ? null : binding.owner;
     rushBinding = binding;
+    observeCancellations(plan, binding, ctx);
     rushPlan = plan;
     rushError = null;
+    scheduleCancelledRowsClear();
     refresh(true);
   };
 
   const clearWorkflowPlan = (): void => {
+    cancelCancelledRowsTimer();
     if (rushBinding) pi.appendEntry(WORKFLOW_PLAN_ENTRY, { version: 1, kind: "clear" });
     rushBinding = null;
     rushPlan = null;
@@ -215,6 +249,7 @@ export default function planExtension(pi: ExtensionAPI): void {
 
   const restore = (ctx: ExtensionContext): void => {
     cancelCompletedPlanClear();
+    cancelCancelledRowsTimer();
     const state = reconstructPlanState(ctx.sessionManager.getBranch());
     currentPlan = state.plan;
     displayedWorkflowOwner = workflowPlanOwner(ctx);
@@ -271,7 +306,7 @@ export default function planExtension(pi: ExtensionAPI): void {
             if (!currentPlan) return [];
             return renderCompactPlan(currentPlan, width, theme as never, expanded);
           },
-          () => (rushBinding ? rushPlan?.issues.length ?? 0 : currentPlan?.steps.length ?? 0) > COMPACT_PLAN_ROWS,
+          () => (rushBinding && rushPlan ? visibleRushUnits(rushPlan).length : currentPlan?.steps.length ?? 0) > COMPACT_PLAN_ROWS,
           () => expanded,
           () => setExpanded(!expanded),
         );
@@ -300,16 +335,21 @@ export default function planExtension(pi: ExtensionAPI): void {
         ctx.ui.notify(renderRushPlan(plan, 160, true, undefined, planOwner, !owner).join("\n"), "info");
         return;
       }
-      await ctx.ui.custom<void>((tui, theme, _keys, done) => {
-        const fg = typeof theme?.fg === "function"
-          ? (color: string, value: string) => theme.fg(color as never, value)
-          : undefined;
-        const component = createRushPlanComponent(plan, () => done(), fg, planOwner, !owner);
-        return { render: (width) => component.render(width), handleInput(data) {
-          component.handleInput?.(data);
-          tui.requestRender();
-        }, invalidate: () => component.invalidate() };
-      });
+      try {
+        await ctx.ui.custom<void>((tui, theme, _keys, done) => {
+          refreshFullPlan = () => tui.requestRender();
+          const fg = typeof theme?.fg === "function"
+            ? (color: string, value: string) => theme.fg(color as never, value)
+            : undefined;
+          const component = createRushPlanComponent(() => rushPlan ?? { ...plan, issues: [] }, () => done(), fg, planOwner, !owner);
+          return { render: (width) => component.render(width), handleInput(data) {
+            component.handleInput?.(data);
+            tui.requestRender();
+          }, invalidate: () => component.invalidate() };
+        });
+      } finally {
+        refreshFullPlan = undefined;
+      }
       return;
     }
     if (!currentPlan) {
@@ -384,14 +424,14 @@ export default function planExtension(pi: ExtensionAPI): void {
           }
           binding = { owner: owner ?? binding!.owner, path, runId: plan.runId };
           if (transition.event === undefined) {
-            displayWorkflowPlan(plan, binding, !owner);
+            displayWorkflowPlan(plan, binding, ctx, !owner);
             return { content: [{ type: "text", text: `Showing ${binding.owner} rev ${plan.planRevision}: ${plan.issues.length} units.${owner ? "" : " Read-only handoff."}` }], details: { ok: true, runId: plan.runId, revision: plan.planRevision, ...(!owner ? { readOnly: true } : {}) } };
           }
         }
         if (!binding) throw new Error(`No ${owner} plan is bound; send workflow.path and workflow.revision to update_plan first.`);
         if (transition.event === undefined) throw new Error("workflow.path is required to bind or reload a plan; otherwise send workflow.event and changes.");
         const result = applyRushPlanUpdate(binding.path, ctx.cwd, binding.runId, { ...transition, event: transition.event });
-        displayWorkflowPlan(result.plan, binding);
+        displayWorkflowPlan(result.plan, binding, ctx);
         const rows = result.changed.map(({ target, id, added }) =>
           `${added ? "+" : ""}${id === null ? "run" : target === "unit" ? `#${id}` : id}`);
         const logNote = result.logAheadRevision === undefined ? ""
@@ -521,6 +561,8 @@ export default function planExtension(pi: ExtensionAPI): void {
   });
   pi.on("session_shutdown", async (_event, ctx) => {
     cancelCompletedPlanClear();
+    cancelCancelledRowsTimer();
+    refreshFullPlan = undefined;
     if (typeof unsubscribeWorkflow === "function") unsubscribeWorkflow();
     refreshWidget = undefined;
     try {

package/node_modules/pi-better-plan/src/plan-presentation.ts

@@ -12,6 +12,8 @@ export interface PlanRow {
   label: string;
   title: string;
   status: DisplayStatus;
+  // Workflow cancellations keep skipped styling but are excluded from the completion total.
+  cancelled?: boolean;
   statusLabel?: string;
   details?: string[];
 }
@@ -65,7 +67,8 @@ export function renderPlanPresentation(
 ): string[] {
   const size = Math.max(1, Math.floor(width));
   const count = (status: DisplayStatus) => plan.rows.filter((row) => row.status === status).length;
-  const summary = [`${count("completed")}/${plan.rows.length} complete`];
+  const total = plan.rows.filter((row) => !row.cancelled).length;
+  const summary = [`${count("completed")}/${total} complete`];
   for (const [status, label] of [
     ["in_progress", "in progress"], ["implemented", "implemented"], ["reviewed", "review passed"],
     ["blocked", "blocked"], ["failed", "failed"],
@@ -129,16 +132,22 @@ export function renderPlanPresentation(
 }
 
 export function createPlanPresentationComponent(
-  plan: PlanPresentation, theme: PlanRenderTheme, onClose: () => void,
+  source: PlanPresentation | (() => PlanPresentation), theme: PlanRenderTheme, onClose: () => void,
 ): Component {
+  const presentation = () => typeof source === "function" ? source() : source;
+  const plan = presentation();
   let selected = plan.rows.findIndex((row) => row.status === "in_progress");
   if (selected < 0) selected = plan.rows.findIndex((row) => row.status !== "completed");
   if (selected < 0) selected = Math.max(0, plan.rows.length - 1);
   return {
-    render: (width) => renderPlanPresentation(plan, width, theme, true, selected),
+    render: (width) => {
+      const current = presentation();
+      selected = Math.min(selected, Math.max(0, current.rows.length - 1));
+      return renderPlanPresentation(current, width, theme, true, selected);
+    },
     handleInput(data) {
       if (matchesKey(data, "up")) selected = Math.max(0, selected - 1);
-      else if (matchesKey(data, "down")) selected = Math.min(Math.max(0, plan.rows.length - 1), selected + 1);
+      else if (matchesKey(data, "down")) selected = Math.min(Math.max(0, presentation().rows.length - 1), selected + 1);
       else if (matchesKey(data, "escape") || matchesKey(data, "left") || matchesKey(data, "ctrl+c")) onClose();
     },
     invalidate() {},

package/node_modules/pi-better-plan/src/workflow-plan.ts

@@ -7,12 +7,14 @@ import {
 } from "./plan-presentation.js";
 
 export const WORKFLOW_PLAN_ENTRY = "pi-better-workflow-plan";
+export const CANCELLED_ROW_RETENTION_MS = 30_000;
 
 interface RushUnit {
   id: string;
   title: string;
   stage: string;
   status: string;
+  cancelledAt?: number;
   dependsOn: string[];
   worker?: string | number | undefined;
   note?: string | undefined;
@@ -134,7 +136,7 @@ function workflowStatus(status: string): DisplayStatus {
     case "pending": return "pending";
     case "blocked": return "blocked";
     case "failed": return "failed";
-    case "skipped": case "not-applicable": case "cancelled": return "skipped";
+    case "skipped": case "not-applicable": case "cancelled": case "canceled": return "skipped";
     default: return "unknown";
   }
 }
@@ -162,19 +164,25 @@ function presentRushPlan(plan: RushPlan, owner: string, readOnly = false): PlanP
   if (plan.spec?.title) metadata.push([{ color: "dim", text: plan.spec.title }]);
   return {
     metadata,
-    rows: plan.issues.map((unit) => {
+    rows: visibleRushUnits(plan).map((unit) => {
       const status = unitStatus(unit);
+      const cancelled = unit.status === "cancelled" || unit.status === "canceled";
       const details = [`${unit.stage} · ${unit.status}${unit.delivery ? ` · ${unit.delivery}` : ""}${unit.worker !== undefined ? ` · worker ${unit.worker}` : ""}`];
       if (unit.dependsOn.length) details.push(`after: ${unit.dependsOn.map((id) => `#${id}`).join(", ")}`);
       if (unit.note) details.push(unit.note);
       return {
-        label: `#${unit.id}`, title: unit.title, status, details,
-        ...(status === "unknown" || unit.status === "cancelled" ? { statusLabel: unit.status } : {}),
+        label: `#${unit.id}`, title: unit.title, status, cancelled, details,
+        ...(status === "unknown" || cancelled ? { statusLabel: unit.status } : {}),
       };
     }),
   };
 }
 
+export function visibleRushUnits(plan: RushPlan, now = Date.now()): RushPlan["issues"] {
+  return plan.issues.filter(unit => (unit.status !== "cancelled" && unit.status !== "canceled") ||
+    unit.cancelledAt === undefined || now < unit.cancelledAt + CANCELLED_ROW_RETENTION_MS);
+}
+
 export function renderRushPlan(
   plan: RushPlan,
   width: number,
@@ -189,12 +197,12 @@ export function renderRushPlan(
 }
 
 export function createRushPlanComponent(
-  plan: RushPlan,
+  source: RushPlan | (() => RushPlan),
   onClose: () => void,
   fg?: (color: string, value: string) => string,
   owner = "rush-issues",
   readOnly = false,
 ): Component {
   const theme = fg ? { fg } : plainPlanTheme;
-  return createPlanPresentationComponent(presentRushPlan(plan, owner, readOnly), theme, onClose);
+  return createPlanPresentationComponent(() => presentRushPlan(typeof source === "function" ? source() : source, owner, readOnly), theme, onClose);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-harness",
-  "version": "0.29.0",
+  "version": "0.29.2",
   "description": "Pi extension bundle for a write sandbox, subagents, background tasks, SSH, goals, and structured plans.",
   "license": "MIT",
   "type": "module",
@@ -54,8 +54,8 @@
   },
   "dependencies": {
     "pi-better-background-tasks": "0.9.0",
-    "pi-better-goal": "0.8.4",
-    "pi-better-plan": "0.9.0",
+    "pi-better-goal": "0.9.0",
+    "pi-better-plan": "0.9.1",
     "pi-better-sandbox": "0.12.0",
     "pi-better-ssh": "0.1.2",
     "pi-better-subagents": "0.18.0",