pikiloom 0.4.51 → 0.4.53

package/dist/agent/drivers/claude.js

@@ -1440,13 +1440,21 @@ const SYSTEM_INJECTED_USER_TAGS = new Set([
     'case_id',
     'tool-use-id',
     'output-file',
+    // Kernel claude driver's in-process truncated-turn recovery prompt (see packages/kernel
+    // drivers/claude.ts): injected on the CLI's stdin, so it lands in the jsonl as a real user
+    // message — hide it from the transcript like other system-injected turns.
+    'pikiloom-recover',
 ]);
+// The CLI's resume-time repair placeholder for a turn that never concluded (paired with an
+// isMeta "Continue from where you left off." user record). It is not model output — but it IS
+// the only durable marker that the previous reply was cut off before its closing message.
 function isClaudeSyntheticResumeNoise(text) {
     const t = (text || '').trim().toLowerCase();
     if (!t)
         return true;
     return t === 'no response requested.' || t === 'no response requested';
 }
+const CLAUDE_INCOMPLETE_TURN_NOTICE = '⚠️ This reply ended before a closing message was delivered (interrupted, or the model returned an empty final response).';
 function isSystemInjectedUserEvent(text) {
     const trimmed = (text || '').trim();
     if (!trimmed)
@@ -1629,13 +1637,18 @@ function getClaudeSessionMessages(opts) {
                 else if (ev.type === 'assistant') {
                     if (ev.message?.model === '<synthetic>') {
                         const noticeText = extractClaudeText(ev.message?.content, true).trim();
-                        if (isClaudeSyntheticResumeNoise(noticeText))
+                        // "No response requested." is the CLI's resume repair for a turn that never
+                        // concluded. Dropping it hid the cut-off entirely — the dangling turn read as a
+                        // normal answer that stops mid-sentence. Show a notice on that turn instead.
+                        const displayText = !noticeText
+                            ? ''
+                            : isClaudeSyntheticResumeNoise(noticeText) ? CLAUDE_INCOMPLETE_TURN_NOTICE : noticeText;
+                        if (!displayText)
                             continue;
                         if (pendingRole === 'user')
                             flush();
                         pendingRole = 'assistant';
-                        if (noticeText)
-                            pendingBlocks.push({ type: 'system_notice', content: noticeText });
+                        pendingBlocks.push({ type: 'system_notice', content: displayText });
                         continue;
                     }
                     if (pendingRole === 'user')
@@ -1808,37 +1821,137 @@ function getClaudeOAuthToken() {
         return null;
     }
 }
+function claudeResetInfo(resetsAt) {
+    const resetAt = typeof resetsAt === 'string' ? resetsAt : null;
+    let resetAfterSeconds = null;
+    if (resetAt) {
+        const resetAtMs = Date.parse(resetAt);
+        if (Number.isFinite(resetAtMs))
+            resetAfterSeconds = Math.max(0, Math.round((resetAtMs - Date.now()) / 1000));
+    }
+    return { resetAt, resetAfterSeconds };
+}
+// Window status from the upstream severity when it maps to one of ours, else from the percent.
+function claudeWindowStatus(usedPercent, severity) {
+    const fromSeverity = normalizeUsageStatus(severity);
+    if (fromSeverity === 'limit_reached' || fromSeverity === 'warning' || fromSeverity === 'allowed')
+        return fromSeverity;
+    return usedPercent >= 100 ? 'limit_reached' : usedPercent >= 80 ? 'warning' : 'allowed';
+}
+// "$101.61" from a minor-unit amount (10161 with exponent 2). Non-USD keeps the currency code.
+function claudeCreditAmount(amountMinor, exponent, currency) {
+    const minor = Number(amountMinor);
+    if (!Number.isFinite(minor))
+        return null;
+    const expRaw = Number(exponent);
+    const exp = Number.isFinite(expRaw) ? Math.max(0, Math.min(4, Math.round(expRaw))) : 2;
+    const value = (minor / Math.pow(10, exp)).toFixed(exp);
+    const cur = typeof currency === 'string' && currency ? currency.toUpperCase() : 'USD';
+    return cur === 'USD' ? `$${value}` : `${value} ${cur}`;
+}
+const CLAUDE_LIMIT_KIND_LABELS = {
+    session: '5h',
+    weekly_all: '7d',
+};
+// One window per `limits[]` entry. `weekly_scoped` is the per-model weekly quota (the successor
+// of the legacy seven_day_opus / seven_day_sonnet keys) — label it by the scoped model name.
+function claudeWindowFromLimitEntry(entry) {
+    if (!entry || typeof entry !== 'object')
+        return null;
+    const usedPercent = roundPercent(entry.percent);
+    if (usedPercent == null)
+        return null;
+    const kind = typeof entry.kind === 'string' ? entry.kind : '';
+    let label = CLAUDE_LIMIT_KIND_LABELS[kind] ?? null;
+    if (!label && kind === 'weekly_scoped') {
+        const scopeName = entry.scope?.model?.display_name || entry.scope?.model?.id || entry.scope?.surface;
+        label = typeof scopeName === 'string' && scopeName ? `7d ${scopeName}` : '7d scoped';
+    }
+    if (!label)
+        label = kind ? kind.replace(/_/g, ' ') : 'limit';
+    const { resetAt, resetAfterSeconds } = claudeResetInfo(entry.resets_at);
+    return {
+        label, usedPercent,
+        remainingPercent: Math.max(0, Math.round((100 - usedPercent) * 10) / 10),
+        resetAt, resetAfterSeconds,
+        status: claudeWindowStatus(usedPercent, entry.severity),
+    };
+}
+// The Extra (credit-metered overage) window. Percent comes from extra_usage.utilization (finer
+// grained) or spend.percent; the actual spend money rides along as `detail` so surfaces can show
+// "$101.61 / $500.00" instead of a bare percent. Skipped when the account has Extra disabled.
+function claudeExtraUsageWindow(data) {
+    const extra = data?.extra_usage && typeof data.extra_usage === 'object' ? data.extra_usage : null;
+    const spend = data?.spend && typeof data.spend === 'object' ? data.spend : null;
+    if (extra?.is_enabled === false || (!extra && spend?.enabled === false))
+        return null;
+    let usedPercent = extra ? roundPercent(extra.utilization) : null;
+    if (usedPercent == null && spend)
+        usedPercent = roundPercent(spend.percent);
+    if (usedPercent == null)
+        return null;
+    let detail = null;
+    const used = claudeCreditAmount(spend?.used?.amount_minor, spend?.used?.exponent, spend?.used?.currency)
+        ?? claudeCreditAmount(extra?.used_credits, extra?.decimal_places, extra?.currency);
+    const limit = claudeCreditAmount(spend?.limit?.amount_minor, spend?.limit?.exponent, spend?.limit?.currency)
+        ?? claudeCreditAmount(extra?.monthly_limit, extra?.decimal_places, extra?.currency);
+    if (used)
+        detail = limit ? `${used} / ${limit}` : used;
+    const { resetAt, resetAfterSeconds } = claudeResetInfo(extra?.resets_at);
+    return {
+        label: 'Extra', usedPercent,
+        remainingPercent: Math.max(0, Math.round((100 - usedPercent) * 10) / 10),
+        resetAt, resetAfterSeconds,
+        status: claudeWindowStatus(usedPercent, spend?.severity),
+        detail,
+    };
+}
 // Shape the `/api/oauth/usage` JSON into a UsageResult (shared by the sync curl probe and the
 // async fetch probe). Returns null on an API error payload or when no usable window is present.
-function buildClaudeOAuthUsage(data) {
+//
+// The payload carries two generations of quota shapes and we prefer the newer one:
+//   - `limits[]` (2026+): one entry per window — kind "session" (5h), "weekly_all" (7d) and
+//     "weekly_scoped" (per-model weekly, scope.model.display_name) — each with its own percent /
+//     severity / resets_at. On these payloads the legacy `seven_day_opus` / `seven_day_sonnet`
+//     top-level keys are null, so parsing only those silently drops the scoped model window.
+//   - legacy fixed top-level keys: five_hour / seven_day / seven_day_opus / seven_day_sonnet.
+// `extra_usage` + `spend` (credit-metered overage) ride on both shapes, handled separately so
+// the actual dollar spend is preserved.
+export function buildClaudeOAuthUsage(data) {
     const apiError = data?.error;
     if (apiError && typeof apiError === 'object')
         return null;
-    const makeWindow = (label, entry) => {
-        if (!entry || typeof entry !== 'object')
-            return null;
-        const usedPercent = roundPercent(entry.utilization);
-        if (usedPercent == null)
-            return null;
-        const remainingPercent = Math.max(0, Math.round((100 - usedPercent) * 10) / 10);
-        const resetAt = typeof entry.resets_at === 'string' ? entry.resets_at : null;
-        let resetAfterSeconds = null;
-        if (resetAt) {
-            const resetAtMs = Date.parse(resetAt);
-            if (Number.isFinite(resetAtMs))
-                resetAfterSeconds = Math.max(0, Math.round((resetAtMs - Date.now()) / 1000));
-        }
-        return {
-            label, usedPercent, remainingPercent, resetAt, resetAfterSeconds,
-            status: usedPercent >= 100 ? 'limit_reached' : usedPercent >= 80 ? 'warning' : 'allowed',
-        };
-    };
     const windows = [];
-    for (const [label, key] of [['5h', 'five_hour'], ['7d', 'seven_day'], ['7d Opus', 'seven_day_opus'], ['7d Sonnet', 'seven_day_sonnet'], ['Extra', 'extra_usage']]) {
-        const w = makeWindow(label, data[key]);
+    const limitEntries = Array.isArray(data?.limits) ? data.limits : [];
+    for (const entry of limitEntries) {
+        const w = claudeWindowFromLimitEntry(entry);
         if (w)
             windows.push(w);
     }
+    if (!windows.length) {
+        const makeWindow = (label, entry) => {
+            if (!entry || typeof entry !== 'object')
+                return null;
+            const usedPercent = roundPercent(entry.utilization);
+            if (usedPercent == null)
+                return null;
+            const { resetAt, resetAfterSeconds } = claudeResetInfo(entry.resets_at);
+            return {
+                label, usedPercent,
+                remainingPercent: Math.max(0, Math.round((100 - usedPercent) * 10) / 10),
+                resetAt, resetAfterSeconds,
+                status: claudeWindowStatus(usedPercent),
+            };
+        };
+        for (const [label, key] of [['5h', 'five_hour'], ['7d', 'seven_day'], ['7d Opus', 'seven_day_opus'], ['7d Sonnet', 'seven_day_sonnet']]) {
+            const w = makeWindow(label, data[key]);
+            if (w)
+                windows.push(w);
+        }
+    }
+    const extra = claudeExtraUsageWindow(data);
+    if (extra)
+        windows.push(extra);
     if (!windows.length)
         return null;
     const overallStatus = windows.some(w => w.status === 'limit_reached') ? 'limit_reached'
@@ -1889,17 +2002,22 @@ async function fetchClaudeUsageFromOAuth(tokenOverride) {
 // token). The read costs no inference tokens but the endpoint RATE-LIMITS aggressive polling
 // (observed: `rate_limit_error` payloads, which parse to null) — so `fresh` re-reads only after
 // 15s, and a failed read backs off 60s serving the last good result. Concurrent callers share
-// one request.
+// one request. `force` is for explicit user-clicked refreshes only: it bypasses both the TTL and
+// the failure backoff (human-paced clicks cannot stampede the endpoint), with a short floor to
+// absorb double-clicks.
 const NATIVE_USAGE_FRESH_TTL_MS = 15_000;
 const NATIVE_USAGE_RETRY_TTL_MS = 60_000;
+const NATIVE_USAGE_FORCE_FLOOR_MS = 3_000;
 const claudeNativeUsageLive = { at: 0, failedAt: 0, inflight: null };
 export function claudeNativeUsage(opts) {
-    const maxAge = opts?.fresh ? NATIVE_USAGE_FRESH_TTL_MS : CLAUDE_USAGE_QUERY_TTL_MS;
+    const maxAge = opts?.force ? NATIVE_USAGE_FORCE_FLOOR_MS
+        : opts?.fresh ? NATIVE_USAGE_FRESH_TTL_MS : CLAUDE_USAGE_QUERY_TTL_MS;
     const now = Date.now();
     if (claudeUsageCache.lastGood && now - claudeNativeUsageLive.at < maxAge) {
         return Promise.resolve(claudeUsageCache.lastGood);
     }
-    if (now - claudeNativeUsageLive.failedAt < NATIVE_USAGE_RETRY_TTL_MS) {
+    const failureFloor = opts?.force ? NATIVE_USAGE_FORCE_FLOOR_MS : NATIVE_USAGE_RETRY_TTL_MS;
+    if (now - claudeNativeUsageLive.failedAt < failureFloor) {
         return Promise.resolve(claudeUsageCache.lastGood);
     }
     if (claudeNativeUsageLive.inflight)
@@ -1933,12 +2051,14 @@ export function claudeNativeUsage(opts) {
 // are tiered by how fresh the caller needs to be:
 //   default -> 5min TTL (background warmers, non-interactive surfaces)
 //   fresh   -> 20s min re-probe interval (user is actively looking at the numbers)
-//   force   -> bypass everything (identity just changed, e.g. account switch)
+//   force   -> bypass the TTL and the failure backoff (account switch, explicit refresh click),
+//              modulo a short double-click floor
 // Failures back off 60s on the default/fresh tiers (force still retries), and in-flight de-dup
 // makes concurrent surfaces (cards + header + IM) share one probe.
 const TOKEN_USAGE_OK_TTL_MS = CLAUDE_USAGE_QUERY_TTL_MS;
 const TOKEN_USAGE_FRESH_TTL_MS = 20_000;
 const TOKEN_USAGE_RETRY_TTL_MS = 60_000;
+const TOKEN_USAGE_FORCE_FLOOR_MS = 3_000;
 const CLAUDE_USAGE_PROBE_MODEL = 'claude-haiku-4-5-20251001';
 const claudeTokenUsageCache = new Map();
 const claudeTokenUsageInflight = new Map();
@@ -2008,10 +2128,11 @@ export function claudeUsageForToken(token, opts) {
         return Promise.resolve(null);
     const now = Date.now();
     const cached = claudeTokenUsageCache.get(t);
-    if (cached && !opts?.force) {
-        const ttl = cached.ok
-            ? (opts?.fresh ? TOKEN_USAGE_FRESH_TTL_MS : TOKEN_USAGE_OK_TTL_MS)
-            : TOKEN_USAGE_RETRY_TTL_MS;
+    if (cached) {
+        const ttl = opts?.force ? TOKEN_USAGE_FORCE_FLOOR_MS
+            : cached.ok
+                ? (opts?.fresh ? TOKEN_USAGE_FRESH_TTL_MS : TOKEN_USAGE_OK_TTL_MS)
+                : TOKEN_USAGE_RETRY_TTL_MS;
         if (now - cached.at < ttl)
             return Promise.resolve(cached.value);
     }

package/dist/agent/drivers/codex.js

@@ -1882,22 +1882,61 @@ function getCodexStateDbPath(home) {
         return null;
     }
 }
-function codexUsageFromRateLimits(rateLimits, capturedAt, source) {
+// Account status across both codex rate-limit generations: newer payloads report
+// `rate_limit_reached_type` (a string names the tripped window, null means not limited); older
+// ones used `limit_reached` / `allowed` booleans, which no longer exist on current codex.
+function codexRateLimitStatus(rateLimits) {
+    const reachedType = rateLimits.rate_limit_reached_type ?? rateLimits.rateLimitReachedType;
+    if (typeof reachedType === 'string' && reachedType)
+        return 'limit_reached';
+    if (rateLimits.limit_reached === true)
+        return 'limit_reached';
+    if (rateLimits.allowed === true)
+        return 'allowed';
+    if ('rate_limit_reached_type' in rateLimits || 'rateLimitReachedType' in rateLimits)
+        return 'allowed';
+    return null;
+}
+// Compact credits description ("unlimited" or a balance figure); null when the credits block
+// carries no user-meaningful number (hasCredits alone says nothing about remaining spend).
+function codexCreditsSummary(credits) {
+    if (!credits || typeof credits !== 'object')
+        return null;
+    if (credits.unlimited === true)
+        return 'unlimited';
+    const balance = credits.balance;
+    if (typeof balance === 'number' && Number.isFinite(balance))
+        return String(balance);
+    if (typeof balance === 'string' && balance)
+        return balance;
+    return null;
+}
+export function codexUsageFromRateLimits(rateLimits, capturedAt, source) {
     if (!rateLimits || typeof rateLimits !== 'object')
         return null;
     const windows = [
         usageWindowFromRateLimit('Primary', rateLimits.primary),
         usageWindowFromRateLimit('Secondary', rateLimits.secondary),
     ].filter((v) => !!v);
+    // Team plans may carry a per-member limit alongside the shared one.
+    const individual = rateLimits.individual_limit;
+    if (individual && typeof individual === 'object') {
+        for (const [fallback, entry] of [['Primary', individual.primary], ['Secondary', individual.secondary]]) {
+            const w = usageWindowFromRateLimit(fallback, entry);
+            if (w)
+                windows.push({ ...w, label: `${w.label} (individual)` });
+        }
+    }
     if (!windows.length)
         return null;
-    let status = null;
-    if (rateLimits.limit_reached === true)
-        status = 'limit_reached';
-    else if (rateLimits.allowed === true)
-        status = 'allowed';
-    return { ok: true, agent: 'codex', source, capturedAt, status, windows, error: null };
+    return {
+        ok: true, agent: 'codex', source, capturedAt, status: codexRateLimitStatus(rateLimits), windows, error: null,
+        planType: typeof rateLimits.plan_type === 'string' && rateLimits.plan_type ? rateLimits.plan_type : null,
+        creditsSummary: codexCreditsSummary(rateLimits.credits),
+    };
 }
+// Legacy source: codex >= 0.142 dropped the `logs` table from the state db entirely, so this
+// returns null there (sqlite3 errors out) and callers fall through to the session-history scan.
 function getCodexUsageFromStateDb(home) {
     const dbPath = getCodexStateDbPath(home);
     if (!dbPath)
@@ -1985,30 +2024,74 @@ function parseRateLimitWindow(label, rl) {
         status: null,
     };
 }
+// Windows for one camelCase rate-limit block from the app-server: primary / secondary plus the
+// per-member individualLimit team plans may carry. `prefix` disambiguates window labels when an
+// account reports multiple limit ids.
+function codexLiveWindows(rl, prefix) {
+    const windows = [];
+    const push = (w, suffix = '') => {
+        if (w)
+            windows.push({ ...w, label: `${prefix}${w.label}${suffix}` });
+    };
+    push(parseRateLimitWindow('Primary', rl.primary));
+    push(parseRateLimitWindow('Secondary', rl.secondary));
+    const individual = rl.individualLimit;
+    if (individual && typeof individual === 'object') {
+        push(parseRateLimitWindow('Primary', individual.primary), ' (individual)');
+        push(parseRateLimitWindow('Secondary', individual.secondary), ' (individual)');
+    }
+    return windows;
+}
+// Pure parse of an `account/rateLimits/read` result. Prefers `rateLimitsByLimitId` (accounts can
+// carry several limits) over the flat `rateLimits`; also lifts planType, credits and
+// `rateLimitResetCredits` (limit-reset coupons) which the previous parse dropped entirely.
+export function codexUsageFromLiveRateLimitsResult(result, capturedAt) {
+    const byId = result?.rateLimitsByLimitId && typeof result.rateLimitsByLimitId === 'object'
+        ? Object.entries(result.rateLimitsByLimitId).filter(([, v]) => v && typeof v === 'object')
+        : [];
+    const blocks = byId.length ? byId
+        : result?.rateLimits && typeof result.rateLimits === 'object' ? [['', result.rateLimits]] : [];
+    if (!blocks.length)
+        return null;
+    const windows = [];
+    let status = null;
+    let planType = null;
+    let creditsSummary = null;
+    const multi = blocks.length > 1;
+    for (const [limitId, rl] of blocks) {
+        const name = typeof rl.limitName === 'string' && rl.limitName ? rl.limitName : limitId;
+        windows.push(...codexLiveWindows(rl, multi && name ? `${name} ` : ''));
+        const blockStatus = codexRateLimitStatus(rl);
+        if (blockStatus === 'limit_reached')
+            status = 'limit_reached';
+        else if (blockStatus && status == null)
+            status = blockStatus;
+        if (!planType && typeof rl.planType === 'string' && rl.planType)
+            planType = rl.planType;
+        if (!creditsSummary)
+            creditsSummary = codexCreditsSummary(rl.credits);
+    }
+    const resetCreditsRaw = Number(result?.rateLimitResetCredits?.availableCount);
+    return {
+        ok: windows.length > 0, agent: 'codex', source: 'app-server-live', capturedAt, status,
+        windows, error: windows.length > 0 ? null : 'No rate limit windows.',
+        planType, creditsSummary,
+        resetCreditsAvailable: Number.isFinite(resetCreditsRaw) ? resetCreditsRaw : null,
+    };
+}
 export async function getCodexUsageLive() {
     const home = getHome();
+    // The state-db `logs` table no longer exists on codex >= 0.142, so the offline fallback must
+    // also try the session-history scan.
+    const fallback = (reason) => getCodexUsageFromStateDb(home) || getCodexUsageFromSessions(home) || emptyUsage('codex', reason);
     const srv = getSharedServer();
-    if (!(await srv.ensureRunning())) {
-        return getCodexUsageFromStateDb(home) || emptyUsage('codex', 'Failed to start codex app-server.');
-    }
+    if (!(await srv.ensureRunning()))
+        return fallback('Failed to start codex app-server.');
     const resp = await srv.call('account/rateLimits/read');
     if (resp.error)
-        return getCodexUsageFromStateDb(home) || emptyUsage('codex', resp.error.message || 'account/rateLimits/read failed');
-    const rl = resp.result?.rateLimits;
-    if (!rl)
-        return getCodexUsageFromStateDb(home) || emptyUsage('codex', 'No rate limits in response.');
-    const capturedAt = new Date().toISOString();
-    const windows = [];
-    const w1 = parseRateLimitWindow('Primary', rl.primary);
-    if (w1)
-        windows.push(w1);
-    const w2 = parseRateLimitWindow('Secondary', rl.secondary);
-    if (w2)
-        windows.push(w2);
-    return {
-        ok: windows.length > 0, agent: 'codex', source: 'app-server-live', capturedAt, status: null,
-        windows, error: windows.length > 0 ? null : 'No rate limit windows.',
-    };
+        return fallback(resp.error.message || 'account/rateLimits/read failed');
+    const parsed = codexUsageFromLiveRateLimitsResult(resp.result, new Date().toISOString());
+    return parsed ?? fallback('No rate limits in response.');
 }
 class CodexDriver {
     id = 'codex';

package/dist/agent/kernel-bridge.js

@@ -140,6 +140,30 @@ export function kernelUsageToResultFields(u) {
         contextPercent: u?.contextPercent ?? null,
     };
 }
+// How a kernel DriverResult presents as the finished message + incomplete flag. Pure +
+// exported for regression testing. The load-bearing rule: a turn whose closing reply never
+// arrived (stopReason 'stalled'/'truncated') must SAY so even when mid-turn narration exists —
+// substituting a note only for empty text is exactly what let those endings read as normal
+// answers that stop mid-sentence, with nothing marking the swallow.
+export function composeKernelFinalPresentation(input) {
+    const endNote = input.stopReason === 'stalled'
+        ? 'The turn stopped responding after tool use without producing a reply (the model or provider may have stalled). Send any message to continue.'
+        : input.stopReason === 'truncated'
+            ? 'The reply ended after the last tool call without a closing message (the model returned an empty final response). Send any message to continue.'
+            : null;
+    // Empty-text fallback (mirrors the legacy driver): a clean turn with no prose reads
+    // "(no textual response)", not "(no output)" (which the kernel path used to show for every
+    // textless turn — including a background-launch turn that intentionally ends without prose).
+    // A turn that settled while work keeps running in the background gets an explicit note.
+    const message = input.bodyText
+        ? (endNote ? `${input.bodyText}\n\n⚠️ ${endNote}` : input.bodyText)
+        : input.finalError
+            || endNote
+            || (input.stopReason === 'background'
+                ? 'Work is now running in the background — I’ll report back here once it finishes. (Send any message to check on it.)'
+                : input.ok ? '(no textual response)' : '(no output)');
+    return { message, incomplete: !input.ok || !!endNote };
+}
 let _kernel = null;
 export async function loadKernel() {
     if (_kernel)
@@ -256,19 +280,15 @@ export async function kernelStream(opts) {
         ? (humanizeCodexError(result.error) ?? result.error)
         : (result.error ?? null);
     const usageFields = kernelUsageToResultFields(result.usage || snapshot.usage || {});
+    const presentation = composeKernelFinalPresentation({
+        bodyText: (result.text || snapshot.text || '').trim(),
+        finalError,
+        ok: !!result.ok,
+        stopReason: result.stopReason ?? null,
+    });
     return {
         ok: !!result.ok,
-        // Empty-text fallback (mirrors the legacy driver): a clean turn with no prose reads
-        // "(no textual response)", not "(no output)" (which the kernel path used to show for every
-        // textless turn — including a background-launch turn that intentionally ends without prose).
-        // A turn that settled while work keeps running in the background gets an explicit note.
-        message: (result.text || snapshot.text || '').trim()
-            || finalError
-            || (result.stopReason === 'background'
-                ? 'Work is now running in the background — I’ll report back here once it finishes. (Send any message to check on it.)'
-                : result.stopReason === 'stalled'
-                    ? 'The turn stopped responding after tool use without producing a reply (the model or provider may have stalled). Send any message to continue.'
-                    : result.ok ? '(no textual response)' : '(no output)'),
+        message: presentation.message,
         thinking: (result.reasoning || snapshot.reasoning || '').trim() || null,
         plan: toPikiloomPlan(snapshot.plan),
         sessionId: finalSessionId,
@@ -280,7 +300,7 @@ export async function kernelStream(opts) {
         codexCumulative: null,
         error: finalError,
         stopReason: result.stopReason ?? null,
-        incomplete: !result.ok,
+        incomplete: presentation.incomplete,
         activity: snapshot.activity || null,
     };
 }

package/dist/agent/utils.js

@@ -414,7 +414,7 @@ export function normalizeUsageStatus(value) {
         return 'limit_reached';
     if (normalized.includes('warning') || normalized.includes('warn'))
         return 'warning';
-    if (normalized.includes('allowed') || normalized === 'ok' || normalized === 'healthy' || normalized === 'ready')
+    if (normalized.includes('allowed') || normalized === 'ok' || normalized === 'healthy' || normalized === 'ready' || normalized === 'normal')
         return 'allowed';
     return normalized;
 }
@@ -427,6 +427,10 @@ export function labelFromWindowMinutes(value, fallback) {
         return '5h';
     if (Math.abs(roundedMinutes - 10080) <= 5)
         return '7d';
+    // Codex team/enterprise plans meter on a monthly window reported as the average month
+    // length (365d/12 = 43800min = 730h) — without this branch it renders as "730h".
+    if (Math.abs(roundedMinutes - 43800) <= 60)
+        return '1mo';
     const roundedDays = Math.round(roundedMinutes / 1440);
     if (roundedDays >= 1 && Math.abs(roundedMinutes - roundedDays * 1440) <= 5)
         return `${roundedDays}d`;

package/dist/bot/bot.js

@@ -10,6 +10,7 @@ import { getDriver, hasDriver, allDriverIds, getDriverCapabilities } from '../ag
 import { resolveGuiIntegrationConfig } from '../agent/mcp/bridge.js';
 import { composeSessionToolPrompt } from '../agent/mcp/capabilities.js';
 import { terminateProcessTree } from '../core/process-control.js';
+import { appendTurnAudit } from '../core/turn-audit.js';
 import { expandTilde } from '../core/platform.js';
 import { VERSION } from '../core/version.js';
 import { buildHumanLoopResponse, createEmptyHumanLoopAnswer, currentHumanLoopQuestion, isHumanLoopAwaitingText, setHumanLoopOption, setHumanLoopText, skipHumanLoopQuestion, summarizeResolvedHumanLoopAnswers, } from './human-loop.js';
@@ -2114,7 +2115,23 @@ export class Bot {
             onCodexTurnReady,
             forkOf: extras?.forkOf,
         };
-        const result = await doStream(opts);
+        let result;
+        try {
+            result = await doStream(opts);
+        }
+        catch (e) {
+            appendTurnAudit({
+                agent: cs.agent, sessionId: cs.sessionId || null, ok: false, stopReason: 'exception',
+                incomplete: true, error: String(e?.message || e).slice(0, 500), promptPreview: prompt.slice(0, 120),
+            });
+            throw e;
+        }
+        appendTurnAudit({
+            agent: cs.agent, sessionId: result.sessionId || cs.sessionId || null,
+            ok: result.ok, stopReason: result.stopReason ?? null, incomplete: !!result.incomplete,
+            error: result.error ? String(result.error).slice(0, 500) : null,
+            elapsedS: result.elapsedS, model: result.model ?? resolvedModel, promptPreview: prompt.slice(0, 120),
+        });
         if (cs.agent === 'claude' && workflowEnabled && result.thinkingEffort) {
             result.thinkingEffort = 'ultra';
         }

package/dist/bot/render-shared.js

@@ -127,9 +127,22 @@ function formatUsageResetDuration(seconds) {
 function formatUsageWindowSummary(window, now) {
     const percent = window.usedPercent != null ? `${Math.round(window.usedPercent)}%` : null;
     const reset = formatUsageWindowReset(window, now);
-    const main = percent ? `${window.label} ${percent}` : window.label;
+    let main = percent ? `${window.label} ${percent}` : window.label;
+    if (window.detail)
+        main += ` (${window.detail})`;
     return reset ? `${main} (${reset})` : main;
 }
+// "plan team · limit resets ×1" — account-level metadata riding on the usage snapshot.
+function usageResultMetaParts(usage) {
+    const parts = [];
+    if (usage.planType)
+        parts.push(`plan ${usage.planType}`);
+    if (usage.creditsSummary)
+        parts.push(`credits ${usage.creditsSummary}`);
+    if (usage.resetCreditsAvailable)
+        parts.push(`limit resets ×${usage.resetCreditsAvailable}`);
+    return parts;
+}
 // Compact "5h 42% (reset 3h12m) · 7d 18% (reset 4d6h)" summary of a usage
 // snapshot, or a short reason when no quota numbers are available.
 export function formatUsageWindowsSummary(usage, now = Date.now()) {
@@ -139,7 +152,7 @@ export function formatUsageWindowsSummary(usage, now = Date.now()) {
         .filter(w => w.usedPercent != null)
         .map(w => formatUsageWindowSummary(w, now));
     if (parts.length)
-        return parts.join(' · ');
+        return [...parts, ...usageResultMetaParts(usage)].join(' · ');
     const resetWindow = usage.windows.find(w => usageWindowResetSeconds(w, now) != null);
     if (resetWindow) {
         const reset = formatUsageWindowReset(resetWindow, now);
@@ -148,13 +161,15 @@ export function formatUsageWindowsSummary(usage, now = Date.now()) {
     }
     return usage.status ? `status=${usage.status}` : 'no data';
 }
-// Freshest capturedAt (ISO string) across the given agents' usage and their accounts' usage, or
+// OLDEST capturedAt (ISO string) across the given agents' usage and their accounts' usage, or
 // null when none carry a timestamp. Mirrors the dashboard usage popover: every usage here is
-// probed in a single getUsageOverview pass, so one freshest stamp stands for the whole block
-// rather than repeating a near-identical timestamp per row. ISO-8601 UTC sorts lexically → max = latest.
-export function freshestUsageCapturedAt(agents) {
+// probed in a single getUsageOverview pass, so one stamp stands for the whole block — and it
+// must be the oldest row's time, not the freshest, so a row pinned at last-good by a failed /
+// rate-limited probe can't hide behind a sibling's fresh timestamp. ISO-8601 UTC sorts
+// lexically → min = oldest.
+export function oldestUsageCapturedAt(agents) {
     let best = null;
-    const consider = (iso) => { if (iso && (!best || iso > best))
+    const consider = (iso) => { if (iso && (!best || iso < best))
         best = iso; };
     for (const agent of agents) {
         consider(agent.usage?.capturedAt);
@@ -175,9 +190,10 @@ export function buildUsageOverviewLines(overview, now = Date.now()) {
         { text: '', bold: false },
         { text: 'Provider Usage', bold: true },
     ];
-    // Data-freshness stamp (restored to match the old /status line and the dashboard usage popover):
-    // one "Updated: X ago" for the whole block, from the freshest capturedAt across everything shown.
-    const capturedMs = Date.parse(freshestUsageCapturedAt(shown) ?? '');
+    // Data-freshness stamp (matches the dashboard usage popover): one "Updated: X ago" for the
+    // whole block, from the OLDEST capturedAt across everything shown — owning up to the most
+    // lagging row instead of advertising the freshest one.
+    const capturedMs = Date.parse(oldestUsageCapturedAt(shown) ?? '');
     if (Number.isFinite(capturedMs)) {
         lines.push({ text: `  Updated: ${fmtUptime(Math.max(0, now - capturedMs))} ago` });
     }

package/dist/core/turn-audit.js

@@ -0,0 +1,25 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getUserConfigPath } from './config/user-config.js';
+// Per-turn终态 audit trail. Prod runs with no disk logs at all, which turns every
+// swallowed-reply report into jsonl archaeology (reconstructing process lifetimes from MCP log
+// filenames). One JSON line per finished turn — how it ended, not what it said — is enough to
+// answer "who ended this turn and why" after the fact. Appends must never break a turn.
+const MAX_AUDIT_BYTES = 2 * 1024 * 1024;
+export function turnAuditPath() {
+    return path.join(path.dirname(getUserConfigPath()), 'logs', 'turn-audit.jsonl');
+}
+export function appendTurnAudit(entry) {
+    try {
+        const file = turnAuditPath();
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        try {
+            // Single-slot rotation: cap the live file, keep exactly one predecessor.
+            if (fs.statSync(file).size > MAX_AUDIT_BYTES)
+                fs.renameSync(file, `${file}.1`);
+        }
+        catch { /* no file yet */ }
+        fs.appendFileSync(file, JSON.stringify({ ts: new Date().toISOString(), ...entry }) + '\n');
+    }
+    catch { /* auditing is best-effort by design */ }
+}