@ashx-j/lunr-dev 0.2.13-dev.1.1

package/dist/builtin-extensions/narumiruna-pi-goal/src/runtime.js

@@ -0,0 +1,835 @@
+// @ts-nocheck
+import { randomUUID } from "node:crypto";
+import { isContextOverflow, } from "@ashx-j/lunr-ai";
+import { assistantUsageTokens, checkpointGoalActiveTime, formatDuration, formatTokenCount, nonNegativeFiniteNumber, updateGoalUsage, } from "./accounting.js";
+import { clearLegacyPersistedGoal, serializeGoalState, } from "./persistence.js";
+import { buildContinuePrompt } from "./prompts.js";
+import { DEFAULT_GOAL_SETTINGS } from "./settings.js";
+import { enterGoalAuto, leaveGoalAuto } from "../../../core/permission-mode-control.js";
+export const STATUS_KEY = "goal";
+export const GOAL_STATE_ENTRY_TYPE = "goal-state";
+export const GOAL_COMPLETE_TOOL = "goal_complete";
+export const GOAL_BLOCKED_TOOL = "goal_blocked";
+export const GOAL_TOOL_NAMES = [GOAL_COMPLETE_TOOL, GOAL_BLOCKED_TOOL];
+const MAX_CANCELLED_CONTINUATION_PROMPTS = 20;
+const MAX_PENDING_GOAL_PROMPTS = 20;
+const GOAL_PROMPT_MARKER_PREFIX = "pi-goal-prompt:";
+const CONTINUATION_MARKER_PREFIX = "pi-goal-continuation:";
+const BUDGET_WRAP_UP_MESSAGE_TYPE = "goal-budget-wrap-up";
+const BUDGET_WRAP_UP_PROMPT = "The active /goal token budget is exhausted. Stop substantive work and do not call substantive tools. Summarize progress, verified results, remaining work, and blockers concisely. Treat completion as unproven. Do not call goal_complete unless authoritative, requirement-by-requirement evidence already proves every requirement is complete. Weak, indirect, or missing evidence is not enough. Budget exhaustion is not completion.";
+const CONTRADICTORY_COMPLETION_PATTERNS = [
+    /(?<!could\s)\bnot\s+(?:yet\s+)?(?:complete|completed|done|finished)\b/i,
+    /\bstill\s+(?:incomplete|failing|failing\s+tests?|fails?)\b/i,
+    /\btests?\s+(?:still\s+)?fail(?:ing)?\b/i,
+];
+const USAGE_LIMIT_GOAL_ERROR_PATTERNS = [
+    /usage[_\s-]*(?:limit|cap)|chatgpt.{0,32}usage/i,
+    /quota.{0,32}(?:reached|exceeded|exhausted|depleted)|(?:reached|exceeded|exhausted|depleted).{0,32}quota/i,
+    /insufficient[_\s-]*(?:quota|credits?)|out of credits|out of budget|available balance|payment required/i,
+    /(?:credit|balance).{0,32}(?:low|exhausted|depleted)|billing/i,
+];
+const NON_RETRYABLE_GOAL_ERROR_RE = /multi-auth rotation failed|credentials tried|unauthori[sz]ed|invalid api key/i;
+// Pi 0.79 does not export its assistant-error retry classifier. Keep this
+// compatibility mirror aligned with Pi's public retry utility in newer versions.
+const RETRYABLE_GOAL_ERROR_PATTERNS = [
+    /overloaded|rate.?limit|too many requests|\b(?:429|500|502|503|504)\b|service.?unavailable|server.?error|internal.?error/i,
+    /provider.?returned.?error|you can retry your request|try your request again|please retry your request/i,
+    /network.?error|connection.?(?:error|refused|lost)|other side closed|fetch failed|upstream.?connect|reset before headers|socket hang up/i,
+    /timed? out|timeout|terminated|websocket.?(?:closed|error)|ended without|stream ended before message_stop|http2 request did not get a response|retry delay/i,
+    /context[_\s-]*length[_\s-]*exceeded|input exceeds the context window/i,
+];
+// One instance belongs to one extension factory. It owns all mutable session state
+// and the cross-cutting invariants used by command and lifecycle orchestration.
+export class GoalRuntime {
+    settings = DEFAULT_GOAL_SETTINGS;
+    activeGoal;
+    queuedGoals = [];
+    pendingQueueAction;
+    queueFrozen = false;
+    completionStatusTimer;
+    // lunr: 30s footer refresh timer so the goal indicator's elapsed minutes tick while active
+    statusRefreshTimer;
+    statusRefreshCtx;
+    continuationIntent;
+    continuationDelivery;
+    goalRecovery;
+    budgetWrapUp;
+    /** `null` marks a run that must not be charged to the active goal. */
+    agentRunGoalId;
+    staleGoalToolCallsBlocked = false;
+    /** Once true, goal tools stay in the active set for this runtime (prompt-cache stable). */
+    goalToolsUnlocked = false;
+    /** Exact lazy goal tools this runtime removed and may restore on a mode change. */
+    goalToolsHiddenByPolicy = new Set();
+    pendingGoalPromptMarkers = new Map();
+    cancelledContinuationMarkers = new Set();
+    pi;
+    constructor(pi) {
+        this.pi = pi;
+    }
+    canRecordGoalUsage() {
+        return (this.agentRunGoalId !== null &&
+            !(this.pendingQueueAction?.kind === "prioritize" &&
+                this.pendingQueueAction.displacedUsageFinalized === true));
+    }
+    hasActiveBudgetWrapUp() {
+        return (this.activeGoal?.status === "budget_limited" &&
+            this.budgetWrapUp?.goalId === this.activeGoal.id &&
+            this.budgetWrapUp.delivered);
+    }
+    hasActiveGoalRecovery() {
+        return Boolean(this.activeGoal && this.goalRecovery?.goalId === this.activeGoal.id);
+    }
+    recordGoalUsage(goal, ctx, checkpointActiveTime = goal.status === "active") {
+        if (!this.canRecordGoalUsage())
+            return false;
+        updateGoalUsage(goal, ctx, checkpointActiveTime);
+        return true;
+    }
+    requestContinuation(goal) {
+        if (this.hasContinuationWorkForGoal(goal.id))
+            return false;
+        const marker = continuationMarker(goal);
+        this.continuationIntent = {
+            goalId: goal.id,
+            iteration: goal.iteration,
+            marker,
+            prompt: buildContinuePrompt(goal, marker),
+        };
+        return true;
+    }
+    dispatchContinuationIfSettled(ctx) {
+        const intent = this.continuationIntent;
+        if (!intent)
+            return false;
+        if (this.activeGoal?.status === "active" && !this.goalToolsAvailable()) {
+            this.pauseGoalForUnavailableTools(ctx);
+            return false;
+        }
+        if (!this.activeGoal ||
+            this.activeGoal.id !== intent.goalId ||
+            this.activeGoal.status !== "active") {
+            this.continuationIntent = undefined;
+            return false;
+        }
+        if (ctx.isIdle?.() !== true || hasPendingMessages(ctx))
+            return false;
+        this.continuationIntent = undefined;
+        this.continuationDelivery = intent;
+        try {
+            this.pi.sendUserMessage(intent.prompt, { deliverAs: "followUp" });
+            return true;
+        }
+        catch (error) {
+            if (this.continuationDelivery?.marker === intent.marker) {
+                this.continuationDelivery = undefined;
+            }
+            if (this.activeGoal?.id === intent.goalId && this.activeGoal.status === "active") {
+                this.continuationIntent = intent;
+            }
+            ctx.ui.notify(`Goal prompt failed: ${formatError(error)}`, "error");
+            return false;
+        }
+    }
+    hasContinuationWorkForGoal(goalId) {
+        return (this.continuationIntent?.goalId === goalId || this.continuationDelivery?.goalId === goalId);
+    }
+    syncGoalPermissionMode(goal) {
+        if (goal?.status === "active")
+            enterGoalAuto();
+        else
+            leaveGoalAuto();
+    }
+    updateStatus(ctx, goal) {
+        this.clearCompletionStatusTimer();
+        this.syncGoalPermissionMode(goal);
+        ctx.ui.setStatus(STATUS_KEY, formatStatus(goal));
+        // lunr: refresh the footer every 30s while a goal is active so the elapsed time ticks
+        this.clearStatusRefreshTimer();
+        if (goal.status === "active") {
+            this.statusRefreshCtx = ctx;
+            this.statusRefreshTimer = setInterval(() => {
+                const currentGoal = this.activeGoal;
+                const refreshCtx = this.statusRefreshCtx;
+                if (!currentGoal || currentGoal.status !== "active" || !refreshCtx) {
+                    this.clearStatusRefreshTimer();
+                    return;
+                }
+                try {
+                    refreshCtx.ui.setStatus(STATUS_KEY, formatStatus(currentGoal));
+                }
+                catch {
+                    // The captured ctx may be stale after session replacement or reload.
+                    this.clearStatusRefreshTimer();
+                }
+            }, 30_000);
+            this.statusRefreshTimer.unref?.();
+        }
+    }
+    // lunr: paired with the status refresh interval started in updateStatus()
+    clearStatusRefreshTimer() {
+        if (!this.statusRefreshTimer)
+            return;
+        clearInterval(this.statusRefreshTimer);
+        this.statusRefreshTimer = undefined;
+        this.statusRefreshCtx = undefined;
+    }
+    blockStaleGoalToolCalls() {
+        this.staleGoalToolCallsBlocked = true;
+    }
+    clearStaleGoalToolCallBlock() {
+        this.staleGoalToolCallsBlocked = false;
+    }
+    clearGoalRecovery() {
+        this.goalRecovery = undefined;
+    }
+    clearBudgetWrapUp() {
+        this.budgetWrapUp = undefined;
+    }
+    keepBudgetWrapUpMessage(message) {
+        if (!message || typeof message !== "object")
+            return true;
+        const candidate = message;
+        if (candidate.role !== "custom" || candidate.customType !== BUDGET_WRAP_UP_MESSAGE_TYPE) {
+            return true;
+        }
+        return (typeof candidate.details?.goalId === "string" &&
+            candidate.details.goalId === this.budgetWrapUp?.goalId &&
+            candidate.details.goalId === this.activeGoal?.id);
+    }
+    queueBudgetWrapUp(ctx, goal) {
+        if (!this.budgetWrapUp || this.budgetWrapUp.goalId !== goal.id) {
+            this.budgetWrapUp = { goalId: goal.id, delivered: false };
+        }
+        if (this.budgetWrapUp.delivered)
+            return true;
+        this.budgetWrapUp.delivered = true;
+        try {
+            this.pi.sendMessage({
+                customType: BUDGET_WRAP_UP_MESSAGE_TYPE,
+                content: BUDGET_WRAP_UP_PROMPT,
+                display: true,
+                details: { goalId: goal.id },
+            }, { deliverAs: "steer" });
+            return true;
+        }
+        catch (error) {
+            this.budgetWrapUp.delivered = false;
+            ctx.ui.notify(`Goal budget wrap-up failed: ${formatError(error)}`, "error");
+            return false;
+        }
+    }
+    limitActiveGoalForBudget(ctx, sendWrapUp) {
+        const goal = this.activeGoal;
+        if (goal?.status !== "active" ||
+            goal.tokenBudget === undefined ||
+            goal.tokensUsed < goal.tokenBudget) {
+            return false;
+        }
+        this.cancelContinuationWork();
+        this.clearGoalRecoveryForGoal(goal.id);
+        this.clearBudgetWrapUp();
+        this.activeGoal = transitionGoal(goal, "budget_limited");
+        this.persistGoal(this.activeGoal);
+        this.updateStatus(ctx, this.activeGoal);
+        ctx.ui.notify(`Goal token budget reached: ${formatBudget(this.activeGoal)}`, "warning");
+        if (sendWrapUp)
+            this.queueBudgetWrapUp(ctx, this.activeGoal);
+        return true;
+    }
+    clearGoalRecoveryForGoal(goalId) {
+        if (this.goalRecovery?.goalId === goalId)
+            this.goalRecovery = undefined;
+    }
+    isPiOwnedCompactionRetry(event, goalId) {
+        const compaction = event;
+        if (compaction.willRetry === true)
+            return true;
+        return (this.goalRecovery?.goalId === goalId &&
+            this.goalRecovery.kind === "compaction_retry" &&
+            (compaction.reason === undefined || compaction.reason === "overflow"));
+    }
+    clearContinuationTracking() {
+        this.continuationIntent = undefined;
+        this.continuationDelivery = undefined;
+        this.cancelledContinuationMarkers.clear();
+    }
+    clearPendingGoalPrompts() {
+        this.pendingGoalPromptMarkers.clear();
+    }
+    async sendOwnedGoalPrompt(ctx, goalId, prompt) {
+        const pending = this.rememberPendingGoalPrompt(goalId, prompt);
+        const sent = await sendPrompt(this.pi, ctx, pending.prompt);
+        if (!sent)
+            this.pendingGoalPromptMarkers.delete(pending.marker);
+        return sent;
+    }
+    cancelContinuationWork() {
+        if (this.continuationDelivery) {
+            this.rememberCancelledContinuationMarker(this.continuationDelivery.marker);
+        }
+        this.continuationIntent = undefined;
+        this.continuationDelivery = undefined;
+    }
+    consumeCancelledContinuationPrompt(prompt) {
+        const marker = extractContinuationMarker(prompt);
+        return marker ? this.cancelledContinuationMarkers.delete(marker) : false;
+    }
+    consumeStaleOwnedGoalPrompt(prompt) {
+        const marker = extractGoalPromptMarker(prompt);
+        if (!marker)
+            return false;
+        const goalId = this.pendingGoalPromptMarkers.get(marker);
+        if (!goalId)
+            return false;
+        if (!this.queueFrozen &&
+            !this.pendingQueueAction &&
+            this.activeGoal?.id === goalId &&
+            this.activeGoal.status === "active") {
+            return false;
+        }
+        this.pendingGoalPromptMarkers.delete(marker);
+        return true;
+    }
+    markContinuationStarted(prompt) {
+        const marker = extractContinuationMarker(prompt);
+        if (!marker) {
+            // A user, retry, or another extension started newer work. Cancel both an
+            // unsent intent and a delivery that may have lost the non-atomic idle race;
+            // the newer work's agent_end will record a fresh intent.
+            this.cancelContinuationWork();
+            return undefined;
+        }
+        if (this.continuationDelivery?.marker === marker)
+            this.continuationDelivery = undefined;
+        return marker.split(":", 1)[0];
+    }
+    persistGoal(goal) {
+        this.pi.appendEntry(GOAL_STATE_ENTRY_TYPE, serializeGoalState(goal, this.queuedGoals, this.pendingQueueAction));
+    }
+    clearPersistedGoal(cwd) {
+        this.pi.appendEntry(GOAL_STATE_ENTRY_TYPE, serializeGoalState(undefined, [], undefined));
+        clearLegacyPersistedGoal(cwd);
+    }
+    clearActiveGoal(ctx) {
+        this.clearStatusRefreshTimer(); // lunr: stop the footer refresh when the goal is cleared
+        this.syncGoalPermissionMode(undefined);
+        this.cancelContinuationWork();
+        this.clearGoalRecovery();
+        this.clearBudgetWrapUp();
+        this.clearStaleGoalToolCallBlock();
+        this.activeGoal = undefined;
+        this.queuedGoals = [];
+        this.pendingQueueAction = undefined;
+        this.queueFrozen = false;
+        this.clearPersistedGoal(ctx.cwd);
+        ctx.ui.setStatus(STATUS_KEY, undefined);
+        // Do not clear goalToolsUnlocked: after first activation, keep tools visible
+        // for the rest of this extension runtime to avoid repeated goal-tool schema
+        // churn within the same runtime.
+    }
+    isGoalToolName(name) {
+        return GOAL_TOOL_NAMES.includes(name);
+    }
+    goalToolsAvailable() {
+        const active = new Set(this.pi.getActiveTools());
+        return GOAL_TOOL_NAMES.every((name) => active.has(name));
+    }
+    hideGoalToolsIfLocked() {
+        if (this.goalToolsUnlocked)
+            return;
+        const active = this.pi.getActiveTools();
+        const hidden = active.filter((name) => this.isGoalToolName(name));
+        if (hidden.length === 0)
+            return;
+        // lunr: do not mutate the active tool list (Anthropic tools sit at the
+        // front of the cache prefix). Locked goal tools stay registered; the
+        // tool_call gate rejects them until a /goal is activated.
+        for (const name of hidden)
+            this.goalToolsHiddenByPolicy.add(name);
+    }
+    restoreGoalToolsHiddenByPolicy() {
+        // lunr: flags only — the tool list is never rewritten at runtime.
+        this.goalToolsHiddenByPolicy.clear();
+    }
+    assertGoalToolsAvailable() {
+        if (this.goalToolsAvailable())
+            return;
+        throw new Error("goal_complete and goal_blocked are unavailable; include them in the active tool allowlist or leave the restrictive tool mode first.");
+    }
+    ensureGoalToolsVisible() {
+        // lunr: never add/remove tools mid-session. Assert they were already
+        // registered at session start so the wire bytes stay stable.
+        this.assertGoalToolsAvailable();
+    }
+    prepareGoalToolsForActivation(ctx) {
+        if (this.settings.toolVisibility === "after-first-goal") {
+            if (!this.goalToolsAvailable() && ctx.isIdle?.() !== true) {
+                throw new Error("wait until Pi is idle before revealing the goal tools");
+            }
+            this.revealGoalTools();
+            return;
+        }
+        this.assertGoalToolsAvailable();
+    }
+    /** Mark lazy tools permanently desired for this runtime and make them active now. */
+    revealGoalTools() {
+        const wasUnlocked = this.goalToolsUnlocked;
+        try {
+            this.ensureGoalToolsVisible();
+            this.goalToolsUnlocked = true;
+            this.goalToolsHiddenByPolicy.clear();
+        }
+        catch (error) {
+            this.goalToolsUnlocked = wasUnlocked;
+            throw error;
+        }
+    }
+    snapshotGoalToolVisibility() {
+        return {
+            activeTools: this.pi.getActiveTools(),
+            goalToolsUnlocked: this.goalToolsUnlocked,
+            goalToolsHiddenByPolicy: [...this.goalToolsHiddenByPolicy],
+        };
+    }
+    /**
+     * lunr: reactivate a stopped (usage_limited / paused / blocked / budget_limited)
+     * goal back to active WITHOUT sending a prompt. Shared by the /goal resume
+     * command and the auto-resume hook (cron wake-up). Returns the reactivated goal
+     * or undefined if reactivation was rejected (tools unavailable, budget reached).
+     * Consumes resumeAfter so a single schedule only fires once.
+     */
+    reactivateGoalForResume(ctx) {
+        if (!this.activeGoal)
+            return undefined;
+        if (!isResumableGoalStatus(this.activeGoal.status))
+            return undefined;
+        if (this.activeGoal.tokenBudget !== undefined &&
+            this.activeGoal.tokensUsed >= this.activeGoal.tokenBudget) {
+            return undefined;
+        }
+        try {
+            this.prepareGoalToolsForActivation(ctx);
+        }
+        catch (error) {
+            ctx.ui.notify(`Cannot resume /goal: ${formatError(error)}`, "error");
+            return undefined;
+        }
+        this.cancelContinuationWork();
+        this.clearGoalRecovery();
+        this.clearBudgetWrapUp();
+        this.clearStaleGoalToolCallBlock();
+        const next = transitionGoal(nextGoalInstance(this.activeGoal), "active");
+        this.activeGoal = { ...next, resumeAfter: undefined };
+        this.persistGoal(this.activeGoal);
+        this.updateStatus(ctx, this.activeGoal);
+        if (this.activeGoal.status !== "active")
+            return undefined;
+        return this.activeGoal;
+    }
+    restoreGoalToolVisibility(snapshot) {
+        // lunr: restore unlock/hidden flags only — never rewrite the tool list.
+        this.goalToolsUnlocked = snapshot.goalToolsUnlocked;
+        this.goalToolsHiddenByPolicy.clear();
+        for (const name of snapshot.goalToolsHiddenByPolicy) {
+            this.goalToolsHiddenByPolicy.add(name);
+        }
+    }
+    areGoalToolsLocked() {
+        return !this.goalToolsUnlocked && this.settings.toolVisibility === "after-first-goal";
+    }
+    pauseGoalForUnavailableTools(ctx, abortTurn = true, recordUsage = true) {
+        const goal = this.activeGoal;
+        if (goal?.status !== "active")
+            return false;
+        if (recordUsage)
+            this.recordGoalUsage(goal, ctx);
+        this.cancelContinuationWork();
+        this.clearGoalRecoveryForGoal(goal.id);
+        this.clearBudgetWrapUp();
+        if (abortTurn) {
+            this.blockStaleGoalToolCalls();
+            abortCurrentTurn(ctx);
+        }
+        else {
+            this.clearStaleGoalToolCallBlock();
+        }
+        this.activeGoal = transitionGoal(goal, "paused");
+        this.persistGoal(this.activeGoal);
+        this.updateStatus(ctx, this.activeGoal);
+        ctx.ui.notify("Goal tools are unavailable, so the active goal was paused. Restore the tools and run /goal resume.", "warning");
+        return true;
+    }
+    showCompletionStatus(ctx) {
+        this.clearCompletionStatusTimer();
+        this.clearStatusRefreshTimer(); // lunr: stop the footer refresh on completion
+        this.syncGoalPermissionMode(undefined);
+        // lunr: enriched footer status format
+        ctx.ui.setStatus(STATUS_KEY, "goal ✓ complete");
+        this.completionStatusTimer = setTimeout(() => {
+            this.completionStatusTimer = undefined;
+            try {
+                ctx.ui.setStatus(STATUS_KEY, undefined);
+            }
+            catch {
+                // The completion status is best-effort; the captured ctx may be stale after
+                // session replacement or reload before this timer fires.
+            }
+        }, 8_000);
+    }
+    clearCompletionStatusTimer() {
+        if (!this.completionStatusTimer)
+            return;
+        clearTimeout(this.completionStatusTimer);
+        this.completionStatusTimer = undefined;
+    }
+    rememberPendingGoalPrompt(goalId, prompt) {
+        const marker = randomUUID();
+        this.pendingGoalPromptMarkers.set(marker, goalId);
+        if (this.pendingGoalPromptMarkers.size > MAX_PENDING_GOAL_PROMPTS) {
+            const oldest = this.pendingGoalPromptMarkers.keys().next().value;
+            if (oldest)
+                this.pendingGoalPromptMarkers.delete(oldest);
+        }
+        return { marker, prompt: `${prompt}\n\n<!-- ${GOAL_PROMPT_MARKER_PREFIX}${marker} -->` };
+    }
+    consumePendingGoalPrompt(prompt) {
+        const marker = extractGoalPromptMarker(prompt);
+        if (!marker)
+            return undefined;
+        const goalId = this.pendingGoalPromptMarkers.get(marker);
+        this.pendingGoalPromptMarkers.delete(marker);
+        return goalId;
+    }
+    consumeOwnedGoalPrompt(prompt) {
+        return this.consumePendingGoalPrompt(prompt);
+    }
+    rememberCancelledContinuationMarker(marker) {
+        this.cancelledContinuationMarkers.add(marker);
+        if (this.cancelledContinuationMarkers.size <= MAX_CANCELLED_CONTINUATION_PROMPTS)
+            return;
+        const oldest = this.cancelledContinuationMarkers.values().next().value;
+        if (oldest)
+            this.cancelledContinuationMarkers.delete(oldest);
+    }
+}
+export function createGoal(text, tokenBudget, baselineTokens) {
+    const now = Date.now();
+    return {
+        id: randomUUID(),
+        text,
+        status: "active",
+        startedAt: now,
+        updatedAt: now,
+        iteration: 0,
+        tokenBudget,
+        tokensUsed: 0,
+        timeUsedSeconds: 0,
+        baselineTokens,
+        activeStartedAt: now,
+    };
+}
+export function transitionGoal(goal, requestedStatus) {
+    const now = Date.now();
+    const status = requestedStatus === "active" &&
+        goal.tokenBudget !== undefined &&
+        goal.tokensUsed >= goal.tokenBudget
+        ? "budget_limited"
+        : requestedStatus;
+    const next = { ...goal, status, updatedAt: now };
+    checkpointGoalActiveTime(next, now, status === "active");
+    return next;
+}
+export function nextGoalInstance(goal) {
+    return { ...goal, id: randomUUID(), updatedAt: Date.now() };
+}
+export function editedGoalStatus(status) {
+    if (status === "paused" || status === "blocked" || status === "usage_limited")
+        return status;
+    return "active";
+}
+export function incrementGoal(goal) {
+    return { ...goal, iteration: goal.iteration + 1, updatedAt: Date.now() };
+}
+// lunr: footer status — active is just `goal` (elapsed/turns stay on paused)
+export function formatStatus(goal) {
+    if (!goal)
+        return undefined;
+    if (goal.status === "complete")
+        return "goal ✓ complete";
+    if (goal.status === "queued")
+        return "goal queued";
+    if (goal.status === "paused") {
+        return `goal ◌ paused · ${formatGoalElapsed(goal)} · ${formatGoalTurns(goal)}`;
+    }
+    if (goal.status === "blocked")
+        return "goal ✗ blocked";
+    if (goal.status === "usage_limited")
+        return "goal usage-limited";
+    if (goal.status === "budget_limited")
+        return `goal budget ${formatBudget(goal)}`;
+    // lunr: active (and budget-suffixed active) display text is exactly `goal`
+    if (goal.tokenBudget !== undefined)
+        return `goal · ${formatBudget(goal)}`;
+    return "goal";
+}
+// lunr: live elapsed = accumulated active time + the in-progress active segment
+function goalElapsedSeconds(goal) {
+    let seconds = nonNegativeFiniteNumber(goal.timeUsedSeconds);
+    if (typeof goal.activeStartedAt === "number" && Number.isFinite(goal.activeStartedAt)) {
+        seconds += Math.max(0, Date.now() - goal.activeStartedAt) / 1000;
+    }
+    return seconds;
+}
+// lunr: footer elapsed format — `Xm` under 1h, `XhYm` after
+function formatGoalElapsed(goal) {
+    const totalMinutes = Math.floor(goalElapsedSeconds(goal) / 60);
+    if (totalMinutes < 60)
+        return `${totalMinutes}m`;
+    return `${Math.floor(totalMinutes / 60)}h${totalMinutes % 60}m`;
+}
+// lunr: footer turn count, singular at 1
+function formatGoalTurns(goal) {
+    return goal.iteration === 1 ? "1 turn" : `${goal.iteration} turns`;
+}
+export function formatBudget(goal) {
+    return `${formatTokenCount(goal.tokensUsed)}/${formatTokenCount(goal.tokenBudget ?? 0)}`;
+}
+export function goalSummary(goal, queuedGoals = [], experimentalGoals = false, queueFrozen = false) {
+    const summary = [
+        `Goal: ${goal.text}`,
+        `Status: ${queueFrozen ? "queue off" : goal.status}`,
+        `Iteration: ${goal.iteration}`,
+        `Active elapsed: ${formatDuration(goal.timeUsedSeconds)}`,
+        `Tokens: ${goal.tokenBudget === undefined ? formatTokenCount(goal.tokensUsed) : formatBudget(goal)}`,
+    ];
+    if (experimentalGoals || queuedGoals.length > 0 || queueFrozen) {
+        summary.push(`Goals (${queuedGoals.length + 1}):`, ...[goal, ...queuedGoals].map((queuedGoal, index) => `${index + 1}. [${queuedGoal.status}] ${queuedGoal.text}`));
+    }
+    if (queueFrozen) {
+        summary.push("Queue is frozen. Re-enable experimental.goals and run /reload, or use /goal clear.", "Commands: /goal, /goal clear");
+    }
+    else {
+        summary.push(`Commands: ${goalCommandHint(goal.status, experimentalGoals)}`);
+    }
+    return summary.join("\n");
+}
+export function hasPendingMessages(ctx) {
+    return ctx.hasPendingMessages?.() ?? false;
+}
+export function abortCurrentTurn(ctx) {
+    try {
+        ctx.abort?.();
+    }
+    catch {
+        // Best effort: stale goal guards still prevent follow-on tool calls.
+    }
+}
+export function blocksStaleGoalToolCalls(status) {
+    return status === "paused" || status === "blocked" || status === "usage_limited";
+}
+export function isResumableGoalStatus(status) {
+    return blocksStaleGoalToolCalls(status) || status === "budget_limited";
+}
+export function stoppedStatusLabel(status) {
+    if (status === "usage_limited")
+        return "usage-limited";
+    if (status === "budget_limited")
+        return "budget-limited";
+    return status;
+}
+export function isContradictoryCompletionSummary(summary) {
+    return CONTRADICTORY_COMPLETION_PATTERNS.some((pattern) => pattern.test(summary));
+}
+export function goalIdRejectionReason(goal, requestedGoalId) {
+    if (!requestedGoalId)
+        return "missing goal_id";
+    if (requestedGoalId !== goal.id)
+        return "goal_id does not match the active goal";
+    return undefined;
+}
+export function isUsageLimitedGoalInterruption(assistant) {
+    const errorMessage = assistant.errorMessage;
+    return (assistant.stopReason === "error" &&
+        typeof errorMessage === "string" &&
+        USAGE_LIMIT_GOAL_ERROR_PATTERNS.some((pattern) => pattern.test(errorMessage)));
+}
+export function isRetryableGoalInterruption(assistant) {
+    if (assistant.stopReason !== "error")
+        return false;
+    if (!assistant.errorMessage)
+        return false;
+    if (isUsageLimitedGoalInterruption(assistant) ||
+        NON_RETRYABLE_GOAL_ERROR_RE.test(assistant.errorMessage)) {
+        return false;
+    }
+    return (isGoalContextOverflow(assistant) ||
+        RETRYABLE_GOAL_ERROR_PATTERNS.some((pattern) => pattern.test(assistant.errorMessage ?? "")));
+}
+export function isGoalContextOverflow(assistant) {
+    return isContextOverflow(toPiAssistantMessage(assistant));
+}
+/**
+ * lunr: best-effort extraction of a usage-limit reset time from a provider error
+ * message. Returns an absolute epoch ms to resume after, or undefined. Handles
+ * relative delays ("reset in 2h", "try again in 30m", "available in 3600s") and
+ * ISO-8601 timestamps. Most provider errors omit this, so undefined is the norm.
+ */
+const USAGE_RESET_TIME_PATTERNS = [
+    /reset(?:s|ting)?\s*(?:in|after|at)?\s*(\d+)\s*s(ec)?/i,
+    /reset(?:s|ting)?\s*(?:in|after|at)?\s*(\d+)\s*m(in)?/i,
+    /reset(?:s|ting)?\s*(?:in|after|at)?\s*(\d+)\s*h(our|r)?/i,
+    /(?:retry|try(?:\s+again)?|available)\s+(?:in|after|at)\s*(\d+)\s*s(ec)?/i,
+    /(?:retry|try(?:\s+again)?|available)\s+(?:in|after|at)\s*(\d+)\s*m(in)?/i,
+    /(?:retry|try(?:\s+again)?|available)\s+(?:in|after|at)\s*(\d+)\s*h(our|r)?/i,
+];
+export function parseUsageResetTimeMs(errorMessage) {
+    if (!errorMessage)
+        return undefined;
+    const now = Date.now();
+    for (const pattern of USAGE_RESET_TIME_PATTERNS) {
+        const match = errorMessage.match(pattern);
+        if (!match)
+            continue;
+        const value = Number.parseInt(match[1] ?? "", 10);
+        if (!Number.isFinite(value) || value <= 0)
+            continue;
+        const unit = pattern.source.includes("\\s*h") ? 3600_000 : pattern.source.includes("\\s*m") ? 60_000 : 1_000;
+        return now + value * unit;
+    }
+    // ISO-8601 timestamp fallback (e.g. "reset at 2026-08-01T09:00:00Z").
+    const isoMatch = errorMessage.match(/(?:reset|available).{0,12}(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2})?(?:Z|[+-]\d{2}:?\d{2})?)/i);
+    if (isoMatch?.[1]) {
+        const parsed = Date.parse(isoMatch[1]);
+        if (Number.isFinite(parsed) && parsed > now)
+            return parsed;
+    }
+    return undefined;
+}
+export function findFinalAssistantMessage(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (!message || typeof message !== "object")
+            continue;
+        const candidate = message;
+        if (candidate.role !== "assistant")
+            continue;
+        const assistant = {
+            role: "assistant",
+            stopReason: isAgentStopReason(candidate.stopReason) ? candidate.stopReason : undefined,
+            errorMessage: typeof candidate.errorMessage === "string" ? candidate.errorMessage : undefined,
+        };
+        if (Array.isArray(candidate.content)) {
+            assistant.content = candidate.content;
+        }
+        if (typeof candidate.api === "string")
+            assistant.api = candidate.api;
+        if (typeof candidate.provider === "string")
+            assistant.provider = candidate.provider;
+        if (typeof candidate.model === "string")
+            assistant.model = candidate.model;
+        if (typeof candidate.timestamp === "number")
+            assistant.timestamp = candidate.timestamp;
+        const usage = normalizeUsage(candidate.usage);
+        if (usage)
+            assistant.usage = usage;
+        return assistant;
+    }
+    return undefined;
+}
+export function formatError(error) {
+    return truncateNotification(error instanceof Error ? error.message : String(error));
+}
+export function truncateNotification(value) {
+    return value.length > 160 ? `${value.slice(0, 157)}...` : value;
+}
+async function sendPrompt(pi, ctx, prompt) {
+    try {
+        await pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+        return true;
+    }
+    catch (error) {
+        ctx.ui.notify(`Goal prompt failed: ${formatError(error)}`, "error");
+        return false;
+    }
+}
+function goalCommandHint(status, experimentalGoals = false) {
+    const queueCommands = experimentalGoals
+        ? ", /goal add <objective>, /goal prioritize <objective>, /goal drop-last, /goal skip"
+        : "";
+    if (status === "active") {
+        return `/goal edit <objective>, /goal pause, /goal clear${queueCommands}`;
+    }
+    if (isResumableGoalStatus(status)) {
+        return `/goal edit <objective>, /goal resume, /goal clear${queueCommands}`;
+    }
+    return `/goal edit <objective>, /goal clear${queueCommands}`;
+}
+function toPiAssistantMessage(assistant) {
+    return {
+        role: "assistant",
+        content: assistant.content ?? [],
+        api: assistant.api ?? "openai-responses",
+        provider: assistant.provider ?? "unknown",
+        model: assistant.model ?? "unknown",
+        usage: assistant.usage ?? zeroUsage(),
+        stopReason: assistant.stopReason ?? "error",
+        errorMessage: assistant.errorMessage,
+        timestamp: assistant.timestamp ?? Date.now(),
+    };
+}
+function zeroUsage() {
+    return {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            total: 0,
+        },
+    };
+}
+function continuationMarker(goal) {
+    return `${goal.id}:${goal.iteration}:${randomUUID()}`;
+}
+function escapeRegExpText(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const GOAL_PROMPT_MARKER_PATTERN = new RegExp(`<!--\\s*${escapeRegExpText(GOAL_PROMPT_MARKER_PREFIX)}([^\\s>]+)\\s*-->`);
+const CONTINUATION_MARKER_PATTERN = new RegExp(`<!--\\s*${escapeRegExpText(CONTINUATION_MARKER_PREFIX)}([^\\s>]+)\\s*-->`);
+function extractGoalPromptMarker(prompt) {
+    return GOAL_PROMPT_MARKER_PATTERN.exec(prompt)?.[1];
+}
+function extractContinuationMarker(prompt) {
+    return CONTINUATION_MARKER_PATTERN.exec(prompt)?.[1];
+}
+function isAgentStopReason(value) {
+    return ["stop", "length", "toolUse", "error", "aborted"].includes(String(value));
+}
+function normalizeUsage(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const usage = value;
+    if (typeof usage.input !== "number" || typeof usage.output !== "number")
+        return undefined;
+    return {
+        input: nonNegativeFiniteNumber(usage.input),
+        output: nonNegativeFiniteNumber(usage.output),
+        cacheRead: nonNegativeFiniteNumber(usage.cacheRead),
+        cacheWrite: nonNegativeFiniteNumber(usage.cacheWrite),
+        totalTokens: assistantUsageTokens(usage),
+        cost: {
+            input: usage.cost?.input ?? 0,
+            output: usage.cost?.output ?? 0,
+            cacheRead: usage.cost?.cacheRead ?? 0,
+            cacheWrite: usage.cost?.cacheWrite ?? 0,
+            total: usage.cost?.total ?? 0,
+        },
+    };
+}
+//# sourceMappingURL=runtime.js.map