killeros 2.1.26 → 2.1.28

package/killeros/goal-runtime.ts

@@ -1,15 +1,24 @@
-import { type ExtensionAPI, type ExtensionCommandContext, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { reportError } from "./errors.ts";
-import { beginGoalTurnState, checkpointActiveGoalState, GOAL_VERSION, parseGoalState, pauseGoalState, transitionGoalState, type GoalTransitionOptions } from "./goal-state.ts";
+import {
+  beginGoalTurnState,
+  boundGoalText,
+  checkpointActiveGoalState,
+  GOAL_VERSION,
+  parseGoalState,
+  pauseGoalState,
+  transitionGoalState,
+  type GoalTransitionOptions,
+} from "./goal-state.ts";
 import { resolvePersonalInstructions } from "./personal-instructions.ts";
-import type { GoalRuntime, GoalState, GoalStatus, InitRuntime } from "./runtime.ts";
+import type { GoalRuntime, GoalState, GoalStatus } from "./runtime.ts";
 import { safeTerminalText } from "./safe-terminal-text.ts";
 
 export const GOAL_ENTRY_TYPE = "killeros-goal";
 const GOAL_CONTINUATION_TYPE = "killeros-goal-continuation";
 export const GOAL_UPDATE_TOOL = "killeros_goal_update";
 
-export type GoalEntryEvent = "set" | "replace" | "limit" | "turn" | "pause" | "resume" | "blocked" | "complete" | "error" | "clear" | "checkpoint" | "blocker-audit";
+export type GoalEntryEvent = "set" | "replace" | "limit" | "turn" | "continue" | "pause" | "resume" | "blocked" | "complete" | "error" | "clear" | "checkpoint" | "blocker-audit";
 export interface GoalEntryData {
   version: 1;
   event: GoalEntryEvent;
@@ -75,18 +84,32 @@ export function sumGoalTokens(ctx: ExtensionContext): number {
 }
 
 function setGoalUpdateToolActive(pi: ExtensionAPI, active: boolean): void {
-  const activeTools = pi.getActiveTools();
-  const isActive = activeTools.includes(GOAL_UPDATE_TOOL);
-  if (active === isActive) return;
-  pi.setActiveTools(active
-    ? [...activeTools, GOAL_UPDATE_TOOL]
-    : activeTools.filter((name) => name !== GOAL_UPDATE_TOOL));
+  try {
+    const activeTools = pi.getActiveTools();
+    const isActive = activeTools.includes(GOAL_UPDATE_TOOL);
+    if (active === isActive) return;
+    pi.setActiveTools(active
+      ? [...activeTools, GOAL_UPDATE_TOOL]
+      : activeTools.filter((name) => name !== GOAL_UPDATE_TOOL));
+  } catch {
+    // Availability is checked again immediately before a goal request.
+  }
 }
 
 export function syncGoalUpdateTool(pi: ExtensionAPI, runtime: GoalRuntime): void {
   setGoalUpdateToolActive(pi, runtime.state?.status === "active");
 }
 
+function goalUpdateToolIsAvailable(pi: ExtensionAPI): boolean {
+  try {
+    const active = pi.getActiveTools();
+    if (!active.includes(GOAL_UPDATE_TOOL)) pi.setActiveTools([...active, GOAL_UPDATE_TOOL]);
+    return pi.getActiveTools().includes(GOAL_UPDATE_TOOL);
+  } catch {
+    return false;
+  }
+}
+
 export function persistGoalState(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
@@ -94,7 +117,6 @@ export function persistGoalState(
   state: GoalState | undefined,
 ): void {
   const data: GoalEntryData = { version: GOAL_VERSION, event, state: state ?? null };
-  runtime.automaticCompaction = undefined;
   pi.appendEntry(GOAL_ENTRY_TYPE, data);
   runtime.state = state;
   syncGoalUpdateTool(pi, runtime);
@@ -117,6 +139,15 @@ export function transitionGoal(
   if (status !== "active") {
     runtime.continuationScheduled = false;
     runtime.automaticCompaction = undefined;
+    if (!options.keepTurnForRecovery) {
+      runtime.goalTurn = undefined;
+      runtime.goalTurnInFlight = false;
+      runtime.agentEndObserved = false;
+    }
+  } else if (!options.resumeInterruptedTurn) {
+    runtime.goalTurn = undefined;
+    runtime.goalTurnInFlight = false;
+    runtime.agentEndObserved = false;
   }
   return next;
 }
@@ -141,6 +172,7 @@ function clearGoalExecutionFlags(runtime: GoalRuntime): void {
   runtime.continuationScheduled = false;
   runtime.goalTurnInFlight = false;
   runtime.agentEndObserved = false;
+  runtime.goalTurn = undefined;
   runtime.automaticCompaction = undefined;
   runtime.lastStopReason = undefined;
   runtime.lastError = undefined;
@@ -156,6 +188,10 @@ export async function stopGoalRun(runtime: GoalRuntime, ctx: ExtensionCommandCon
   }
 }
 
+function safeFailureReason(reason: string): string {
+  return boundGoalText(reason) || "an unspecified goal failure";
+}
+
 export function pauseGoalAfterFailure(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
@@ -165,7 +201,11 @@ export function pauseGoalAfterFailure(
   notify = true,
 ): void {
   if (runtime.state?.status !== "active") return;
-  const safeReason = safeTerminalText(reason);
+  const safeReason = safeFailureReason(reason);
+  const safeRecoveryInstruction = safeReason === "no turn decision"
+    && recoveryInstruction === "Run /goal resume after resolving the problem."
+    ? "The agent ended without choosing continue, complete, or blocked. Run /goal resume only after choosing to continue."
+    : safeTerminalText(recoveryInstruction);
   try {
     transitionGoal(pi, runtime, "error", "paused", safeReason);
   } catch {
@@ -173,11 +213,34 @@ export function pauseGoalAfterFailure(
     runtime.state = current ? pauseGoalState(current, safeReason, Date.now()) : undefined;
     syncGoalUpdateTool(pi, runtime);
     runtime.persistenceRetryNeeded = true;
-    runtime.continuationScheduled = false;
-    runtime.automaticCompaction = undefined;
+    clearGoalExecutionFlags(runtime);
+    runtime.requestRender?.();
+  }
+  if (notify) ctx.ui.notify(`Goal paused: ${safeReason}\n${safeRecoveryInstruction}`, "error");
+}
+
+function pauseGoalBeforeTurn(
+  pi: ExtensionAPI,
+  runtime: GoalRuntime,
+  ctx: ExtensionContext,
+): void {
+  const state = runtime.state;
+  if (state?.status !== "active") return;
+  const nextTurn = state.turns + 1;
+  const reason = "killeros_goal_update is unavailable";
+  try {
+    transitionGoal(pi, runtime, "error", "paused", reason);
+  } catch {
+    runtime.state = pauseGoalState(state, reason, Date.now());
+    syncGoalUpdateTool(pi, runtime);
+    runtime.persistenceRetryNeeded = true;
+    clearGoalExecutionFlags(runtime);
     runtime.requestRender?.();
   }
-  if (notify) ctx.ui.notify(`Goal paused: ${safeReason}\n${recoveryInstruction}`, "error");
+  ctx.ui.notify(
+    `Goal paused before turn ${nextTurn}: ${reason}\nEnable the goal tool, then run /goal resume.`,
+    "error",
+  );
 }
 
 function beginGoalTurn(
@@ -186,13 +249,15 @@ function beginGoalTurn(
   ctx: ExtensionContext,
   current: Extract<GoalState, { status: "active" }>,
 ): GoalState | undefined {
-  const next = beginGoalTurnState(current, Date.now());
+  let next: GoalState;
   try {
+    next = beginGoalTurnState(current, Date.now());
     persistGoalState(pi, runtime, "turn", next);
   } catch (error) {
     pauseGoalAfterFailure(pi, runtime, ctx, `turn state could not be saved: ${error instanceof Error ? error.message : String(error)}`);
     return undefined;
   }
+  runtime.goalTurn = { revision: next.revision, turn: next.turns };
   runtime.goalTurnInFlight = true;
   runtime.agentEndObserved = false;
   runtime.lastStopReason = undefined;
@@ -200,42 +265,85 @@ function beginGoalTurn(
   return next;
 }
 
-/** Starts one goal turn only after Pi is idle and all competing workflow gates are clear. */
-export function scheduleGoalContinuation(
+function sendGoalTurn(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
-  initState: InitRuntime,
   ctx: ExtensionContext,
+  state: Extract<GoalState, { status: "active" }>,
 ): boolean {
-  if (isGoalModeSupported(ctx) && isSavedSession(ctx) && pauseGoalAtTurnLimit(pi, runtime, ctx)) return false;
-  if (!isGoalModeSupported(ctx)
-    || !isSavedSession(ctx)
-    || runtime.state?.status !== "active"
-    || runtime.continuationScheduled
-    || runtime.continuationHeld
-    || runtime.goalTurnInFlight
-    || initState.active
-    || !ctx.isIdle()
-    || ctx.hasPendingMessages()) return false;
   runtime.continuationScheduled = true;
-  const next = beginGoalTurn(pi, runtime, ctx, runtime.state);
-  if (!next) return false;
   try {
     pi.sendMessage({
       customType: GOAL_CONTINUATION_TYPE,
-      content: goalContinuationMessage(next, ctx),
+      content: goalContinuationMessage(state, ctx),
       display: false,
     }, { triggerTurn: true, deliverAs: "followUp" });
     return true;
   } catch (error) {
     runtime.continuationScheduled = false;
     runtime.goalTurnInFlight = false;
+    runtime.goalTurn = undefined;
     pauseGoalAfterFailure(pi, runtime, ctx, `continuation could not start: ${error instanceof Error ? error.message : String(error)}`);
     return false;
   }
 }
 
+export function resumeInterruptedGoalTurn(
+  pi: ExtensionAPI,
+  runtime: GoalRuntime,
+  ctx: ExtensionContext,
+): boolean {
+  const state = runtime.state;
+  if (state?.status !== "active"
+    || (state.turnPhase !== "in-flight" && state.turnPhase !== "authorized")
+    || !runtime.goalTurnInFlight) return false;
+  if (!goalUpdateToolIsAvailable(pi)) {
+    pauseGoalBeforeTurn(pi, runtime, ctx);
+    return false;
+  }
+  return sendGoalTurn(pi, runtime, ctx, state);
+}
+
+/** Starts one goal turn only after Pi is idle and all competing workflow gates are clear. */
+export function scheduleGoalContinuation(
+  pi: ExtensionAPI,
+  runtime: GoalRuntime,
+  ctx: ExtensionContext,
+  guard?: { generation: number; state: GoalState },
+): boolean {
+  if (guard && (guard.generation !== runtime.lifecycleGeneration || runtime.state !== guard.state)) return false;
+  if (isGoalModeSupported(ctx) && isSavedSession(ctx) && pauseGoalAtTurnLimit(pi, runtime, ctx)) return false;
+  if (!isGoalModeSupported(ctx)
+    || !isSavedSession(ctx)
+    || runtime.state?.status !== "active"
+    || runtime.continuationScheduled
+    || runtime.continuationHeld
+    || runtime.goalTurnInFlight
+    || !ctx.isIdle()
+    || ctx.hasPendingMessages()) return false;
+
+  const current = runtime.state;
+  const phase = current.turnPhase;
+  const canStart = phase === "ready"
+    || phase === "authorized"
+    || phase === undefined && current.turns === 0;
+  if (!canStart || phase === "authorized" && current.turnDecision === undefined) return false;
+  if (!goalUpdateToolIsAvailable(pi)) {
+    pauseGoalBeforeTurn(pi, runtime, ctx);
+    return false;
+  }
+  const next = beginGoalTurn(pi, runtime, ctx, current);
+  return next !== undefined && sendGoalTurn(pi, runtime, ctx, next as Extract<GoalState, { status: "active" }>);
+}
+
 function goalInstructions(state: GoalState, heading: string): string {
+  const previous = state.lastDecision;
+  const continuation = previous?.kind === "continue"
+    ? [
+      "The previous turn's accepted next action was model-reported (not independently verified):",
+      previous.nextAction,
+    ]
+    : [];
   return [
     `# ${heading}`,
     `Status: active · Turn: ${state.turns}`,
@@ -244,10 +352,18 @@ function goalInstructions(state: GoalState, heading: string): string {
     "",
     "Treat the exact objective above from /goal as authoritative; a compaction summary may describe it but does not replace it.",
     "If the current context contains a compaction summary, take its first concrete next step after checking the current repository state.",
+    ...continuation,
     "Continue making concrete progress toward this unchanged objective. Re-check repository state and prior results instead of repeating work.",
-    "Do not stop merely because one response is complete: KillerOS will start another goal turn while the goal remains active.",
-    "Before declaring completion, audit every part of the objective and verify the relevant results. Then call killeros_goal_update with status complete and concise evidence.",
-    "Call killeros_goal_update with status blocked and the same lowercase blockerKey on each turn where one external impasse persists; attempts one and two record the audit, and attempt three marks the goal blocked.",
+    ...(state.turnDecision === undefined
+      ? [
+        "Before ending this turn, choose exactly one accepted goal decision.",
+        "After auditing and verifying the whole objective, call killeros_goal_update with status complete and concise evidence.",
+        "If useful work remains, call killeros_goal_update with status continue, concrete evidence from this turn, and one concrete nextAction toward the unchanged objective.",
+        "If one external impasse persists, call killeros_goal_update with status blocked, the same lowercase blockerKey, and current evidence; attempts one and two record audits and attempt three marks the goal blocked.",
+      ]
+      : ["This logical turn already has one accepted decision. Do not call killeros_goal_update again; finish the interrupted request, then let KillerOS start the authorized next turn after settlement."]),
+    "A normal response without one accepted decision pauses the goal. Do not restate a previous result as progress.",
+    "Goal evidence and nextAction are model-reported; KillerOS does not verify progress from prose or tool activity.",
     "Never use the goal tool to pause, resume, edit, replace, or clear the objective. Those transitions belong to the user.",
   ].join("\n");
 }
@@ -260,9 +376,7 @@ function goalContinuationMessage(state: GoalState, ctx: ExtensionContext): strin
   const sections = [goalInstructions(state, "KillerOS long-running goal turn")];
   if (ctx.isProjectTrusted()) {
     const personal = resolvePersonalInstructions(ctx.cwd);
-    if (personal) {
-      sections.push(personal);
-    }
+    if (personal) sections.push(personal);
   }
   return sections.join("\n\n");
 }
@@ -282,30 +396,40 @@ export function isSavedSession(ctx: ExtensionContext): boolean {
 export function registerGoalRuntime(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
-  initState: InitRuntime,
 ): void {
   const restoreGoal = (ctx: ExtensionContext): void => {
+    runtime.lifecycleGeneration += 1;
+    const generation = runtime.lifecycleGeneration;
     const restored = restoreGoalState(ctx);
     runtime.state = isGoalModeSupported(ctx) ? restored.state : undefined;
     syncGoalUpdateTool(pi, runtime);
     runtime.continuationScheduled = false;
     runtime.continuationHeld = false;
     runtime.goalTurnInFlight = false;
+    runtime.goalTurn = undefined;
     runtime.agentEndObserved = false;
     runtime.automaticCompaction = undefined;
     runtime.persistenceRetryNeeded = false;
     runtime.lastStopReason = undefined;
     runtime.lastError = undefined;
     runtime.requestRender?.();
-    if (runtime.state?.status === "active") {
-      setImmediate(() => scheduleGoalContinuation(pi, runtime, initState, ctx));
+    const state = runtime.state;
+    if (state?.status !== "active") return;
+    if ((state.turnPhase === "in-flight") || (state.turnPhase === undefined && state.turns > 0)) {
+      pauseGoalAfterFailure(pi, runtime, ctx, "no turn decision");
+      return;
     }
+    setImmediate(() => {
+      if (runtime.lifecycleGeneration !== generation || runtime.state !== state) return;
+      scheduleGoalContinuation(pi, runtime, ctx, { generation, state });
+    });
   };
 
   pi.on("session_start", (_event, ctx) => restoreGoal(ctx));
   pi.on("session_tree", (_event, ctx) => restoreGoal(ctx));
 
   pi.on("session_shutdown", (_event, ctx) => {
+    runtime.lifecycleGeneration += 1;
     if (runtime.state?.status === "active") {
       const checkpoint = checkpointActiveGoalState(runtime.state, Date.now());
       try {
@@ -316,22 +440,41 @@ export function registerGoalRuntime(
     }
     runtime.state = undefined;
     syncGoalUpdateTool(pi, runtime);
-    runtime.continuationScheduled = false;
+    clearGoalExecutionFlags(runtime);
     runtime.continuationHeld = false;
-    runtime.goalTurnInFlight = false;
-    runtime.agentEndObserved = false;
-    runtime.automaticCompaction = undefined;
     runtime.persistenceRetryNeeded = false;
-    runtime.lastStopReason = undefined;
-    runtime.lastError = undefined;
   });
 
   pi.on("before_agent_start", (event, ctx) => {
     runtime.continuationScheduled = false;
     if (!runtime.goalTurnInFlight && isGoalModeSupported(ctx) && isSavedSession(ctx) && pauseGoalAtTurnLimit(pi, runtime, ctx)) return;
     const current = runtime.state;
-    if (!isGoalModeSupported(ctx) || !isSavedSession(ctx) || !current || current.status !== "active" || initState.active) return;
-    if (runtime.goalTurnInFlight) return { systemPrompt: `${event.systemPrompt}\n\n${goalSystemPrompt(current)}` };
+    if (!isGoalModeSupported(ctx) || !isSavedSession(ctx) || !current || current.status !== "active") return;
+    if (runtime.goalTurnInFlight) {
+      if (!goalUpdateToolIsAvailable(pi)) {
+        pauseGoalBeforeTurn(pi, runtime, ctx);
+        try {
+          ctx.abort();
+        } catch {
+          // The state is already paused; a host abort may be unavailable during startup.
+        }
+        return;
+      }
+      return { systemPrompt: `${event.systemPrompt}\n\n${goalSystemPrompt(current)}` };
+    }
+    if (current.turnPhase === "in-flight") {
+      pauseGoalAfterFailure(pi, runtime, ctx, "no turn decision");
+      return;
+    }
+    if (!goalUpdateToolIsAvailable(pi)) {
+      pauseGoalBeforeTurn(pi, runtime, ctx);
+      try {
+        ctx.abort();
+      } catch {
+        // See the in-flight branch above.
+      }
+      return;
+    }
     const next = beginGoalTurn(pi, runtime, ctx, current);
     if (!next) return;
     return { systemPrompt: `${event.systemPrompt}\n\n${goalSystemPrompt(next)}` };