killeros 2.1.26 → 2.1.28

package/killeros/goal-settlement.ts

@@ -1,9 +1,18 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { AutoCompactionGoalHandlers } from "./auto-compaction.ts";
 import { reportError } from "./errors.ts";
-import { isGoalModeSupported, isSavedSession, pauseGoalAfterFailure, pauseGoalAtTurnLimit, scheduleGoalContinuation, syncGoalUpdateTool, transitionGoal } from "./goal-runtime.ts";
-import { pauseGoalState } from "./goal-state.ts";
-import type { GoalRuntime, InitRuntime } from "./runtime.ts";
+import {
+  isGoalModeSupported,
+  isSavedSession,
+  pauseGoalAfterFailure,
+  pauseGoalAtTurnLimit,
+  resumeInterruptedGoalTurn,
+  scheduleGoalContinuation,
+  syncGoalUpdateTool,
+  transitionGoal,
+} from "./goal-runtime.ts";
+import { boundGoalText, pauseGoalState } from "./goal-state.ts";
+import type { GoalRuntime, GoalState } from "./runtime.ts";
 import { safeTerminalText } from "./safe-terminal-text.ts";
 
 function pauseGoalForPossibleManualCompaction(
@@ -13,14 +22,16 @@ function pauseGoalForPossibleManualCompaction(
   reason: string,
 ): void {
   if (runtime.state?.status !== "active") return;
-  const safeReason = safeTerminalText(reason);
+  const safeReason = boundGoalText(reason) || "the agent turn was aborted";
   try {
     transitionGoal(pi, runtime, "error", "paused", safeReason, {
       resumeAfterManualCompaction: true,
+      keepTurnForRecovery: true,
+      preserveTurnAuthorization: true,
     });
   } catch {
     const current = runtime.state;
-    runtime.state = current ? pauseGoalState(current, safeReason, Date.now(), true) : undefined;
+    runtime.state = current ? pauseGoalState(current, safeReason, Date.now(), true, true) : undefined;
     syncGoalUpdateTool(pi, runtime);
     runtime.persistenceRetryNeeded = true;
     runtime.continuationScheduled = false;
@@ -28,7 +39,7 @@ function pauseGoalForPossibleManualCompaction(
     runtime.requestRender?.();
   }
   ctx.ui.notify(
-    "Goal paused because the turn was aborted. If /compact is running, KillerOS will resume after Pi saves the summary. Run /goal pause to keep it paused.",
+    "Goal paused because the turn was aborted. If /compact is running, KillerOS will resume the same goal turn after Pi saves the summary. Run /goal pause to keep it paused.",
     "warning",
   );
 }
@@ -36,14 +47,20 @@ function pauseGoalForPossibleManualCompaction(
 function recoverGoalAfterManualCompaction(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
-  initState: InitRuntime,
   ctx: ExtensionContext,
 ): boolean {
   if (runtime.state?.status !== "paused"
-    || runtime.state.resumeAfterManualCompaction !== true
-    || initState.active) return false;
+    || runtime.state.resumeAfterManualCompaction !== true) return false;
+  const state = runtime.state;
+  const sameTurn = state.turnDecision === undefined;
+  const turn = runtime.goalTurn?.turn ?? state.turns;
+  const generation = runtime.lifecycleGeneration;
+  let resumed: GoalState;
   try {
-    transitionGoal(pi, runtime, "resume", "active", undefined, { resetBlockedAudit: true });
+    resumed = transitionGoal(pi, runtime, "resume", "active", undefined, {
+      ...(sameTurn ? { resumeInterruptedTurn: true as const } : {}),
+      preserveTurnAuthorization: true,
+    });
   } catch (error) {
     runtime.persistenceRetryNeeded = true;
     reportError(ctx, "Manual compaction succeeded, but the goal could not be resumed", error);
@@ -51,63 +68,93 @@ function recoverGoalAfterManualCompaction(
   }
   runtime.continuationScheduled = false;
   runtime.automaticCompaction = undefined;
-  ctx.ui.notify("Manual compaction complete. Goal resumed.", "info");
-  setImmediate(() => scheduleGoalContinuation(pi, runtime, initState, ctx));
+  if (sameTurn) {
+    runtime.goalTurn = { turn, revision: runtime.state?.revision ?? state.revision };
+    runtime.goalTurnInFlight = true;
+    runtime.agentEndObserved = false;
+    if (ctx.mode !== "tui") ctx.ui.notify("Manual compaction complete. The interrupted goal turn resumed.", "info");
+    setImmediate(() => {
+      if (runtime.lifecycleGeneration !== generation || runtime.state !== resumed) return;
+      resumeInterruptedGoalTurn(pi, runtime, ctx);
+    });
+  } else {
+    runtime.goalTurn = undefined;
+    runtime.goalTurnInFlight = false;
+    if (scheduleGoalContinuation(pi, runtime, ctx) && ctx.mode !== "tui") ctx.ui.notify("Manual compaction complete. Goal resumed.", "info");
+  }
   return true;
 }
 
-/** Resumes the paused revision after both compaction and goal-turn settlement report an outcome. */
+/** Resumes the paused revision only after compaction and the interrupted turn have both settled. */
 function finalizeAutomaticCompaction(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
-  initState: InitRuntime,
   ctx: ExtensionContext,
 ): void {
   const recovery = runtime.automaticCompaction;
   if (!recovery || recovery.outcome === "pending" || !recovery.turnSettled) return;
-  const skipped = recovery.outcome === "skipped";
-  runtime.automaticCompaction = undefined;
   if (runtime.state?.status !== "paused"
-    || runtime.state.revision !== recovery.pausedRevision
-    || initState.active) return;
+    || runtime.state.revision !== recovery.pausedRevision) {
+    runtime.automaticCompaction = undefined;
+    return;
+  }
+  const state = runtime.state;
+  const sameTurn = recovery.resumeSameTurn;
+  const generation = runtime.lifecycleGeneration;
+  runtime.automaticCompaction = undefined;
+  let resumed: GoalState;
   try {
-    transitionGoal(pi, runtime, "resume", "active", undefined, { resetBlockedAudit: true });
+    resumed = transitionGoal(pi, runtime, "resume", "active", undefined, {
+      ...(sameTurn ? { resumeInterruptedTurn: true as const } : {}),
+      ...(!sameTurn && state.turnDecision !== undefined ? { preserveTurnAuthorization: true as const } : {}),
+    });
   } catch (error) {
     runtime.persistenceRetryNeeded = true;
-    reportError(ctx, skipped
-      ? "Automatic compaction was skipped, but the goal could not be resumed"
+    reportError(ctx, sameTurn
+      ? "Automatic compaction succeeded, but the interrupted goal turn could not be resumed"
       : "Automatic compaction succeeded, but the goal could not be resumed", error);
     return;
   }
   runtime.continuationScheduled = false;
-  setImmediate(() => scheduleGoalContinuation(pi, runtime, initState, ctx));
+  if (sameTurn) {
+    runtime.goalTurn = { turn: recovery.turn, revision: runtime.state?.revision ?? state.revision };
+    runtime.goalTurnInFlight = false;
+    runtime.agentEndObserved = false;
+    setImmediate(() => {
+      if (runtime.lifecycleGeneration !== generation
+        || runtime.state !== resumed
+        || runtime.goalTurn?.turn !== recovery.turn) return;
+      runtime.goalTurnInFlight = true;
+      resumeInterruptedGoalTurn(pi, runtime, ctx);
+    });
+    return;
+  }
+  runtime.goalTurn = undefined;
+  runtime.goalTurnInFlight = false;
+  if (pauseGoalAtTurnLimit(pi, runtime, ctx)) return;
+  setImmediate(() => scheduleGoalContinuation(pi, runtime, ctx, { generation, state: resumed }));
 }
 
-/** Records Pi's successful compaction callback and attempts guarded recovery. */
 function completeAutomaticCompaction(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
-  initState: InitRuntime,
   ctx: ExtensionContext,
 ): void {
   if (!runtime.automaticCompaction) return;
   runtime.automaticCompaction.outcome = "completed";
-  finalizeAutomaticCompaction(pi, runtime, initState, ctx);
+  finalizeAutomaticCompaction(pi, runtime, ctx);
 }
 
-/** Records Pi's expected session-too-small rejection and resumes without claiming compaction succeeded. */
 function skipAutomaticCompaction(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
-  initState: InitRuntime,
   ctx: ExtensionContext,
 ): void {
   if (!runtime.automaticCompaction) return;
   runtime.automaticCompaction.outcome = "skipped";
-  finalizeAutomaticCompaction(pi, runtime, initState, ctx);
+  finalizeAutomaticCompaction(pi, runtime, ctx);
 }
 
-/** Consumes automatic recovery and records its failure on the eligible paused goal. */
 function stopAutomaticCompactionRecovery(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
@@ -116,13 +163,17 @@ function stopAutomaticCompactionRecovery(
 ): void {
   const recovery = runtime.automaticCompaction;
   runtime.automaticCompaction = undefined;
-  const safeReason = safeTerminalText(reason);
+  const safeReason = boundGoalText(reason) || "automatic compaction failed";
   if (runtime.state?.status !== "paused" || runtime.state.revision !== recovery?.pausedRevision) return;
   try {
     transitionGoal(pi, runtime, "error", "paused", safeReason);
   } catch {
-    runtime.state = { ...runtime.state, result: safeReason };
+    runtime.state = pauseGoalState(runtime.state, safeReason, Date.now());
+    syncGoalUpdateTool(pi, runtime);
     runtime.persistenceRetryNeeded = true;
+    runtime.continuationScheduled = false;
+    runtime.goalTurn = undefined;
+    runtime.goalTurnInFlight = false;
     runtime.requestRender?.();
   }
   ctx.ui.notify(
@@ -131,7 +182,6 @@ function stopAutomaticCompactionRecovery(
   );
 }
 
-/** Leaves the goal paused when Pi rejects automatic compaction. */
 function failAutomaticCompaction(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
@@ -148,15 +198,32 @@ function failAutomaticCompaction(
   stopAutomaticCompactionRecovery(pi, runtime, ctx, `automatic compaction failed: ${reason}`);
 }
 
+function settleGoalTurn(
+  pi: ExtensionAPI,
+  runtime: GoalRuntime,
+  ctx: ExtensionContext,
+  settledTurn: number,
+): void {
+  const state = runtime.state;
+  if (state?.status !== "active") return;
+  const decision = state.turnDecision;
+  if (!decision || decision.turn !== settledTurn) {
+    pauseGoalAfterFailure(pi, runtime, ctx, "no turn decision");
+    return;
+  }
+  if (pauseGoalAtTurnLimit(pi, runtime, ctx)) return;
+  scheduleGoalContinuation(pi, runtime, ctx);
+}
+
 export function registerGoalSettlement(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
-  initState: InitRuntime,
 ): AutoCompactionGoalHandlers {
   pi.on("agent_settled", (_event, ctx) => {
     const wasGoalTurn = runtime.goalTurnInFlight;
     const continuationWasScheduled = runtime.continuationScheduled;
     const agentEndObserved = runtime.agentEndObserved;
+    const settledTurn = runtime.goalTurn?.turn;
     runtime.goalTurnInFlight = false;
     runtime.agentEndObserved = false;
     runtime.continuationScheduled = false;
@@ -166,6 +233,12 @@ export function registerGoalSettlement(
       const error = safeTerminalText(runtime.lastError ?? "");
       runtime.lastStopReason = undefined;
       runtime.lastError = undefined;
+      if (runtime.automaticCompaction.turnSettled
+        && (settledTurn === undefined || settledTurn === runtime.automaticCompaction.turn)) {
+        // The interrupted turn already settled; a repeated settlement carries no new
+        // information, so keep waiting for compaction instead of failing the recovery.
+        return;
+      }
       const expectedInterruption = stopReason === "aborted"
         || stopReason === "error" && error === "This operation was aborted";
       if (!wasGoalTurn || !agentEndObserved) {
@@ -181,19 +254,29 @@ export function registerGoalSettlement(
         );
         return;
       }
-      runtime.automaticCompaction.turnSettled = true;
-      finalizeAutomaticCompaction(pi, runtime, initState, ctx);
+      if (settledTurn !== undefined && runtime.automaticCompaction.turn === settledTurn) {
+        runtime.automaticCompaction.turnSettled = true;
+      } else {
+        stopAutomaticCompactionRecovery(pi, runtime, ctx, "the goal turn identity changed during compaction");
+        return;
+      }
+      finalizeAutomaticCompaction(pi, runtime, ctx);
       return;
     }
 
-    if (!wasGoalTurn || runtime.state?.status !== "active" || initState.active) {
-      if (continuationWasScheduled && runtime.state?.status === "active" && !initState.active) {
+    if (!wasGoalTurn || runtime.state?.status !== "active") {
+      if (continuationWasScheduled && runtime.state?.status === "active") {
         pauseGoalAfterFailure(pi, runtime, ctx, "the goal continuation ended before an agent turn started");
-      } else if (runtime.state?.status === "active" && !initState.active) {
-        scheduleGoalContinuation(pi, runtime, initState, ctx);
+      } else if (runtime.state?.status === "active"
+        && (runtime.state.turnPhase === "ready" || runtime.state.turnPhase === "authorized")) {
+        scheduleGoalContinuation(pi, runtime, ctx);
       }
       return;
     }
+    if (settledTurn === undefined) {
+      pauseGoalAfterFailure(pi, runtime, ctx, "the goal turn identity was lost");
+      return;
+    }
     if (!agentEndObserved) {
       pauseGoalAfterFailure(pi, runtime, ctx, "the goal turn ended without an agent result");
       return;
@@ -214,44 +297,52 @@ export function registerGoalSettlement(
     }
     runtime.lastStopReason = undefined;
     runtime.lastError = undefined;
-    if (pauseGoalAtTurnLimit(pi, runtime, ctx)) return;
-    scheduleGoalContinuation(pi, runtime, initState, ctx);
+    settleGoalTurn(pi, runtime, ctx, settledTurn);
   });
 
   pi.on("session_compact", (event, ctx) => {
     if (runtime.automaticCompaction !== undefined) return;
     if (event.reason !== "manual") return;
-    recoverGoalAfterManualCompaction(pi, runtime, initState, ctx);
+    recoverGoalAfterManualCompaction(pi, runtime, ctx);
   });
 
   return {
     isActive: (ctx: ExtensionContext): boolean => isGoalModeSupported(ctx)
       && isSavedSession(ctx)
-      && runtime.state?.status === "active"
-      && !initState.active,
+      && runtime.state?.status === "active",
     onRequested: (): void => {
       if (runtime.state?.status !== "active") return;
+      const current = runtime.state;
+      // A turn that already accepted continue or a blocker audit owns a pending
+      // authorization; recovery must take the next-turn path, never resume the decided turn.
+      const resumeSameTurn = runtime.goalTurnInFlight && current.turnDecision === undefined;
       try {
-        const paused = transitionGoal(pi, runtime, "pause", "paused");
+        const paused = transitionGoal(pi, runtime, "pause", "paused", undefined, {
+          keepTurnForRecovery: true,
+          preserveTurnAuthorization: true,
+        });
         runtime.automaticCompaction = {
           pausedRevision: paused.revision,
           outcome: "pending",
           turnSettled: false,
+          turn: current.turns,
+          resumeSameTurn,
         };
       } catch (error) {
-        const current = runtime.state;
-        const reason = safeTerminalText(`automatic compaction pause could not be saved: ${error instanceof Error ? error.message : String(error)}`);
+        const reason = boundGoalText(`automatic compaction pause could not be saved: ${error instanceof Error ? error.message : String(error)}`);
         runtime.state = current ? pauseGoalState(current, reason, Date.now()) : undefined;
         syncGoalUpdateTool(pi, runtime);
         runtime.persistenceRetryNeeded = true;
         runtime.continuationScheduled = false;
         runtime.automaticCompaction = undefined;
+        runtime.goalTurn = undefined;
+        runtime.goalTurnInFlight = false;
         runtime.requestRender?.();
         throw error;
       }
     },
-    onCompleted: (ctx: ExtensionContext): void => completeAutomaticCompaction(pi, runtime, initState, ctx),
+    onCompleted: (ctx: ExtensionContext): void => completeAutomaticCompaction(pi, runtime, ctx),
     onFailed: (ctx: ExtensionContext, error: unknown): void => failAutomaticCompaction(pi, runtime, ctx, error),
-    onSkipped: (ctx: ExtensionContext): void => skipAutomaticCompaction(pi, runtime, initState, ctx),
+    onSkipped: (ctx: ExtensionContext): void => skipAutomaticCompaction(pi, runtime, ctx),
   };
 }