@tduyng/pi-session 0.0.1 → 0.0.3

package/README.md

@@ -1,20 +1,24 @@
 # @tduyng/pi-session
 
-Session lifecycle: sessions name themselves and resume once a provider quota resets. No more `untitled` rows in the picker, no more waiting out a usage limit by hand.
+Sessions name themselves, and a turn killed by a usage limit resumes when the limit resets. No more `untitled` rows in the picker, no more sitting out a quota by hand.
+
+## What it costs
+
+Nothing. No tool is registered, no prompt text is injected, and no session entry is created for the naming. The extension reads at `agent_end` and writes a name.
 
 ## Auto-name
 
-A new session starts unnamed. On `agent_end`, the extension reads the first user message and uses it as the name. It takes the first line, strips a leading `/` or `#`, collapses whitespace, and limits the result to 60 characters, cutting at a word boundary.
+A new session starts unnamed. On `agent_end` the extension reads the first user message and uses it: first line, a leading `/` or `#` stripped, whitespace collapsed, 60 characters at most, cut at a word boundary.
 
-An expanded skill uses its argument when one is present, or the skill name when it has no argument. The extension ignores the expanded instructions and the skill's filesystem path. A `/skill:name task` command follows the same rule and uses `task` when present. A `Skill invocation protocol` message without a skill block is skipped because an extension injected it. A name you set with `/name` always wins. Naming runs last and swallows its own errors. It is cosmetic and never blocks the turn.
+Before, a week of `2026-09-01 14:22`, `2026-09-01 14:47`, `2026-09-02 09:03`. After, `fix retry backoff`, `review auth diff`, `migrate schema`.
 
-The extension finds the first user-role message in the `event.messages` array. If the message content is a block array, it extracts text blocks and joins them with spaces. When no user message exists, naming is skipped silently.
+An expanded skill uses its argument when one is present, or the skill name when it has none. The extension ignores the expanded instructions and the skill's filesystem path. A `/skill:name task` command follows the same rule and uses `task`. A `Skill invocation protocol` message with no skill block is skipped, because an extension injected it. A name you set with `/name` always wins.
 
-Before: a week of `2026-09-01 14:22`, `2026-09-01 14:47`, `2026-09-02 09:03`. After: `fix retry backoff`, `review auth diff`, `migrate schema`.
+Naming runs last and swallows its own errors. It is cosmetic and never blocks a turn.
 
 ## Autoresume
 
-When a provider quota exhaustion kills a turn, the extension parses a reset time from the error text. Formats it accepts:
+When a provider quota exhaustion kills a turn, the extension parses a reset time out of the error text. It accepts:
 
 - Epoch timestamps: `limit reached|1757193000`
 - ISO timestamps: `resets at 2026-09-06T23:30:00+02:00`
@@ -22,15 +26,22 @@ When a provider quota exhaustion kills a turn, the extension parses a reset time
 - Clock times: `resets 11:30pm (Europe/Paris)`, `reset at 23:30`
 - Retry-after headers: `retry-after: 3600`
 
-For claude-bridge sessions where the error carries no reset time, autoresume queries the Anthropic OAuth usage endpoint and picks the latest reset among all exhausted windows, with the credential from the macOS keychain (`Claude Code-credentials`) or `~/.claude/.credentials.json`.
+For a claude-bridge session whose error carries no reset time, it asks the Anthropic OAuth usage endpoint and picks the latest reset among the exhausted windows, with the credential from the macOS keychain or `~/.claude/.credentials.json`.
 
-A 5-second safety delay is added past the reset time. The timer caps at 24 hours. A parsed reset further than 24 hours out schedules nothing and posts a warning: Usage limit resets in over 24h, auto-resume not scheduled. Any user turn or session shutdown cancels it. The resume sends a real user message: "The usage limit has reset. Continue the previous task from where it stopped."
+A 5-second safety delay is added past the reset, and the timer caps at 24 hours. A reset further out than 24 hours schedules nothing and posts a warning instead. Any user turn or session shutdown cancels it. The resume sends a real user message: "The usage limit has reset. Continue the previous task from where it stopped."
 
