npm - pikiloom - Versions diffs - 0.4.52 → 0.4.54 - Mend

pikiloom 0.4.52 → 0.4.54

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (30) hide show

package/dashboard/dist/assets/{shared-CCX1F8yo.js → shared-CpIdR9QI.js} RENAMED Viewed

	@@ -1 +1 @@
1	- import{j as s}from"./react-vendor-C7Sl8SE7.js";import{O as t,m as i,S as a}from"./index-~~FePQwr1a~~.js";function o({primary:e,secondary:l,tertiary:n}){return s.jsxs("div",{className:"flex flex-col gap-2 pt-1 sm:flex-row sm:flex-wrap sm:items-center sm:justify-between",children:[s.jsxs("div",{className:"flex flex-wrap items-center gap-2",children:[e&&s.jsxs(i,{tone:"primary",onClick:e.onClick,disabled:e.disabled,children:[e.loading&&s.jsx(a,{}),e.label]}),l&&s.jsx(i,{tone:"secondary",onClick:l.onClick,disabled:l.disabled,children:l.label})]}),n&&s.jsx("div",{className:"text-xs leading-relaxed text-fg-4",children:n})]})}function c({children:e,className:l}){return s.jsx(t,{padding:"md",elevation:"flat",className:l,children:e})}export{o as A,c as S};
1	+ import{j as s}from"./react-vendor-C7Sl8SE7.js";import{O as t,m as i,S as a}from"./index-89WIHUvA.js";function o({primary:e,secondary:l,tertiary:n}){return s.jsxs("div",{className:"flex flex-col gap-2 pt-1 sm:flex-row sm:flex-wrap sm:items-center sm:justify-between",children:[s.jsxs("div",{className:"flex flex-wrap items-center gap-2",children:[e&&s.jsxs(i,{tone:"primary",onClick:e.onClick,disabled:e.disabled,children:[e.loading&&s.jsx(a,{}),e.label]}),l&&s.jsx(i,{tone:"secondary",onClick:l.onClick,disabled:l.disabled,children:l.label})]}),n&&s.jsx("div",{className:"text-xs leading-relaxed text-fg-4",children:n})]})}function c({children:e,className:l}){return s.jsx(t,{padding:"md",elevation:"flat",className:l,children:e})}export{o as A,c as S};

package/dashboard/dist/index.html CHANGED Viewed

@@ -6,10 +6,10 @@
   <link rel="icon" type="image/png" href="/logo.png">
   <title>Pikiloom</title>
   <link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600;700&family=Geist+Mono:wght@400;500&display=swap" rel="stylesheet">
-  <script type="module" crossorigin src="/assets/index-FePQwr1a.js"></script>
+  <script type="module" crossorigin src="/assets/index-89WIHUvA.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/react-vendor-C7Sl8SE7.js">
   <link rel="modulepreload" crossorigin href="/assets/router-DHISdpPk.js">
-  <link rel="stylesheet" crossorigin href="/assets/index-BcPBJtn2.css">
+  <link rel="stylesheet" crossorigin href="/assets/index-BQ_R1F_G.css">
 </head>
 <body>
   <div id="root"></div>

package/dist/agent/drivers/claude.js CHANGED Viewed

@@ -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'
@@ -1892,6 +2005,13 @@ async function fetchClaudeUsageFromOAuth(tokenOverride) {
 // 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.
+//
+// The 429 budget is PER ACCOUNT and shared with every other Claude Code process on the machine,
+// so the endpoint can stay rate-limited for long stretches through no fault of our cadence. When
+// it fails and there is no last-good to serve, degrade to the inference-header probe (the same
+// channel setup-token accounts use): coarser — 5h/7d only, no Extra spend or per-model weekly —
+// but reliably available, so the native row never goes blank. A later successful oauth read
+// replaces it with the full-fidelity snapshot.
 const NATIVE_USAGE_FRESH_TTL_MS = 15_000;
 const NATIVE_USAGE_RETRY_TTL_MS = 60_000;
 const NATIVE_USAGE_FORCE_FLOOR_MS = 3_000;
@@ -1909,20 +2029,31 @@ export function claudeNativeUsage(opts) {
     }
     if (claudeNativeUsageLive.inflight)
         return claudeNativeUsageLive.inflight;
-    const p = fetchClaudeUsageFromOAuth()
-        .then(fresh => {
-        if (fresh) {
-            claudeUsageCache.lastGood = fresh;
+    const p = (async () => {
+        let result = await fetchClaudeUsageFromOAuth();
+        const oauthOk = !!result;
+        // Degrade to the header probe when oauth fails and there is no full-fidelity snapshot to
+        // serve — including when last-good is itself a header-probe result (keep it refreshing
+        // through a long 429 stretch instead of freezing on the first degraded read).
+        if (!result && (!claudeUsageCache.lastGood || claudeUsageCache.lastGood.source === 'ratelimit-headers')) {
+            const token = getClaudeOAuthToken();
+            if (token)
+                result = await claudeUsageForToken(token, opts);
+            agentLog(`[usage] native oauth usage read failed; header-probe fallback -> ${result ? result.source : 'null'}`);
+        }
+        if (result) {
+            claudeUsageCache.lastGood = result;
             claudeUsageCache.lastAttemptAt = Date.now();
             claudeNativeUsageLive.at = Date.now();
-            claudeNativeUsageLive.failedAt = 0;
+            // A header-probe fallback is a degraded read: keep failedAt so the oauth endpoint is
+            // retried on the normal backoff cadence instead of idling out the full ok-TTL.
+            claudeNativeUsageLive.failedAt = oauthOk ? 0 : Date.now();
         }
         else {
             claudeNativeUsageLive.failedAt = Date.now();
         }
-        return fresh ?? claudeUsageCache.lastGood;
-    })
-        .finally(() => { claudeNativeUsageLive.inflight = null; });
+        return result ?? claudeUsageCache.lastGood;
+    })().finally(() => { claudeNativeUsageLive.inflight = null; });
     claudeNativeUsageLive.inflight = p;
     return p;
 }

package/dist/agent/drivers/codex.js CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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);

package/dist/core/turn-audit.js ADDED Viewed

@@ -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 */ }
+}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "pikiloom",
-  "version": "0.4.52",
+  "version": "0.4.54",
   "description": "Put the world's smartest AI agents in your pocket. Command local Claude & Gemini via IM. | 让最好用的 IM 变成你电脑上的顶级 Agent 控制台",
   "type": "module",
   "bin": {

package/packages/kernel/dist/drivers/claude.d.ts CHANGED Viewed

@@ -35,11 +35,14 @@ export declare function handleClaudeEvent(ev: any, s: any, emit: (e: DriverEvent
 export declare function claudeBgHoldCapMs(): number;
 export declare function claudeBgSettleQuietMs(): number;
 export declare function claudeModelStallMs(): number;
+export declare const CLAUDE_TRUNCATED_RECOVERY_PROMPT: string;
+export declare function claudeTruncatedRecoveryEnabled(): boolean;
 export declare function claudeUserEventHasToolResult(ev: any): boolean;
 export declare function isTerminalTaskStatus(status: unknown): boolean;
 export declare function trackClaudeBackgroundTask(ev: any, s: any): void;
 export declare function markClaudeTaskNotificationTerminal(content: any, s: any): void;
 export declare function pendingClaudeBackgroundTasks(s: any): number;
+export declare function claudeTurnEndedDangling(s: any): boolean;
 export type ClaudeResultSettleDecision = 'settle' | 'hold' | 'quiet-settle';
 export declare function decideClaudeResultSettle(input: {
     hasError: boolean;