clauderipple 0.9.5 → 0.11.0

package/dist/mod/hooks/judge.ts

@@ -5,9 +5,15 @@ import type { Lang } from './i18n.ts'
 
 const EFFORTS: readonly Effort[] = ['low', 'medium', 'high', 'xhigh', 'max']
 
-export const EFFORT_JUDGE_SYSTEM = `Choose the cheapest reasoning effort that can do this work well. This is a coding agent able to inspect files, run commands, and edit code, not merely answer a chat question.
-Assess work volume, uncertainty, and the cost of mistakes, not message length. A short choice approving a build inherits the size of that build. Corrections and steering retain at least the running effort; closing remarks need little effort. "Think hard" or thorough reasoning requires at least high; an explicit quick answer calls for low.
-Low and medium are only for turns that need no judgment: low for chit-chat, thanks, or a direct answer needing no inspection; medium for one fully specified, low-risk step the user spelled out (run this command, rename this). Anything that asks the agent to decide, explain why, review, verify, debug, plan, delegate, or change more than one thing needs at least high; most coding-agent turns are high. xhigh is for unusually difficult investigation, and max only for the hardest open-ended problems. Consider the current model's strength.
+// "xhigh for unusually difficult investigation, max only for the hardest open-ended problems" left
+// a medium..max range at medium and high: 10-13..10-17 ran ~9,000 Opus requests with no max and 91
+// xhigh, and Jev gave an architecture redesign 2% max (2026-10-19). Above high is now named by
+// what hinges on judgment, so important plans and failed attempts can reach it.
+export const EFFORT_JUDGE_SYSTEM = `Choose the reasoning effort this work deserves. This is a coding agent able to inspect files, run commands, and edit code, not merely answer a chat question.
+Assess work volume, uncertainty, and the cost of mistakes, not message length. A short choice approving a build inherits the size of that build. Closing remarks need little effort. "Think hard" or thorough reasoning requires at least high; an explicit quick answer calls for low.
+Low and medium are only for turns that need no judgment: low for chit-chat, thanks, or a direct answer needing no inspection; medium for one fully specified, low-risk step the user spelled out (run this command, rename this). Ordinary coding that asks the agent to decide, explain why, review, verify, debug with a known direction, delegate, or change more than one thing is high.
+Go above high when the outcome hinges on judgment rather than labor. xhigh: debugging whose cause is unknown, changes across interacting modules, or planning a feature. max: decisions that shape the product or system (architecture, an important plan or strategy, a design meant to last), work where a wrong call risks security, money, or data loss, and problems that earlier attempts in this conversation failed to solve. Not every plan is max; a small or routine plan is high or xhigh.
+When the user says the previous attempt failed, is wrong, or still does not work, choose at least one level above the running effort. Other corrections and steering keep at least the running effort. Consider the current model's strength.
 Return only JSON {"effort":"low|medium|high|xhigh|max","sure":0.0,"why":"short reason"}. Confidence is between zero and one. The reason uses the user's language and at most six words.`
 
 /** A terse continuation usually carries no new scope; answers to questions are handled separately. */
@@ -16,6 +22,11 @@ export function isShortFollowUp(text: string): boolean {
   return trimmed.length > 0 && trimmed.length <= 12 && trimmed.split(/\s+/).length <= 2
 }
 
