@kky42/pi-goal 1.0.1 → 1.0.2

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## 1.0.2 - 2026-05-30
+
+- Prevents `/goal` argument autocomplete from injecting `pause`, `resume`, or `clear` into free-form goal objectives while preserving explicit subcommand completion.
+- Sends overflow-recovery goal continuations as user-started follow-ups when pi's host overflow cap needs a user turn, while keeping normal continuations hidden.
+- Makes headless `/goal <objective>` replace existing non-complete goals deterministically and drain scheduled goal continuations until the goal leaves `active`, instead of exiting without model output or after only the first turn.
+
 ## 1.0.1 - 2026-05-30
 
 - Exposes the extension through a root `index.ts` package entry so pi displays the installed package as `@kky42/pi-goal` instead of `@kky42/pi-goal:src`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kky42/pi-goal",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Codex-style goal tracking and continuation for pi.",
   "type": "module",
   "author": "kky42",

package/src/commands.ts

@@ -8,7 +8,7 @@ export interface CommandHost {
   getGoal(): ThreadGoal | null;
   setGoal(goal: ThreadGoal, source: GoalEntrySource, ctx: GoalCommandContext): void;
   clearGoal(source: GoalEntrySource, ctx: GoalCommandContext): void;
-  requestContinuation(ctx: GoalCommandContext): void;
+  requestContinuation(ctx: GoalCommandContext): boolean;
 }
 
 const COMMANDS = ["pause", "resume", "clear"] as const;
@@ -19,14 +19,38 @@ export type GoalCommandPi = Pick<ExtensionAPI, "registerCommand">;
 export interface GoalCommandContext {
   hasUI: boolean;
   ui: Pick<ExtensionCommandContext["ui"], "confirm" | "notify" | "setStatus">;
+  waitForIdle?: ExtensionCommandContext["waitForIdle"];
 }
 
