@pi-unipi/unipi 3.0.0-alpha.2 → 3.0.0-alpha.21

package/packages/long-horizon/src/commands.ts

@@ -2,9 +2,12 @@
  * Long-horizon commands — the explicit mode triggers.
  *
  *   /unipi:goal|ralph|swarm|graph <prompt>   turn override + prompt
+ *   /unipi:goal|swarm|graph stop             END the active owner (terminal)
+ *   /unipi:ralph stop                        park the active loop
  *   /unipi:goal|ralph|swarm|graph status     owner + mode snapshot
  *   /unipi:goal|ralph|swarm|graph resume     reactivate the parked owner
  *   /unipi:goal|ralph|swarm|graph clear      drop the parked owner
+ *   /unipi:regular                           stop any owner, pin regular mode
  *   /unipi:continue                          resume the parked owner
  *
  * Switching while an owner is active suspends it (max-1 park slot; the
@@ -13,14 +16,23 @@
  */
 
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { emitEvent, UNIPI_EVENTS } from "@pi-unipi/core";
-import type { LhMode } from "./modes.js";
+import { appendProgress, emitEvent, sendHarnessUserMessage, UNIPI_EVENTS, type ProgressData } from "@pi-unipi/core";
+import type { LhMode, OwnerKind } from "./modes.js";
 import { MODE_REGISTRY } from "./modes.js";
 import type { Gate } from "./gate.js";
 import type { OwnerCoordinator } from "./owner.js";
 import type { RalphLoop } from "./engine/ralph.js";
+import type { GoalMachine } from "./engine/goal-state.js";
+import type { GoalToolset } from "./tools/goal.js";
 import { loadSettings } from "./settings.js";
 
+/** Progress-bar hooks (all output is user-only; see src/progress.ts). */
+export interface ProgressHooks {
+  ralphBar(): ProgressData | undefined;
+  estimateGoal(ctx: ExtensionCommandContext): Promise<"ok" | "none" | "failed">;
+  goalEstimateOn(): boolean;
+}
+
 export interface LongHorizonCommandDeps {
   readonly gate: Gate;
   readonly owner: OwnerCoordinator;
@@ -32,6 +44,37 @@ function notify(ctx: ExtensionCommandContext, text: string): void {
   if (ctx.hasUI) ctx.ui.notify(text, "info");
 }
 
+/**
+ * Terminally end the active owner (optionally only one kind): goal marked
+ * complete(user_requested), pending proposal dropped, owner → history, session
+ * pinned to regular mode. Returns the stopped owner id, undefined when nothing
+ * (of that kind) is active. Shared by /unipi:<mode> stop, /unipi:regular, and
+ * the unipi:goal-stop runner.
+ */
+export function stopActiveOwner(
+  pi: ExtensionAPI,
+  gate: Gate,
+  owner: OwnerCoordinator,
+  machine?: GoalMachine,
+  toolset?: GoalToolset,
+  kind?: OwnerKind,
+): string | undefined {
+  const active = owner.getActive();
+  if (!active || (kind !== undefined && active.kind !== kind)) return undefined;
+  if (active.kind === "goal") {
+    machine?.clear();
+    toolset?.discardProposal();
+  }
+  const finished = owner.finish("stopped(user_requested)");
+  emitEvent(pi, UNIPI_EVENTS.LONG_HORIZON_OWNER_CHANGED, {
+    event: "stopped",
+    kind: active.kind,
+    ...(finished ? { ownerId: finished.ownerId } : {}),
+  });
+  gate.setSessionMode("none");
+  return finished?.ownerId ?? active.ownerId;
+}
+
 function ownerSnapshotText(owner: OwnerCoordinator): string {
   const active = owner.getActive();
   const parked = owner.getParked();
@@ -55,10 +98,10 @@ function ownerSnapshotText(owner: OwnerCoordinator): string {
 
 /** Short user-facing mode descriptions: use case + cost/success (design §2 rubric). */
 const MODE_DESCRIPTIONS = {
-  goal: "One objective until verifiably true. Use: medium-complex single deliverables. Cost/success: pareto per success. (<prompt> | status | resume | clear)",
+  goal: "One objective until verifiably true. Use: medium-complex single deliverables. Cost/success: pareto per success. (<prompt> | status | stop | resume | clear)",
   ralph: "Checklist grind over iterations. Use: enumerable chores, repo-scale plans. Cost/success: low cost, solid success. (start <name> | stop | status | resume | clear | <prompt>)",
-  swarm: "Parallel fan-out + one synthesis. Use: complex decomposable work. Cost/success: higher cost, high coverage. (<prompt> | status | resume | clear)",
-  graph: "Dependent multi-step work. Use: later steps need earlier results. Cost/success: highest; run when the shape demands it. (<prompt> | status | resume | clear)",
+  swarm: "Parallel fan-out + one synthesis. Use: complex decomposable work. Cost/success: higher cost, high coverage. (<prompt> | status | stop | resume | clear)",
+  graph: "Dependent multi-step work. Use: later steps need earlier results. Cost/success: highest; run when the shape demands it. (<prompt> | status | stop | resume | clear)",
 } as const;
 
 interface CompletionItem {
@@ -71,6 +114,7 @@ interface CompletionItem {
 const goalCompletions = (prefix: string): CompletionItem[] => {
   const subs: CompletionItem[] = [
     { value: "status", label: "status", description: "show owner + mode snapshot" },
+    { value: "stop", label: "stop", description: "end the active owner (terminal)" },
     { value: "resume", label: "resume", description: "reactivate the parked owner" },
     { value: "clear", label: "clear", description: "drop the parked owner" },
   ];
@@ -98,7 +142,13 @@ export function registerLongHorizonCommands(
   gate: Gate,
   owner: OwnerCoordinator,
   ralph?: RalphLoop,
+  progressHooks?: ProgressHooks,
+  machine?: GoalMachine,
+  toolset?: GoalToolset,
 ): void {
+  /** Kept for the modeHandler closure — see exported stopActiveOwner. */
+  const stopActiveOwnerFor = (kind?: OwnerKind): string | undefined =>
+    stopActiveOwner(pi, gate, owner, machine, toolset, kind);
   const modeHandler = (mode: LhMode) => async (args: string, ctx: ExtensionCommandContext): Promise<void> => {
     const definition = MODE_REGISTRY[mode];
     const parts = args.trim().split(/\s+/);
@@ -146,6 +196,22 @@ export function registerLongHorizonCommands(
           ? `Loop "${loopState.name}": iteration ${loopState.iteration}, ${progress.checked}/${progress.total} items checked.\nNext: ${progress.next.slice(0, 3).join(" · ") || "(all checked)"}\n${ownerSnapshotText(owner)}`
           : ownerSnapshotText(owner),
       );
+      const bar = progress.total > 0 ? progressHooks?.ralphBar() : undefined;
+      if (bar) appendProgress(pi, bar);
+      return;
+    }
+
+    // stop — terminally END the active owner (goal/swarm/graph; ralph's stop
+    // stays park). A subcommand, never a prompt: it must not fall through to
+    // the <prompt> branch below.
+    if (mode !== "ralph" && sub === "stop") {
+      const stopped = stopActiveOwnerFor(mode as OwnerKind);
+      notify(
+        ctx,
+        stopped !== undefined
+          ? `${definition.label} stopped.`
+          : `No active ${definition.label.toLowerCase()}.`,
+      );
       return;
     }
 
@@ -158,6 +224,13 @@ export function registerLongHorizonCommands(
           `\nJudge: ${settings.judge.enabled ? `${settings.judge.provider}/${settings.judge.model} (threshold ${settings.judge.threshold})` : "off"} — default mode: ${settings.defaultMode}` +
           `\nSettings: ~/.pi/agent/settings.json → unipi.longHorizon`,
       );
+      // /goal status: estimate progress + summary in a side call (user-only).
+      if (mode === "goal" && progressHooks?.goalEstimateOn()) {
+        ctx.ui.setStatus?.("lh-progress", "◎ estimating goal progress…");
+        const outcome = await progressHooks.estimateGoal(ctx);
+        ctx.ui.setStatus?.("lh-progress", undefined);
+        if (outcome === "failed") notify(ctx, "Goal progress estimate failed (model unavailable or unparseable reply).");
+      }
       return;
     }
 
@@ -174,17 +247,32 @@ export function registerLongHorizonCommands(
       emitEvent(pi, UNIPI_EVENTS.LONG_HORIZON_OWNER_CHANGED, { event: "resumed", ownerId: resumed.ownerId });
       const resumeMode = resumed.kind === "ralph-loop" ? "ralph" : resumed.kind;
       gate.setExplicit(resumeMode as LhMode);
-      await pi.sendUserMessage("Continue the resumed owner from its own durable state; re-read its status before acting.");
+      await sendHarnessUserMessage(
+        pi,
+        "Continue the resumed owner from its own durable state; re-read its status before acting.",
+        { source: "Long-horizon", title: "Resume", synopsis: "Owner resumed from durable state" },
+      );
       return;
     }
 
     if (sub === "clear") {
+      const active = owner.getActive();
+      if (active) {
+        const noun = active.kind === "ralph-loop" ? "ralph loop" : active.kind;
+        notify(
+          ctx,
+          active.kind === "ralph-loop"
+            ? "A ralph loop is running — /unipi:ralph stop parks it, or /unipi:regular ends it."
+            : `A ${noun} is running — use /unipi:${noun} stop to end it.`,
+        );
+        return;
+      }
       const cleared = owner.clearParked();
       notify(
         ctx,
         cleared
           ? `Cleared parked ${cleared.kind} "${cleared.label}".`
-          : "Nothing parked to clear.",
+          : "Nothing to clear.",
       );
       if (cleared) {
         emitEvent(pi, UNIPI_EVENTS.LONG_HORIZON_OWNER_CHANGED, { event: "cleared", ownerId: cleared.ownerId });
@@ -221,5 +309,13 @@ export function registerLongHorizonCommands(
   pi.registerCommand("unipi:ralph", { description: MODE_DESCRIPTIONS.ralph, getArgumentCompletions: ralphCompletions, handler: modeHandler("ralph") });
   pi.registerCommand("unipi:swarm", { description: MODE_DESCRIPTIONS.swarm, getArgumentCompletions: goalCompletions, handler: modeHandler("swarm") });
   pi.registerCommand("unipi:graph", { description: MODE_DESCRIPTIONS.graph, getArgumentCompletions: goalCompletions, handler: modeHandler("graph") });
+  pi.registerCommand("unipi:regular", {
+    description: "Regular mode — stop any active owner and run prompts without long-horizon routing",
+    handler: async (_args: string, ctx: ExtensionCommandContext): Promise<void> => {
+      stopActiveOwnerFor();
+      gate.setSessionMode("none");
+      notify(ctx, "Regular mode.");
+    },
+  });
 
 }

package/packages/long-horizon/src/compaction-brief.ts

@@ -0,0 +1,35 @@
+/**
+ * Active-work brief for compaction summaries: what the goal / ralph loop is
+ * doing right now, from durable state rather than transcript guesses.
+ */
+
+import type { GoalState } from "./engine/goal-state.js";
+import type { LoopFileState } from "./engine/ralph.js";
+
+const clip = (text: string, max: number): string => {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length <= max ? flat : `${flat.slice(0, max - 1)}…`;
+};
+
+export function longHorizonCompactionBrief(
+  goal: GoalState | null,
+  loop: LoopFileState | null,
+  ralphDir: string,
+): string | null {
+  const lines: string[] = [];
+  if (loop && loop.status === "active") {
+    const max = loop.maxIterations > 0 ? `/${loop.maxIterations}` : "";
+    lines.push(
+      `Ralph loop "${loop.name}" is running — iteration ${loop.iteration}${max}.`,
+      `Task file (the checklist is the source of truth, re-read it): ${ralphDir}/${loop.taskFile}`,
+      "Work the next unchecked items, update the task file, then call ralph_done.",
+    );
+  } else if (goal && goal.status === "active") {
+    const stall = goal.noProgressStreak > 0 ? `, ${goal.noProgressStreak}/${goal.stallCap} no-progress` : "";
+    lines.push(
+      `Goal (active, turn ${goal.turn}/${goal.maxTurns}${stall}): "${clip(goal.objective, 700)}"`,
+      "Keep working toward it; call get_goal for the durable state. Completion is judged by an independent verifier.",
+    );
+  }
+  return lines.length > 0 ? lines.join("\n") : null;
+}

package/packages/long-horizon/src/engine/continuation.ts

@@ -55,8 +55,20 @@ export interface ContinuationDeps {
   readonly owner: OwnerCoordinator;
   /** Verifier wiring; defaults to a VerifierDeps the caller provides. */
   readonly verifier: VerifierDeps;
-  /** Deliver a continuation/kickoff/wrap-up message (tail message). */
-  send(message: string): void;
+  /**
+   * Deliver a continuation/kickoff/wrap-up message. Messages go to the
+   * arbiter's nudge stash (long-horizon/index.ts), NOT the message queue;
+   * `kind: "kickoff"` marks the kickoff contract, which is never overwritten
+   * while undelivered.
+   */
+  send(message: string, kind?: "kickoff"): void;
+  /**
+   * Direct delivery for TIMER wakes while idle (waiting-backoff): an event,
+   * not a nudge — bypasses the stash and prompts immediately.
+   */
+  sendNow?(message: string): void;
+  /** User-only notification (wired to ctx.ui.notify at agent_end; optional in tests). */
+  notify?(text: string, level?: "info" | "warning" | "error"): void;
   getTokenCount?(): number | undefined;
   now?(): number;
   schedule?(callback: () => void, delayMs: number): void;
@@ -108,6 +120,23 @@ export class GoalContinuation {
     this.evaluateOverride = evaluate;
   }
 
+  private tokensEstimated = false;
+  private notifyOverride?: NonNullable<ContinuationDeps["notify"]>;
+
+  /** Late-bound: the last turn's tokens were estimated, not read from usage. */
+  setTokensEstimated(estimated: boolean): void {
+    this.tokensEstimated = estimated;
+  }
+
+  /** Late-bound user notification (ctx.ui.notify at agent_end). */
+  setNotify(notify: NonNullable<ContinuationDeps["notify"]>): void {
+    this.notifyOverride = notify;
+  }
+
+  private inform(text: string, level: "info" | "warning" | "error" = "warning"): void {
+    (this.notifyOverride ?? this.deps.notify)?.(text, level);
+  }
+
   /** Crash/interrupt marker: the next continuation carries the recovery fragment. */
   armRecovery(): void {
     this.recoveryArmed = true;
@@ -115,7 +144,7 @@ export class GoalContinuation {
 
   /** Deliver the kickoff contract once for a fresh goal (cache-stable). */
   deliverKickoff(goal: GoalState): void {
-    this.deps.send(renderKickoff(goal.objective));
+    this.deps.send(renderKickoff(goal.objective), "kickoff");
     this.deps.machine.markKickoffDelivered(goal.goalId);
     this.consecutiveWaits = 0;
     this.lastVerifierReason = undefined;
@@ -128,11 +157,19 @@ export class GoalContinuation {
   async onTurnEnd(activity: TurnActivity): Promise<ContinuationDecision> {
     const machine = this.deps.machine;
     const goal = machine.getActive();
-    if (!goal) return { action: "none", reason: "no-active-goal" };
+    if (!goal) {
+      // No drivable goal: a pending proposal could never be settled — drop it
+      // so get_goal stops advertising "verification pending" forever.
+      this.deps.toolset.discardProposal();
+      return { action: "none", reason: "no-active-goal" };
+    }
 
     // Kickoff not yet delivered (e.g., goal created mid-turn): contract first.
+    // The kickoff turn never settles — a proposal made beside creation is
+    // stale by definition; discard it instead of letting it outlive the turn.
     if (!goal.kickoffDelivered) {
       this.deliverKickoff(goal);
+      this.deps.toolset.discardProposal();
       return { action: "none", reason: "kickoff-delivered" };
     }
 
@@ -149,11 +186,16 @@ export class GoalContinuation {
         commands: activity.commands,
         recentTail: activity.recentTail,
       });
-      const verdict = await verifyCompletion(
-        { ...this.deps.verifier, ...(this.evaluateOverride ? { evaluate: this.evaluateOverride } : {}) },
-        goal.objective,
-        brief,
-      );
+      const verify = () =>
+        verifyCompletion(
+          { ...this.deps.verifier, ...(this.evaluateOverride ? { evaluate: this.evaluateOverride } : {}) },
+          goal.objective,
+          brief,
+        );
+      // One transient evaluator failure gets a retry inside the same
+      // settlement; a second failure is `verifierUnavailable`, never a verdict.
+      let verdict = await verify();
+      if (verdict.evaluatorFailed) verdict = await verify();
       this.lastVerifierReason = verdict.evaluatorFailed
         ? undefined
         : `${verdict.reason}${verdict.missing.length > 0 ? ` (missing: ${verdict.missing.join("; ")})` : ""}`;
@@ -162,11 +204,27 @@ export class GoalContinuation {
         revision: goal.revision,
         completionClaim: { ...(proposal.summary !== undefined ? { summary: proposal.summary } : {}) },
         verifier: { verdict: verdict.verdict, ...(verdict.missing.length > 0 ? { missing: verdict.missing } : {}) },
-        // A rejected claim is no progress; a met claim completed above; an
-        // inconclusive/failed verifier is neutral (undefined).
-        madeProgress: verdict.verdict === "not_met" ? false : undefined,
+        ...(verdict.evaluatorFailed ? { verifierUnavailable: true } : {}),
+        // A rejected claim is no progress unless the turn also changed files
+        // (work done, claimed early — common in batched goals); a met claim
+        // completed above; an inconclusive/failed verifier is neutral.
+        madeProgress: verdict.verdict === "not_met" ? activity.changedFiles.length > 0 : undefined,
         ...(tokensNow !== undefined ? { tokensNow } : {}),
+        ...(tokensNow !== undefined ? { tokensEstimated: this.tokensEstimated } : {}),
       });
+      this.tokensEstimated = false;
+      if (settled?.status === "paused") {
+        if (settled.reason === "paused(verifier_unavailable)") {
+          this.inform(`Goal verifier unavailable twice (${verdict.reason}) — goal paused. /unipi:goal resume to retry.`);
+        } else if (settled.reason === "paused(verifier_inconclusive)") {
+          this.inform(
+            `Goal verifier returned inconclusive twice — goal paused. Last evaluation: ${verdict.reason}. /unipi:goal resume.`,
+          );
+        } else if (settled.reason === "paused(no_progress_after_completion_claim)") {
+          const missing = verdict.missing.length > 0 ? ` Missing: ${verdict.missing.join("; ")}.` : "";
+          this.inform(`Completion claim rejected ${settled.notMetStreak} times — goal paused.${missing} /unipi:goal resume.`);
+        }
+      }
     } else if (proposal?.kind === "blocked") {
       settled = machine.settleTurn({
         goalId: goal.goalId,
@@ -184,7 +242,9 @@ export class GoalContinuation {
         madeProgress: activity.toolCalls > 0 ? true : undefined,
         ...(activity.waiting ? { waiting: true } : {}),
         ...(tokensNow !== undefined ? { tokensNow } : {}),
+        ...(tokensNow !== undefined ? { tokensEstimated: this.tokensEstimated } : {}),
       });
+      this.tokensEstimated = false;
     }
 
     if (!settled) {
@@ -192,12 +252,19 @@ export class GoalContinuation {
       return { action: "none", reason: "no-active-goal" };
     }
 
-    // Terminal / paused → stop the owner; budget_limited adds a wrap-up turn.
+    // Terminal → stop the owner; PAUSED → park it (resumable via
+    // /unipi:goal resume); budget_limited adds a wrap-up turn.
     if (settled.status !== "active" && settled.status !== "waiting") {
       const terminal = settled.reason ?? settled.status;
       const wrapUp = settled.status === "budget_limited" && !machine.isWrapUpDelivered(settled);
       if (wrapUp) machine.markWrapUpDelivered(settled.goalId, settled.revision);
-      this.deps.owner.finish(terminal);
+      if (settled.status === "paused") {
+        // Park (resume keeps the same goal); fall back to finish if the
+        // single park slot is held — the loop must still stop.
+        if (!this.deps.owner.suspend(terminal)) this.deps.owner.finish(terminal);
+      } else {
+        this.deps.owner.finish(terminal);
+      }
       if (wrapUp) this.deps.send(WRAP_UP_PROMPT);
       return { action: "stopped", terminal, wrapUp };
     }
@@ -210,7 +277,9 @@ export class GoalContinuation {
         const woken = this.deps.machine.wakeWaiting();
         if (woken) {
           this.consecutiveWaits = 0;
-          this.deps.send(renderContinuationHint(woken));
+          // Timer wake while idle: an event, delivered directly — never
+          // through the stash (nothing will settle to drain it).
+          (this.deps.sendNow ?? this.deps.send)(renderContinuationHint(woken));
         }
       }, delayMs);
       return { action: "wait", delayMs };

package/packages/long-horizon/src/engine/goal-state.ts

@@ -16,7 +16,8 @@
  *     can neither fake progress nor trip the stall detector)
  *   - worker completion proposals never complete directly: only verifier met
  *     or user request does (propose + verify). A rejected claim counts as
- *     no-progress for that turn and feeds notMetStreak.
+ *     no-progress for that turn (unless the turn changed files) and feeds
+ *     notMetStreak.
  *   - blocked requires 3 consecutive blocked proposals (mcode threshold);
  *     safety/policy refusals are immediate
  *   - every settlement carries {goalId, revision} — CAS; stale settlements
@@ -55,6 +56,7 @@ export const GOAL_STATUS_REASONS = [
   "paused(user_requested)",
   "paused(superseded)",
   "paused(verifier_unavailable)",
+  "paused(verifier_inconclusive)",
   "paused(no_progress)",
   "paused(no_progress_after_completion_claim)",
   "blocked(threshold_3turns)",
@@ -76,7 +78,9 @@ export const STALL_CAP_CEILING = 50;
 export const TOKEN_BUDGET_MINIMUM = 1_000;
 export const BLOCKED_PROPOSAL_THRESHOLD = 3;
 /** mcode: a verifier that keeps saying not_met this many times after claims parks the goal. */
-export const NOT_MET_STREAK_CAP = 3;
+export const NOT_MET_STREAK_CAP = 5;
+/** Consecutive inconclusive verdicts before the goal pauses for a human call. */
+export const INCONCLUSIVE_STREAK_CAP = 2;
 
 export const GOAL_CONDITION_LIMIT = { codeUnits: 500, utf8Bytes: 1_500 } as const;
 
@@ -96,6 +100,8 @@ export interface GoalState {
   readonly tokenBudget: number | null;
   /** Written at the first settlement that observes tokensNow. */
   readonly tokensBaselinePending: boolean;
+  /** True when the current tokens figure was estimated (no provider usage). */
+  readonly tokensEstimated?: boolean;
   readonly tokensAtStart: number;
   readonly tokensNow: number;
   readonly turn: number;
@@ -104,6 +110,8 @@ export interface GoalState {
   readonly stallCap: number;
   /** Consecutive verifier not_met verdicts on completion claims. */
   readonly notMetStreak: number;
+  /** Consecutive inconclusive verdicts (weak evidence — neither met nor not_met). */
+  readonly inconclusiveStreak: number;
   /** Consecutive blocked proposals (blocked needs 3 in a row). */
   readonly blockedProposalStreak: number;
   readonly lease: GoalLease;
@@ -133,6 +141,10 @@ export interface GoalSettlement {
   readonly blockedProposal?: boolean;
   /** Safety/policy refusal — immediately terminal. */
   readonly safetyRefusal?: boolean;
+  /** The evaluator itself failed twice (error/timeout/unparseable) — pause, don't guess. */
+  readonly verifierUnavailable?: boolean;
+  /** tokensNow was estimated from message sizes, not read from provider usage. */
+  readonly tokensEstimated?: boolean;
 }
 
 export interface GoalCreateOptions {
@@ -233,11 +245,13 @@ export class GoalMachine {
       tokensBaselinePending: true,
       tokensAtStart: 0,
       tokensNow: 0,
+      tokensEstimated: false,
       turn: 0,
       maxTurns: Math.min(options.maxTurns ?? DEFAULT_MAX_TURNS, MAX_TURNS_CEILING),
       noProgressStreak: 0,
       stallCap: Math.min(options.stallCap ?? DEFAULT_STALL_CAP, STALL_CAP_CEILING),
       notMetStreak: 0,
+      inconclusiveStreak: 0,
       blockedProposalStreak: 0,
       lease: Object.freeze({ goalId, generation: 0 }),
       revision: 0,
@@ -338,33 +352,68 @@ export class GoalMachine {
     let turn = goal.turn;
     let noProgressStreak = goal.noProgressStreak;
     let notMetStreak = goal.notMetStreak;
+    let inconclusiveStreak = goal.inconclusiveStreak ?? 0;
     let blockedProposalStreak = goal.blockedProposalStreak;
 
     // 1. Verification of a completion claim decides completion.
     if (input.completionClaim && input.verifier) {
-      if (input.verifier.verdict === "met") {
-        const next = this.withGoal(goal, { status: "complete", reason: "complete(verifier_met)" });
+      // 1a. The evaluator itself failed twice in this settlement: pause — an
+      // unproven verdict must never advance (or stall) the goal.
+      if (input.verifierUnavailable) {
+        const next = this.withGoal(goal, {
+          status: "paused",
+          reason: "paused(verifier_unavailable)",
+          inconclusiveStreak: 0,
+          ...(input.tokensEstimated !== undefined ? { tokensEstimated: input.tokensEstimated } : {}),
+        });
         this.goal = next;
         this.commit(next, goal.status);
         return next;
       }
-      if (input.verifier.verdict === "impossible") {
-        const next = this.withGoal(goal, { status: "blocked", reason: "blocked(verifier_impossible)" });
+      if (input.verifier.verdict === "met") {
+        const next = this.withGoal(goal, { status: "complete", reason: "complete(verifier_met)", inconclusiveStreak: 0 });
         this.goal = next;
         this.commit(next, goal.status);
         return next;
       }
-      // not_met / inconclusive: the claim failed. Count it.
-      notMetStreak = input.verifier.verdict === "not_met" ? notMetStreak + 1 : notMetStreak;
-      if (notMetStreak >= NOT_MET_STREAK_CAP && noProgressStreak + 1 >= goal.stallCap) {
-        const next = this.withGoal(goal, {
-          status: "paused",
-          reason: "paused(no_progress_after_completion_claim)",
-        });
+      if (input.verifier.verdict === "impossible") {
+        const next = this.withGoal(goal, { status: "blocked", reason: "blocked(verifier_impossible)", inconclusiveStreak: 0 });
         this.goal = next;
         this.commit(next, goal.status);
         return next;
       }
+      // not_met: the claim failed. Count it; the cap parks unconditionally.
+      if (input.verifier.verdict === "not_met") {
+        notMetStreak = notMetStreak + 1;
+        inconclusiveStreak = 0;
+        if (notMetStreak >= NOT_MET_STREAK_CAP) {
+          const next = this.withGoal(goal, {
+            status: "paused",
+            reason: "paused(no_progress_after_completion_claim)",
+            notMetStreak,
+            inconclusiveStreak,
+          });
+          this.goal = next;
+          this.commit(next, goal.status);
+          return next;
+        }
+      }
+      // inconclusive: evidence too weak either way; twice in a row = human call.
+      if (input.verifier.verdict === "inconclusive") {
+        inconclusiveStreak = inconclusiveStreak + 1;
+        if (inconclusiveStreak >= INCONCLUSIVE_STREAK_CAP) {
+          const next = this.withGoal(goal, {
+            status: "paused",
+            reason: "paused(verifier_inconclusive)",
+            inconclusiveStreak,
+          });
+          this.goal = next;
+          this.commit(next, goal.status);
+          return next;
+        }
+      }
+    } else {
+      inconclusiveStreak = 0;
     }
 
     // 2. Safety refusal is immediately terminal.
@@ -457,9 +506,11 @@ export class GoalMachine {
       tokensAtStart,
       tokensNow,
       tokensBaselinePending,
+      ...(input.tokensEstimated !== undefined ? { tokensEstimated: input.tokensEstimated } : {}),
       turn,
       noProgressStreak,
       notMetStreak,
+      inconclusiveStreak,
       blockedProposalStreak,
     });
     this.goal = next;

package/packages/long-horizon/src/engine/nudge-stash.ts

@@ -0,0 +1,71 @@
+/**
+ * One-slot nudge stash — the long-horizon handoff between `agent_end`
+ * settlement and the arbiter's `agent_before_settle` boundary.
+ *
+ * Continuation/ralph "sends" land here instead of pi's message queue; the
+ * package's nudge provider (priority 100) returns the stash at the boundary
+ * and takes it on delivery. A put overwrites an undelivered nudge (the newest
+ * intent wins) EXCEPT when the undelivered stash is a kickoff: the kickoff
+ * contract must never be lost, so a new put appends with a blank line and the
+ * merged stash stays kickoff-flagged until delivered.
+ */
+
+export interface NudgeStashPutOptions {
+	/** Marks the kickoff contract (append-only while undelivered). */
+	kickoff?: boolean;
+}
+
+export class NudgeStash {
+	private text: string | null = null;
+	private kickoff = false;
+
+	put(text: string, options: NudgeStashPutOptions = {}): void {
+		if (this.text !== null && this.kickoff) {
+			this.text = `${this.text}\n\n${text}`;
+			return;
+		}
+		this.text = text;
+		this.kickoff = options.kickoff ?? false;
+	}
+
+	/** Undelivered text, or null. */
+	peek(): string | null {
+		return this.text;
+	}
+
+	/** Take the text out (delivered). */
+	take(): string | null {
+		const text = this.text;
+		this.text = null;
+		this.kickoff = false;
+		return text;
+	}
+}
+
+/**
+ * Owner lifecycle events that invalidate an undelivered nudge: when the owner
+ * stops or parks, a queued hint targets a machine that no longer drives. The
+ * wrap-up survives because continuation puts it AFTER owner.finish commits.
+ */
+export interface StashMetaState<M> {
+	meta: M | undefined;
+	kickoff: boolean;
+}
+
+/** Pure metadata mirror of the stash merge semantics: a put into an undelivered
+ * KICKOFF appends and KEEPS the original provenance; any other put replaces it.
+ * `hasText` mirrors stash.peek() !== null. */
+export function nextStashMetaState<M>(
+	prev: StashMetaState<M> | undefined,
+	hasText: boolean,
+	kind: "kickoff" | undefined,
+	incoming: M,
+): StashMetaState<M> {
+	const merging = hasText && (prev?.kickoff ?? false);
+	if (merging) return { meta: prev?.meta, kickoff: true };
+	return { meta: incoming, kickoff: kind === "kickoff" };
+}
+
+export function ownerEventClearsStash(event: { type: string }): boolean {
+	return event.type === "finished" || event.type === "suspended";
+}

package/packages/long-horizon/src/engine/ralph.ts

@@ -93,7 +93,8 @@ export interface RalphLoopDeps {
   readonly owner: OwnerCoordinator;
   /** Resolve the ralph dir (usually ctx.cwd-based). */
   ralphDir(): string;
-  send(message: string): void;
+  /** Lands in the arbiter's nudge stash; the first prompt is the kickoff contract. */
+  send(message: string, kind?: "kickoff"): void;
   now?(): number;
   /** Footer/info-screen events (loop_start / iteration_done / loop_end). */
   onEvent?(event: RalphEvent): void;
@@ -214,7 +215,7 @@ export class RalphLoop {
     const itemsTotal = parseChecklist(taskContent).length;
     this.deps.onEvent?.({ type: "loop_start", name: state.name, iteration: 1, total: itemsTotal });
     const firstPrompt = this.buildIterationPrompt(state, false);
-    this.deps.send(firstPrompt);
+    this.deps.send(firstPrompt, "kickoff");
     return { ok: true, state, firstPrompt };
   }