+/** "Still broken" is short but asks for more thought, so it is judged rather than inheriting the effort that failed. */
+export function looksLikeRetry(text: string): boolean {
+  return /안\s*[돼되]|다시|틀렸|아직|여전|그대로|실패|\bstill\b|\bagain\b|\bwrong\b|\bbroken\b|n['’]?t work|\bfail/i.test(text)
+}
+
 export function looksLikeQuestion(assistantTail: string): boolean {
   return assistantTail.slice(-400).includes('?')
 }
@@ -28,7 +39,7 @@ export function shouldJudge(input: {
   if (!input.auto || !['composer', 'bridge', 'sdk'].includes(input.origin) || (!input.text.trim() && !input.attachments?.length) || input.hostCommand) return false
   if (input.modelId !== undefined && !isCacheSafeModel(input.modelId)) return false
   const followup = input.current && input.current.by !== 'manual' && !input.text.trim().startsWith('/') &&
-    !input.attachments?.length && isShortFollowUp(input.text) && !looksLikeQuestion(input.assistantTail ?? '')
+    !input.attachments?.length && isShortFollowUp(input.text) && !looksLikeRetry(input.text) && !looksLikeQuestion(input.assistantTail ?? '')
   return !followup
 }
 
@@ -110,16 +121,19 @@ function looseVerdictObject(text: string): Record<string, unknown> | undefined {
 }
 
 const effortCriteria = {
-  low: 'Small direct work with little uncertainty or planning.',
-  medium: 'Ordinary bounded coding with a few inspections or edits.',
-  high: 'Substantial multi-step coding or debugging where mistakes matter.',
-  xhigh: 'Difficult extended investigation with interacting constraints.',
-  max: 'Exceptional open-ended research or the hardest reasoning problems.',
-}
+  low: 'Chit-chat, thanks, or a direct answer needing no inspection.',
+  medium: 'One fully specified, low-risk step the user spelled out.',
+  high: 'Ordinary coding: implement, fix, review, or debug with a known direction.',
+  xhigh: 'Debugging with an unknown cause, changes across interacting modules, or planning a feature.',
+  max: 'Product or architecture decisions, important plans or strategy, security or data-loss risk, or a problem earlier attempts failed to solve.',
+}
+// Read with the brief, the old wording sent 49 of 64 delegated tasks to deep, against 19 from their
+// one-line descriptions alone: a brief's warnings ("do not restart", "read-only", "no guessing")
+// read as high stakes. Re-judged with this wording the same briefs give 28 (2026-10-15, pick log).
 const levelCriteria = {
-  light: 'Mechanical chores, repeated changes, or simple lookups.',
-  standard: 'Implement a designed change, research, summarize documentation, or review.',
-  deep: 'Careful high-stakes reasoning, subtle debugging, architecture, or security.',
+  light: 'Mechanical chores, repeated edits, simple lookups, or one small fix.',
+  standard: 'Carry out a designed change, even across several files; research, summarize, or review read-only.',
+  deep: 'Subtle debugging, security review, or architecture where a wrong call is costly. Size, file count, or warnings and prohibitions in the brief do not by themselves make work deep.',
 }
 const domainCriteria: Record<Domain, string> = {
   design: 'Visual composition, branding, taste, look and voice of copy.',
@@ -188,10 +202,14 @@ export function parseJevWorker(json: unknown): WorkerVerdict | undefined {
   const effortAnswer = record(reply?.effort)
   const selectedEffort = effort(effortAnswer?.choice)
   if (!domainAnswer || !DOMAINS.includes(domainAnswer.choice as Domain) || !levelAnswer || !LEVELS.includes(levelAnswer.choice as Level) || !effortAnswer || !selectedEffort) return undefined
-  // Confidence moves a task up the ladder, so it is the level's question that counts, not the kind's.
-  const scores = [answerSure(domainAnswer), answerSure(levelAnswer), answerSure(effortAnswer)].filter((score): score is number => score !== undefined)
-  const kind = kindOf(record(reply?.kind)?.choice) ?? 'do'
-  return { domain: domainAnswer.choice as Domain, level: levelAnswer.choice as Level, kind, effort: selectedEffort, ...(scores.length ? { sure: Math.min(...scores) } : {}), why: '' }
+  // Confidence moves a task up the ladder, so it is the level's question that counts. The lowest of
+  // all three counted before: torn only between frontend and backend, or high and xhigh, a task
+  // judged standard was sent a rung up (4 of 16 standard verdicts, pick log 2026-10-12..15).
+  const kindAnswer = record(reply?.kind)
+  const kind = kindOf(kindAnswer?.choice) ?? 'do'
+  const odds = { domain: answerSure(domainAnswer), level: answerSure(levelAnswer), kind: kindAnswer ? answerSure(kindAnswer) : undefined, effort: answerSure(effortAnswer) }
+  const known = Object.fromEntries(Object.entries(odds).filter(([, score]) => score !== undefined)) as WorkerVerdict['odds']
+  return { domain: domainAnswer.choice as Domain, level: levelAnswer.choice as Level, kind, effort: selectedEffort, ...(odds.level !== undefined ? { sure: odds.level } : {}), ...(Object.keys(known!).length ? { odds: known } : {}), why: '' }
 }
 
 export function jevUsage(json: unknown): number {

package/dist/mod/hooks/modes.ts

@@ -1,7 +1,7 @@
 // Operating modes in the session (docs/specs/2026-10-12-worker-tiers.md "Operating modes"): which
 // mode is on, when it ends by itself, and the eager-delegation note. Pure; register.tsx wires them.
 
-import type { Hot, Mode, Settings } from '../types'
+import type { Hot, LimitItem, Mode, Settings } from '../types'
 
 /** The mode that is on, if the settings name one that exists. */
 export function activeModeOf(s: Pick<Settings, 'modes' | 'activeMode'>): Mode | undefined {
@@ -91,3 +91,58 @@ export function modeOver(mode: Pick<Mode, 'until'>, since: number | undefined, n
   const passed = (at: number) => at > since && at <= now
   return windows.some(w => passed(w.at) || (w.windowMs !== undefined && passed(w.at - w.windowMs)))
 }
+
+/** The configured providers of ChatGPT type, from GET /api/status `providers` (name → {type}). */
+export function chatgptProviders(status: unknown): string[] {
+  const providers = record(status).providers
+  if (!providers || typeof providers !== 'object' || Array.isArray(providers)) return []
+  return Object.entries(providers as Record<string, unknown>)
+    .filter(([, value]) => record(value).type === 'chatgpt')
+    .map(([name]) => name)
+}
+
+/**
+ * Every signed-in ChatGPT account's known windows as the limits row reads them, from GET
+ * /api/chatgpt-accounts (`quota.rate_limits.{primary,secondary}` with `reset_at` in epoch
+ * seconds or ms, or `reset_after_seconds` from the snapshot's `at`, and `window_minutes`;
+ * the same shape `quotaWindows` reads). Paused and needs-login accounts are left out (and take
+ * no number), and so is an account with no snapshot. `account` numbers the accounts kept, in
+ * answer order. A snapshot is not aged out: the router takes it from the account's own replies,
+ * so an account idle for an hour holds an hour-old figure that is still right (measured
+ * 2026-10-15: 30 minutes old between uses). Only a window whose reset has passed is dropped,
+ * since its figure no longer stands.
+ */
+export function gptLimitsFrom(body: unknown, provider: string, now: number): LimitItem[] {
+  const accounts = record(body).accounts
+  if (!Array.isArray(accounts)) return []
+  const kept = accounts.map(record).filter(account => account.state !== 'paused' && account.state !== 'needs-login' && account.paused !== true)
+  const out: LimitItem[] = []
+  kept.forEach((account, index) => {
+    const quota = record(account.quota)
+    const at = quota.at
+    if (typeof at !== 'number') return
+    const limits = record(quota.rate_limits)
+    for (const key of ['primary', 'secondary']) {
+      const window = record(limits[key])
+      const used = window.used_percent
+      if (typeof used !== 'number' || !Number.isFinite(used)) continue
+      const minutes = window.window_minutes
+      const resetAt = typeof window.reset_at === 'number' ? (window.reset_at > 1e12 ? window.reset_at : window.reset_at * 1000)
+        : typeof window.reset_after_seconds === 'number' && typeof at === 'number' ? at + window.reset_after_seconds * 1000 : NaN
+      if (Number.isFinite(resetAt) && resetAt <= now) continue
+      const kind = minutes === 300 ? 'five_hour' : minutes === 10080 ? 'seven_day' : 'window'
+      out.push({
+        provider,
+        type: 'chatgpt',
+        title: 'GPT',
+        account: index,
+        kind,
+        label: '',
+        ...(typeof minutes === 'number' && minutes > 0 ? { windowMinutes: minutes } : {}),
+        percent: Math.round(used * 10) / 10,
+        ...(Number.isFinite(resetAt) ? { resetsAt: new Date(resetAt).toISOString() } : {}),
+      })
+    }
+  })
+  return out
+}