-function completions(prefix: string) {
-  return COMMANDS.filter((command) => command.startsWith(prefix)).map((command) => ({
+async function waitForHeadlessContinuationDrain(
+  host: CommandHost,
+  ctx: GoalCommandContext,
+): Promise<void> {
+  if (ctx.hasUI || !ctx.waitForIdle) {
+    return;
+  }
+  while (host.getGoal()?.status === "active") {
+    await ctx.waitForIdle();
+    if (host.getGoal()?.status !== "active") {
+      return;
+    }
+    if (!host.requestContinuation(ctx)) {
+      return;
+    }
+  }
+}
+
+function completions(argumentPrefix: string) {
+  const prefix = argumentPrefix.trim();
+  if (prefix.length === 0 || /\s/.test(argumentPrefix)) {
+    return null;
+  }
+  const items = COMMANDS.filter((command) => command.startsWith(prefix)).map((command) => ({
     value: command,
     label: command,
     description: `goal ${command}`,
   }));
+  return items.length > 0 ? items : null;
 }
 
 export async function handleGoalCommand(
@@ -64,16 +88,13 @@ export async function handleGoalCommand(
     ctx.ui.notify(result.message);
     if (trimmed === "resume" && result.goal.status === "active") {
       host.requestContinuation(ctx);
+      await waitForHeadlessContinuationDrain(host, ctx);
     }
     return;
   }
 
   const current = host.getGoal();
-  if (current && current.status !== "complete") {
-    if (!ctx.hasUI) {
-      ctx.ui.notify("Clear the existing goal before replacing it.", "error");
-      return;
-    }
+  if (current && current.status !== "complete" && ctx.hasUI) {
     const shouldReplace = await ctx.ui.confirm(
       "Replace goal?",
       `Current goal:\n${current.objective}\n\nNew goal:\n${trimmed}`,
@@ -92,13 +113,14 @@ export async function handleGoalCommand(
   host.setGoal(result.goal, "command", ctx);
   ctx.ui.notify([GOLDEN_SET_BANNER, formatGoalSummary(result.goal)].join("\n"));
   host.requestContinuation(ctx);
+  await waitForHeadlessContinuationDrain(host, ctx);
 }
 
 export function registerGoalCommand(pi: GoalCommandPi, host: CommandHost): void {
   pi.registerCommand("goal", {
     description: "Show or manage the current Codex-style goal.",
     getArgumentCompletions(argumentPrefix) {
-      return completions(argumentPrefix.trim());
+      return completions(argumentPrefix);
     },
     async handler(args: string, ctx: ExtensionCommandContext) {
       await handleGoalCommand(pi, host, args, ctx);

package/src/continuation-scheduler.ts

@@ -1,7 +1,8 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 
-import { continuationGoalIdFromPrompt, continuationPrompt } from "./prompts.js";
+import { continuationGoalIdFromPrompt, continuationPrompt, markedContinuationPrompt } from "./prompts.js";
 import {
+  goalStartTurnStrategy,
   recoveryPhaseBlocksContinuation,
   type GoalRecoveryMachineState,
 } from "./recovery-machine.js";
@@ -11,7 +12,7 @@ import type { StaleQueuedWorkGuard } from "./stale-queued-work-guard.js";
 import { CUSTOM_ENTRY_TYPE, type ThreadGoal } from "./types.js";
 
 interface ContinuationSchedulerDeps {
-  pi: Pick<ExtensionAPI, "sendMessage">;
+  pi: Pick<ExtensionAPI, "sendMessage" | "sendUserMessage">;
   getGoal: () => ThreadGoal | null;
   getRecoveryState: () => GoalRecoveryMachineState;
   staleQueuedWorkGuard: StaleQueuedWorkGuard;
@@ -96,6 +97,10 @@ export function createContinuationScheduler(deps: ContinuationSchedulerDeps) {
 
   const sendContinuation = (goalToContinue: ThreadGoal): void => {
     continuationQueuedFor = goalToContinue.goalId;
+    if (goalStartTurnStrategy(deps.getRecoveryState().phase) === "userFollowUp") {
+      deps.pi.sendUserMessage(markedContinuationPrompt(goalToContinue), { deliverAs: "followUp" });
+      return;
+    }
     deps.pi.sendMessage(
       {
         customType: CUSTOM_ENTRY_TYPE,
@@ -107,17 +112,20 @@ export function createContinuationScheduler(deps: ContinuationSchedulerDeps) {
     );
   };
 
-  const requestContinuation = (ctx: ExtensionContext): void => {
+  const requestContinuation = (ctx: ExtensionContext): boolean => {
     const goal = deps.getGoal();
     if (
       deps.staleQueuedWorkGuard.isBlockingContinuation() ||
       !goal ||
       goal.status !== "active" ||
-      continuationQueuedFor === goal.goalId ||
       hasPendingRecoveryAttention() ||
       recoveryPhaseBlocksContinuation(deps.getRecoveryState().phase)
     ) {
-      return;
+      return false;
+    }
+
+    if (continuationQueuedFor === goal.goalId) {
+      return true;
     }
 
     const goalId = goal.goalId;
@@ -125,12 +133,12 @@ export function createContinuationScheduler(deps: ContinuationSchedulerDeps) {
       if (continuationScheduledFor === goalId) {
         clearContinuationTimer();
       }
-      return;
+      return false;
     }
 
     if (!ctx.isIdle()) {
       if (continuationScheduledFor === goalId) {
-        return;
+        return true;
       }
       continuationScheduledFor = goalId;
       continuationTimer = setTimeout(() => {
@@ -139,7 +147,7 @@ export function createContinuationScheduler(deps: ContinuationSchedulerDeps) {
         requestContinuation(ctx);
       }, CONTINUATION_RETRY_MS);
       continuationTimer.unref?.();
-      return;
+      return true;
     }
 
     clearContinuationTimer();
@@ -155,9 +163,10 @@ export function createContinuationScheduler(deps: ContinuationSchedulerDeps) {
       hasPendingRecoveryAttention() ||
       recoveryPhaseBlocksContinuation(deps.getRecoveryState().phase)
     ) {
-      return;
+      return false;
     }
     sendContinuation(currentGoal);
+    return true;
   };
 
   return {

package/src/format.ts

@@ -45,7 +45,7 @@ function twoDigit(value: number): string {
 export function formatLocalTimestamp(unixSeconds: number): string {
   const date = new Date(Math.max(0, Math.trunc(unixSeconds)) * 1000);
   const day = `${date.getFullYear()}-${twoDigit(date.getMonth() + 1)}-${twoDigit(date.getDate())}`;
-  const time = `${twoDigit(date.getHours())}-${twoDigit(date.getMinutes())}-${twoDigit(date.getSeconds())}`;
+  const time = `${twoDigit(date.getHours())}:${twoDigit(date.getMinutes())}:${twoDigit(date.getSeconds())}`;
   return `${day} ${time}`;
 }
 

package/src/goal-runtime-controller.ts

@@ -27,7 +27,7 @@ export interface GoalRuntimeController extends GoalRuntimeEventHandlers {
   setGoal(goal: ThreadGoal, source: GoalEntrySource, ctx: ExtensionContext): void;
   clearGoal(source: GoalEntrySource, ctx: ExtensionContext): void;
   updateGoal(status: "complete" | "blocked", source: GoalEntrySource, ctx: ExtensionContext): GoalResult;
-  requestContinuation(ctx: ExtensionContext): void;
+  requestContinuation(ctx: ExtensionContext): boolean;
 }
 
 export function createGoalRuntimeController(pi: ExtensionAPI): GoalRuntimeController {

package/src/goal-runtime-event-handler-types.ts

@@ -54,7 +54,7 @@ export interface GoalRuntimeContinuationPort {
   clearPassthroughContinuationInput: () => void;
   continuationGoalIdFromRuntimePrompt: (prompt: string) => string | null;
   notePassthroughContinuationInput: (input: string) => void;
-  requestContinuation: (ctx: ExtensionContext) => void;
+  requestContinuation: (ctx: ExtensionContext) => boolean;
 }
 
 export interface GoalAccountingPort {

package/src/goal-runtime-input-context-handlers.ts

@@ -130,7 +130,6 @@ export function createInputContextEventHandlers(
 
       continuation.clearContinuationStateFor(queuedGoalId);
       if (stateController.isCurrentActiveGoalId(queuedGoalId)) {
-        stateController.persistHostOverflowUserReset(false);
         runtimeState.staleQueuedWorkGuard.noteRunnableWorkStarted();
         if (isCommandResumeQueuedGoalMessage(event.message)) {
           resetErrorRecovery();

package/src/prompts.ts

@@ -36,6 +36,10 @@ export function continuationGoalIdFromPrompt(prompt: string): string | null {
   return prompt.slice(CONTINUATION_MARKER_PREFIX.length, end);
 }
 
+export function markedContinuationPrompt(goal: ThreadGoal): string {
+  return [`${CONTINUATION_MARKER_PREFIX}${goal.goalId}" />`, "", continuationPrompt(goal)].join("\n");
+}
+
 function formatOptionalTokenBudget(goal: ThreadGoal): string {
   return goal.tokenBudget === null ? "none" : formatTokenValue(goal.tokenBudget);
 }

package/src/recovery-machine.ts

@@ -71,6 +71,7 @@ export function onRecoverySuccessfulTurn(
     return false;
   }
   resetRecoveryCounters(state);
+  clearActiveHostOverflowRecovery(state);
   return true;
 }
 

package/src/recovery-runtime.ts

@@ -19,7 +19,7 @@ interface RecoveryRuntimeDeps {
   clearContinuationState: () => void;
   pauseGoalForRecovery: (ctx: ExtensionContext, recoveryReason: string) => void;
   refreshUi: (ctx: ExtensionContext) => void;
-  requestContinuation: (ctx: ExtensionContext) => void;
+  requestContinuation: (ctx: ExtensionContext) => boolean;
 }
 
 export function createGoalRecoveryRuntime(deps: RecoveryRuntimeDeps) {