-Commands: `/autoresume`, `/autoresume status`, `/autoresume on`, `/autoresume off`, `/autoresume cancel`.
+A quota reset is the cheapest minute of the day to be running: the window opened, the work is ready, and nobody has to be awake for it.
+
+| Command | Effect |
+| --- | --- |
+| `/autoresume` | Status |
+| `/autoresume on` | Arm it |
+| `/autoresume off` | Disarm it |
+| `/autoresume cancel` | Drop the pending resume |
 
 ## Design
 
-Auto-naming reads at `agent_end`, when real conversation content exists. Autoresume touches no session storage and adds no tools beyond the one command. Session creation, storage, and selection stay with pi.
+Autoresume touches no session storage and adds no tool beyond its command. Session creation, storage, and selection stay with pi.
 
 ## Install
 
@@ -40,6 +51,4 @@ pi install npm:@tduyng/pi-session
 
 Local checkout: `pi install /path/to/dotfiles/pi/agent/extensions/pi-session`
 
-## Configure
-
-None. It works out of the box.
+No configuration required.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tduyng/pi-session",
-  "version": "0.0.1",
-  "description": "Session lifecycle: name an unnamed session after its first message, and resume once a provider quota resets.",
+  "version": "0.0.3",
+  "description": "Sessions name themselves, and a turn killed by a usage limit resumes when the limit resets.",
   "keywords": [
     "pi",
     "pi-package",
@@ -31,6 +31,9 @@
     "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*"
   },
+  "dependencies": {
+    "ata-validator": "^1.62.1"
+  },
   "publishConfig": {
     "access": "public"
   },

package/src/autoresume.ts

@@ -1,6 +1,5 @@
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
-import { claudeToken, fetchAnthropicUsage } from '../../pi-cost/src/cost/index.js'
-import { exhaustedResetAt } from '../../pi-cost/src/cost/logic.js'
+import { claudeToken, exhaustedResetAt, fetchAnthropicUsage } from './usage.js'
 
 const SAFETY_DELAY_MS = 5_000
 const MAX_DELAY_MS = 24 * 60 * 60 * 1000
@@ -33,6 +32,7 @@ export default function autoResume(pi: ExtensionAPI) {
         pendingError = undefined
 
         if (!enabled || !error || resumeAt) return
+        if (!isQuotaError(error)) return
 
         const reportedTarget = parseReset(error)
         const providerTarget = ctx.model?.provider === 'claude-bridge' ? await usageResetAt(pi, ctx) : undefined
@@ -78,9 +78,9 @@ export default function autoResume(pi: ExtensionAPI) {
     })
 
     pi.on('session_shutdown', async (_event, ctx) => cancel(ctx))
