@mocito/pi-goal 0.1.6 → 0.1.7

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## Unreleased
+
+## 0.1.7 - 2026-06-08
+
+### Fixed
+
+- Stop compounding active elapsed time during token accounting; active time is now materialized only on status transitions and computed live for display.
+
+### Changed
+
+- Pause goals on assistant-surfaced provider usage/quota/billing limit errors and repeated provider failures, not only HTTP 429 response hooks.
+
 ## 0.1.6 - 2026-06-06
 
 ### Changed

package/README.md

@@ -44,6 +44,8 @@ When an active goal is idle, the extension injects a hidden `pi-goal-context` me
 
 The footer and optional editor widget show status, elapsed active time, token usage, and budget.
 
+Provider usage-limit handling pauses active goals when Pi exposes HTTP 429 responses or assistant error messages that indicate subscription, quota, billing, balance, or repeated provider failures. This prevents automatic continuation from retrying indefinitely after provider limits such as 5-hour subscription caps.
+
 ## Examples
 
 Simple goal:
@@ -81,14 +83,14 @@ Environment flags:
 ## Troubleshooting
 
 - If continuation does not start, run `/goal status` and confirm the goal is `active`.
-- If a goal stops unexpectedly, check whether it reached its token budget or the provider returned a rate/usage limit.
+- If a goal stops unexpectedly, check whether it reached its token budget or the provider returned a rate/usage limit. Usage-limit pauses may include a provider reset hint when one is available.
 - If context appears stale after tree navigation or reload, run `/goal status`; branch state is reconstructed from the active branch.
 - In print/JSON modes, commands and tools work, but interactive confirmations/editors are unavailable.
 
 ## Limitations
 
 - Token budget is enforced after finalized assistant usage is visible; v1 cannot hard-stop mid-turn.
-- Usage-limit handling is best-effort via HTTP 429 provider responses.
+- Usage-limit handling is best-effort via HTTP responses and assistant error messages; provider transports vary in how much structured limit information they expose.
 - Automatic continuation is session-local, not a background daemon.
 
 ## Development and validation

package/extensions/index.ts

@@ -9,17 +9,21 @@ import { registerGoalTools } from "../src/tools.js";
 import type { GoalState } from "../src/types.js";
 import { GOAL_EVENT_TYPE } from "../src/types.js";
 import { nowIso, realizedTimeUsed } from "../src/utils.js";
