pi-better-goal 0.1.18 → 0.1.20

package/README.md

@@ -13,6 +13,7 @@ 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.
+- `escape` pauses the active goal; paused goals are never poked.
 - A compact goal widget that does not replace Pi's footer.
 - Background activity tracking for subagents and other registered providers.
 - A progress-aware follow-up loop that holds after repeated identical outcomes.

package/package.json

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

package/src/index.ts

@@ -19,6 +19,7 @@ import {
   goalWithStatus,
   validateObjective,
   validateTokenBudget,
+  type GoalEntrySource,
 } from "./goal-state.js";
 import { continuationEvidence, type ContinuationEvidence } from "./continuation.js";
 import { observeGoalStall } from "./stall.js";
@@ -73,6 +74,26 @@ function parseRetryLimit(raw: string | undefined, fallback: number): number {
   return Number.isInteger(parsed) && parsed >= 0 ? parsed : fallback;
 }
 
+/**
+ * True when the agent loop ended because the running turn was interrupted
+ * (escape / ctrl+c). An aborted run leaves a final assistant message whose
+ * stopReason is "aborted".
+ */
+function wasTurnAborted(messages: readonly unknown[]): boolean {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (!message || typeof message !== "object") {
+      continue;
+    }
+    const candidate = message as { role?: unknown; stopReason?: unknown };
+    if (candidate.role !== "assistant") {
+      continue;
+    }
+    return candidate.stopReason === "aborted";
+  }
+  return false;
+}
+
 function continuationPrompt(goal: GoalSnapshot): string {
   return [
     "Continue working toward the active thread goal.",
@@ -148,6 +169,9 @@ export default function (pi: ExtensionAPI): void {
 
   const getGoal = (ctx: ExtensionContext): GoalSnapshot | null => currentGoalSnapshot(ctx);
 
+  /** Only active goals receive autonomous pokes; paused, complete, and budget-limited goals never do. */
+  const isPokeable = (goal: GoalSnapshot | null): goal is GoalSnapshot => goal?.status === "active";
+
   const appendContinuationState = (state: ReturnType<typeof createContinuationState>): void => {
     pi.appendEntry(EXTENSION_NAME, continuationStateEntry(state));
   };
@@ -156,7 +180,7 @@ export default function (pi: ExtensionAPI): void {
     appendContinuationState(createContinuationState(goal.goalId));
   };
 
-  const setGoal = (goal: GoalSnapshot, ctx: ExtensionContext, source: "command" | "tool" | "runtime"): void => {
+  const setGoal = (goal: GoalSnapshot, ctx: ExtensionContext, source: GoalEntrySource): void => {
     pi.appendEntry(EXTENSION_NAME, goalSetEntry(goal, source));
     continuationQueuedFor = null;
     backgroundDrainTracker = null;
@@ -164,7 +188,7 @@ export default function (pi: ExtensionAPI): void {
     refreshGoalWidget?.();
   };
 
-  const clearGoal = (ctx: ExtensionContext, source: "command" | "tool" | "runtime"): void => {
+  const clearGoal = (ctx: ExtensionContext, source: GoalEntrySource): void => {
     const current = getGoal(ctx);
     pi.appendEntry(EXTENSION_NAME, goalClearEntry(current?.goalId ?? null, source));
     continuationQueuedFor = null;
@@ -174,7 +198,7 @@ export default function (pi: ExtensionAPI): void {
   };
 
   const queueGoalContinuation = (goal: GoalSnapshot): void => {
-    if (goal.status !== "active" || continuationQueuedFor === goal.goalId) {
+    if (!isPokeable(goal) || continuationQueuedFor === goal.goalId) {
       return;
     }
     clearIdleContinuation();
@@ -205,7 +229,7 @@ export default function (pi: ExtensionAPI): void {
     kind: "continuation" | "background-drained",
     snapshot?: ActivitySnapshot,
   ): void => {
-    if (WAKE_DISABLED || goal.status !== "active" || continuationQueuedFor === goal.goalId) {
+    if (WAKE_DISABLED || !isPokeable(goal) || continuationQueuedFor === goal.goalId) {
       return;
     }
     if (kind === "continuation" && currentContinuationState(ctx, goal.goalId)?.blocked) {
@@ -232,7 +256,7 @@ export default function (pi: ExtensionAPI): void {
     priorSnapshot?: ActivitySnapshot,
   ): Promise<void> => {
     const goal = currentGoalSnapshot(ctx);
-    if (goal?.status !== "active" || goal.goalId !== goalId || continuationQueuedFor === goal.goalId || foregroundRunning) {
+    if (!isPokeable(goal) || goal.goalId !== goalId || continuationQueuedFor === goal.goalId || foregroundRunning) {
       return;
     }
     const snapshot = await collectActivitySnapshot(ctx, providers.values(), foregroundRunning);
@@ -299,7 +323,7 @@ export default function (pi: ExtensionAPI): void {
       const goal = currentGoalSnapshot(ctx);
       const wakePlan = planBackgroundDrainWake(backgroundDrainTracker, goal, snapshot);
       backgroundDrainTracker = wakePlan.nextTracker;
-      if (goal?.status === "active" && wakePlan.wakeSignature) {
+      if (isPokeable(goal) && wakePlan.wakeSignature) {
         const wakeSignature = wakePlan.wakeSignature;
         if (wakeSignature !== lastWakeSignature) {
           lastWakeSignature = wakeSignature;
@@ -586,7 +610,7 @@ export default function (pi: ExtensionAPI): void {
     currentCtx = ctx;
     const goal = currentGoalSnapshot(ctx);
     const snapshot = await publishSnapshot(ctx);
-    if (goal?.status !== "active") {
+    if (!isPokeable(goal)) {
       return;
     }
 
@@ -609,8 +633,21 @@ export default function (pi: ExtensionAPI): void {
     await publishSnapshot(ctx);
   });
 
-  pi.on("agent_end", async (event, _ctx) => {
+  pi.on("agent_end", async (event, ctx) => {
     lastAgentEvidence = continuationEvidence(event.messages);
+    // `escape` is a pi-reserved built-in shortcut (`app.interrupt`), so extensions
+    // cannot register it. Observe the interrupt instead: when a running turn is
+    // aborted (escape / ctrl+c while streaming), pause the active goal so it does
+    // not auto-continue after the user stopped the agent.
+    if (wasTurnAborted(event.messages)) {
+      const goal = getGoal(ctx);
+      if (isPokeable(goal)) {
+        setGoal(goalWithStatus(goal, "paused"), ctx, "runtime");
+        if (ctx.hasUI) {
+          ctx.ui.notify("Goal paused (interrupted).", "info");
+        }
+      }
+    }
   });
 
   pi.on("agent_settled", async (_event, ctx) => {
@@ -618,37 +655,38 @@ export default function (pi: ExtensionAPI): void {
     foregroundRunning = false;
     const snapshot = await publishSnapshot(ctx);
     const goal = getGoal(ctx);
-    if (goal?.status === "active" && !snapshot.backgroundRunning) {
-      const previous = currentContinuationState(ctx, goal.goalId) ?? createContinuationState(goal.goalId);
-      const evidence = lastAgentEvidence ?? continuationEvidence([]);
-      const repeated = previous.lastEvidenceSignature === evidence.signature;
-      const noProgressRetries = repeated ? previous.noProgressRetries + 1 : 0;
-      const blocked = repeated && noProgressRetries >= MAX_NO_PROGRESS_RETRIES;
-      const now = Date.now();
-      appendContinuationState({
-        goalId: goal.goalId,
-        lastEvidenceSignature: evidence.signature,
-        lastEvidenceSummary: evidence.summary,
-        ...(repeated
-          ? (previous.lastProgressAt !== undefined ? { lastProgressAt: previous.lastProgressAt } : {})
-          : { lastProgressAt: now }),
-        noProgressRetries,
-        blocked,
-        updatedAt: Math.floor(now / 1000),
-      });
-      if (blocked) {
-        refreshGoalWidget?.();
-        if (ctx.hasUI) {
-          ctx.ui.setStatus(EXTENSION_NAME, "waiting: no progress");
-          ctx.ui.notify(
-            `Goal automatic continuation is waiting after ${noProgressRetries} identical retries (${evidence.summary}). New input or background activity will resume it.`,
-            "warning",
-          );
-        }
-        return;
+    if (!isPokeable(goal) || snapshot.backgroundRunning) {
+      return;
+    }
+    const previous = currentContinuationState(ctx, goal.goalId) ?? createContinuationState(goal.goalId);
+    const evidence = lastAgentEvidence ?? continuationEvidence([]);
+    const repeated = previous.lastEvidenceSignature === evidence.signature;
+    const noProgressRetries = repeated ? previous.noProgressRetries + 1 : 0;
+    const blocked = repeated && noProgressRetries >= MAX_NO_PROGRESS_RETRIES;
+    const now = Date.now();
+    appendContinuationState({
+      goalId: goal.goalId,
+      lastEvidenceSignature: evidence.signature,
+      lastEvidenceSummary: evidence.summary,
+      ...(repeated
+        ? (previous.lastProgressAt !== undefined ? { lastProgressAt: previous.lastProgressAt } : {})
+        : { lastProgressAt: now }),
+      noProgressRetries,
+      blocked,
+      updatedAt: Math.floor(now / 1000),
+    });
+    if (blocked) {
+      refreshGoalWidget?.();
+      if (ctx.hasUI) {
+        ctx.ui.setStatus(EXTENSION_NAME, "waiting: no progress");
+        ctx.ui.notify(
+          `Goal automatic continuation is waiting after ${noProgressRetries} identical retries (${evidence.summary}). New input or background activity will resume it.`,
+          "warning",
+        );
       }
-      scheduleIdleContinuation(goal, ctx, "continuation", snapshot);
+      return;
     }
+    scheduleIdleContinuation(goal, ctx, "continuation", snapshot);
   });
 
   pi.on("session_shutdown", async (_event, ctx) => {