-    pi.on('session_start', () => {
+    pi.on('session_start', (_event, ctx) => {
         pendingError = undefined
-        stopTicker()
+        cancel(ctx)
     })
 }
 
@@ -244,10 +244,14 @@ function parseRetryAfter(input: string, now: number): number | undefined {
     return match ? now + Number(match[1]) * 1000 : undefined
 }
 
+function isQuotaError(input: string): boolean {
+    return /\b(?:usage|quota|limit|rate[- ]?limit|too many requests|429)\b/i.test(input)
+}
+
 function parseClock(input: string, now: number): number | undefined {
     const match = input.match(/\breset(?:s)?(?:\s+at)?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?(?:\s*\(([^)]+)\))?/i)
 
-    if (!match) return
+    if (!match || (match[2] === undefined && match[3] === undefined)) return
 
     let hour = Number(match[1])
     const minute = Number(match[2] ?? '0')

package/src/usage.ts

@@ -0,0 +1,109 @@
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+import { Validator } from 'ata-validator'
+import { t } from 'ata-validator/t'
+
+const REQUEST_TIMEOUT_MS = 10_000
+const KEYCHAIN_TIMEOUT_MS = 5_000
+
+const WindowSchema = t.object({
+    utilization: t.optional(t.union([t.number(), t.null()])),
+    resets_at: t.optional(t.union([t.string(), t.number(), t.null()]))
+})
+const UsageSchema = t.object({
+    five_hour: t.optional(t.union([WindowSchema, t.null()])),
+    seven_day: t.optional(t.union([WindowSchema, t.null()])),
+    seven_day_opus: t.optional(t.union([WindowSchema, t.null()])),
+    seven_day_sonnet: t.optional(t.union([WindowSchema, t.null()]))
+})
+const CredentialsSchema = t.object(
+    {
+        claudeAiOauth: t.optional(t.object({ accessToken: t.optional(t.string()) }, { additionalProperties: true }))
+    },
+    { additionalProperties: true }
+)
+
+const isUsage = new Validator(UsageSchema).isValidObject
+const isCredentials = new Validator(CredentialsSchema).isValidObject
+
+export type AnthropicWindow = { utilization?: number | null; resets_at?: string | number | null }
+
+export type AnthropicUsagePayload = {
+    five_hour?: AnthropicWindow | null
+    seven_day?: AnthropicWindow | null
+    seven_day_opus?: AnthropicWindow | null
+    seven_day_sonnet?: AnthropicWindow | null
+}
+
+function finite(value: number | null | undefined): number | undefined {
+    const numeric = value ?? Number.NaN
+    return Number.isFinite(numeric) ? numeric : undefined
+}
+
+export function resetAtMs(value: string | number | null | undefined): number | undefined {
+    if (value === null || value === undefined) return undefined
+    const numeric = Number(value)
+    const parsed = Number.isFinite(numeric) ? numeric : Date.parse(String(value))
+    if (!Number.isFinite(parsed) || parsed <= 0) return undefined
+    return parsed < 1e12 ? parsed * 1000 : parsed
+}
+
+export function exhaustedResetAt(payload: AnthropicUsagePayload): number | undefined {
+    const windows = [payload.five_hour, payload.seven_day, payload.seven_day_opus, payload.seven_day_sonnet]
+    let latest: number | undefined
+    for (const window of windows) {
+        const utilization = finite(window?.utilization)
+        const resetAt = resetAtMs(window?.resets_at)
+        if (utilization === undefined || utilization < 100 || resetAt === undefined) continue
+        latest = latest === undefined ? resetAt : Math.max(latest, resetAt)
+    }
+    return latest
+}
+
+export function claudeAccessToken(raw: string | undefined): string | undefined {
+    if (!raw) return undefined
+    try {
+        const parsed: unknown = JSON.parse(raw)
+        if (!isCredentials(parsed)) return undefined
+        const token = parsed.claudeAiOauth?.accessToken?.trim()
+        return token || undefined
+    } catch {
+        return undefined
+    }
+}
+
+export async function claudeToken(
+    pi: ExtensionAPI,
+    platform: NodeJS.Platform = process.platform
+): Promise<string | undefined> {
+    let raw: string | undefined
+    if (platform === 'darwin') {
+        const result = await pi.exec('security', ['find-generic-password', '-s', 'Claude Code-credentials', '-w'], {
+            cwd: os.homedir(),
+            timeout: KEYCHAIN_TIMEOUT_MS
+        })
+        if (result.code && result.code !== 44) throw new Error(`keychain lookup failed (exit ${result.code})`)
+        raw = result.stdout
+    }
+    if (!raw) {
+        raw = await fs.readFile(path.join(os.homedir(), '.claude', '.credentials.json'), 'utf8').catch(() => undefined)
+    }
+    return claudeAccessToken(raw)
+}
+
+export async function fetchAnthropicUsage(token: string): Promise<AnthropicUsagePayload> {
+    const response = await fetch('https://api.anthropic.com/api/oauth/usage', {
+        headers: {
+            authorization: `Bearer ${token}`,
+            'anthropic-beta': 'oauth-2025-04-20',
+            accept: 'application/json'
+        },
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    })
+    if (!response.ok) throw new Error(`HTTP ${response.status}`)
+    const payload: unknown = await response.json()
+    if (!isUsage(payload)) throw new Error('usage response did not match the Anthropic schema')
+    return payload
+}