+import { classifyAssistantError, classifyProviderLimit } from "../src/provider-limits.js";
+import type { ProviderLimitClassification } from "../src/provider-limits.js";
 import { clearGoalUi, updateGoalUi } from "../src/ui.js";
 
 export default function piGoal(pi: ExtensionAPI) {
   reportInstallTelemetry();
 
   let goal: GoalState | null = null;
+  let consecutiveAssistantErrors = 0;
   const scheduler = new GoalContinuationScheduler(pi, { getGoal: () => goal });
 
   const setGoal = (next: GoalState | null) => { goal = next; };
 
   function afterGoalChanged(ctx: ExtensionContext, event?: string): void {
+    if (event) consecutiveAssistantErrors = 0;
     updateGoalUi(ctx, goal);
     if (event) {
       ctx.ui.notify(event, "info");
@@ -28,6 +32,17 @@ export default function piGoal(pi: ExtensionAPI) {
     if (!goal || goal.status !== "active") scheduler.clear();
   }
 
+  function pauseForProviderLimit(ctx: ExtensionContext, classification: ProviderLimitClassification): void {
+    if (!goal || goal.status !== "active" || !classification.pause) return;
+    const limited = statusMutation(goal, "usage_limited", realizedTimeUsed(goal), undefined);
+    appendGoalMutation(pi, limited);
+    goal = applyGoalMutation(goal, limited);
+    const suffix = classification.resetHint ? ` (${classification.resetHint})` : classification.retryAfterSeconds != null ? ` (retry after ${classification.retryAfterSeconds}s)` : "";
+    ctx.ui.notify(`Goal paused because the provider hit a usage/rate limit${suffix}.`, "warning");
+    updateGoalUi(ctx, goal);
+    scheduler.clear();
+  }
+
   function accountAndEnforceBudget(ctx: ExtensionContext): void {
     if (!goal) return;
     const result = accountUsageFromBranch(goal, ctx.sessionManager.getBranch() as any[]);
@@ -90,7 +105,22 @@ export default function piGoal(pi: ExtensionAPI) {
   });
 
   pi.on("message_end", async (event: any, ctx) => {
-    if (event.message?.role === "assistant") accountAndEnforceBudget(ctx);
+    if (event.message?.role !== "assistant") return;
+    const classification = classifyAssistantError(event.message);
+    if (classification.pause) {
+      consecutiveAssistantErrors = 0;
+      pauseForProviderLimit(ctx, classification);
+      return;
+    }
+    if (event.message?.stopReason === "error" || event.message?.errorMessage) {
+      consecutiveAssistantErrors++;
+      if (consecutiveAssistantErrors >= 3 && goal?.status === "active") {
+        pauseForProviderLimit(ctx, { kind: "provider_error", pause: true, reason: "repeated assistant provider errors" });
+      }
+      return;
+    }
+    consecutiveAssistantErrors = 0;
+    accountAndEnforceBudget(ctx);
   });
 
   pi.on("turn_end", async (_event, ctx) => {
@@ -103,13 +133,8 @@ export default function piGoal(pi: ExtensionAPI) {
   });
 
   pi.on("after_provider_response", async (event, ctx) => {
-    if (event.status !== 429 || !goal || goal.status !== "active") return;
-    const limited = statusMutation(goal, "usage_limited", realizedTimeUsed(goal), undefined);
-    appendGoalMutation(pi, limited);
-    goal = applyGoalMutation(goal, limited);
-    ctx.ui.notify("Goal paused because the provider returned a usage/rate limit.", "warning");
-    updateGoalUi(ctx, goal);
-    scheduler.clear();
+    if (!goal || goal.status !== "active") return;
+    pauseForProviderLimit(ctx, classifyProviderLimit({ status: event.status, headers: event.headers }));
   });
 
   pi.on("context", async (event) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mocito/pi-goal",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Persistent long-running goals for Pi.",
   "type": "module",
   "license": "MIT",
@@ -53,12 +53,12 @@
     "typebox": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.75.4",
-    "@earendil-works/pi-coding-agent": "^0.75.4",
-    "@earendil-works/pi-tui": "^0.75.4",
+    "@earendil-works/pi-ai": "^0.78.0",
+    "@earendil-works/pi-coding-agent": "^0.78.0",
+    "@earendil-works/pi-tui": "^0.78.0",
     "@types/node": "^25.6.2",
-    "typebox": "^1.1.33",
-    "tsx": "^4.21.0",
+    "typebox": "^1.1.39",
+    "tsx": "^4.22.4",
     "typescript": "^6.0.3"
   },
   "publishConfig": {

package/src/accounting.ts

@@ -1,6 +1,6 @@
 import type { BranchEntry, GoalMutation, GoalState } from "./types.js";
 import { GOAL_SCHEMA_VERSION } from "./types.js";
-import { nowIso, realizedTimeUsed } from "./utils.js";
+import { nowIso } from "./utils.js";
 
 export interface UsageAccountingResult {
   mutation?: GoalMutation;
@@ -34,14 +34,13 @@ export function accountUsageFromBranch(goal: GoalState, branchEntries: BranchEnt
     addedEntryIds.push(entry.id);
   }
   if (addedTokens === 0) return { goal, addedTokens: 0, addedEntryIds };
-  const timeUsedSeconds = realizedTimeUsed(goal, endMs);
+  void endMs;
   const mutation: GoalMutation = {
     schemaVersion: GOAL_SCHEMA_VERSION,
     kind: "account",
     goalId: goal.goalId,
     tokens: addedTokens,
     entryIds: addedEntryIds,
-    timeUsedSeconds,
     at: nowIso(),
   };
   return {
@@ -51,7 +50,6 @@ export function accountUsageFromBranch(goal: GoalState, branchEntries: BranchEnt
     goal: {
       ...goal,
       tokensUsed: goal.tokensUsed + addedTokens,
-      timeUsedSeconds,
       accountedUsage: {
         tokens: goal.tokensUsed + addedTokens,
         entryIds: [...goal.accountedUsage.entryIds, ...addedEntryIds],

package/src/index.ts

@@ -10,3 +10,4 @@ export * from "./tools.js";
 export * from "./ui.js";
 export * from "./rendering.js";
 export * from "./install-telemetry.js";
+export * from "./provider-limits.js";

package/src/provider-limits.ts

@@ -0,0 +1,125 @@
+export type ProviderLimitKind = "none" | "rate_limit" | "usage_limit" | "quota_exceeded" | "billing_required" | "auth_required" | "provider_error";
+
+export interface ProviderLimitInput {
+  status?: number;
+  headers?: Record<string, string | string[] | undefined>;
+  errorMessage?: string;
+  provider?: string;
+  model?: string;
+}
+
+export interface ProviderLimitClassification {
+  kind: ProviderLimitKind;
+  pause: boolean;
+  reason?: string;
+  retryAfterSeconds?: number;
+  resetHint?: string;
+}
+
+const USAGE_LIMIT_PATTERNS = [
+  /GoUsageLimitError/i,
+  /\busage limit (?:reached|exceeded)/i,
+  /\b\d+\s*-?\s*hour usage limit/i,
+  /\bdaily limit\b/i,
+  /\bmonthly limit\b/i,
+  /\bweekly limit\b/i,
+  /\btoken plan\b/i,
+];
+
+const QUOTA_PATTERNS = [
+  /insufficient[_\s-]?quota/i,
+  /quota (?:exceeded|reached)/i,
+  /exceeded (?:your )?quota/i,
+];
+
+const BILLING_PATTERNS = [
+  /billing/i,
+  /available balance/i,
+  /enable usage from your available balance/i,
+  /payment required/i,
+  /credits? exhausted/i,
+];
+
+const AUTH_PATTERNS = [
+  /invalid api key/i,
+  /unauthorized/i,
+  /forbidden/i,
+  /authentication/i,
+];
+
+export function classifyProviderLimit(input: ProviderLimitInput): ProviderLimitClassification {
+  const status = input.status;
+  const text = extractSearchableText(input);
+  const retryAfterSeconds = parseRetryAfter(input.headers);
+  const resetHint = extractResetHint(text);
+
+  if (matchesAny(text, USAGE_LIMIT_PATTERNS)) return { kind: "usage_limit", pause: true, reason: "provider usage limit reached", retryAfterSeconds, resetHint };
+  if (matchesAny(text, QUOTA_PATTERNS)) return { kind: "quota_exceeded", pause: true, reason: "provider quota exceeded", retryAfterSeconds, resetHint };
+  if (matchesAny(text, BILLING_PATTERNS)) return { kind: "billing_required", pause: true, reason: "provider billing or balance limit", retryAfterSeconds, resetHint };
+  if ((status === 401 || status === 403) && matchesAny(text, AUTH_PATTERNS)) return { kind: "auth_required", pause: true, reason: "provider authentication failed", retryAfterSeconds, resetHint };
+  if (status === 402) return { kind: "billing_required", pause: true, reason: "provider payment required", retryAfterSeconds, resetHint };
+  if (status === 429) return { kind: "rate_limit", pause: true, reason: "provider returned HTTP 429", retryAfterSeconds, resetHint };
+  if (status && status >= 500) return { kind: "provider_error", pause: false, reason: `provider returned HTTP ${status}`, retryAfterSeconds, resetHint };
+  if (/\b429\b/.test(text) && /rate limit|too many requests|limit/i.test(text)) return { kind: "rate_limit", pause: true, reason: "provider returned a rate limit error", retryAfterSeconds, resetHint };
+  return { kind: "none", pause: false, retryAfterSeconds, resetHint };
+}
+
+export function classifyAssistantError(message: any): ProviderLimitClassification {
+  if (!message || message.role !== "assistant") return { kind: "none", pause: false };
+  const raw = typeof message.errorMessage === "string" ? message.errorMessage : "";
+  if (!raw && message.stopReason !== "error") return { kind: "none", pause: false };
+  return classifyProviderLimit({
+    status: extractStatus(raw),
+    errorMessage: raw || String(message.stopReason ?? ""),
+    provider: message.provider,
+    model: message.model,
+  });
+}
+
+function extractSearchableText(input: ProviderLimitInput): string {
+  const parts = [input.errorMessage ?? "", input.provider ?? "", input.model ?? ""];
+  if (input.headers) parts.push(JSON.stringify(input.headers));
+  try {
+    const match = (input.errorMessage ?? "").match(/\{[\s\S]*\}/);
+    if (match) parts.push(JSON.stringify(JSON.parse(match[0])));
+  } catch {
+    // Keep the raw error text if provider payload is not valid JSON.
+  }
+  return parts.join("\n");
+}
+
+function matchesAny(text: string, patterns: RegExp[]): boolean {
+  return patterns.some((pattern) => pattern.test(text));
+}
+
+function extractStatus(errorMessage: string): number | undefined {
+  const match = errorMessage.match(/^\s*(\d{3})\b/);
+  if (!match) return undefined;
+  const status = Number(match[1]);
+  return Number.isFinite(status) ? status : undefined;
+}
+
+function parseRetryAfter(headers: ProviderLimitInput["headers"]): number | undefined {
+  const value = headerValue(headers, "retry-after");
+  if (!value) return undefined;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds >= 0) return Math.floor(seconds);
+  const date = Date.parse(value);
+  if (!Number.isFinite(date)) return undefined;
+  return Math.max(0, Math.ceil((date - Date.now()) / 1000));
+}
+
+function headerValue(headers: ProviderLimitInput["headers"], name: string): string | undefined {
+  if (!headers) return undefined;
+  const found = Object.entries(headers).find(([key]) => key.toLowerCase() === name);
+  const value = found?.[1];
+  return Array.isArray(value) ? value[0] : value;
+}
+
+function extractResetHint(text: string): string | undefined {
+  const resets = text.match(/resets?\s+in\s+([^".\n]+)/i);
+  if (resets) return `resets in ${resets[1].trim()}`;
+  const retry = text.match(/try again\s+in\s+([^".\n]+)/i);
+  if (retry) return `try again in ${retry[1].trim()}`;
+  return undefined;
+}

package/src/state.ts

@@ -63,7 +63,7 @@ export function applyGoalMutation(current: GoalState | null, mutation: GoalMutat
     case "account": {
       const ids = [...new Set([...current.accountedUsage.entryIds, ...mutation.entryIds])];
       const tokens = current.tokensUsed + mutation.tokens;
-      return { ...current, tokensUsed: tokens, timeUsedSeconds: mutation.timeUsedSeconds ?? current.timeUsedSeconds, accountedUsage: { tokens, entryIds: ids }, updatedAt: mutation.at };
+      return { ...current, tokensUsed: tokens, accountedUsage: { tokens, entryIds: ids }, updatedAt: mutation.at };
     }
   }
 }