@itookit/dsht 0.3.2 → 0.3.3

package/dist/ui/chat/status.d.ts

@@ -28,12 +28,12 @@ export interface StatusGroups {
     phase?: StatusSegment;
     /** How to stop the running turn. */
     stop?: StatusSegment;
-    /** This session's cost, scope-labelled so it cannot read as a share of the day total. */
-    session?: StatusSegment;
+    /** This session's cost with today's spend in parentheses, the only money the bar reports. */
+    cost?: StatusSegment;
     /** Context share, labelled because a bare percentage next to money reads as a budget. */
     context?: StatusSegment;
-    /** Today's cost across sessions; shown only where the width allows it. */
-    day?: StatusSegment;
+    /** The same share drawn as a bar; used only where it still fits beside every other kept group. */
+    contextBar?: StatusSegment;
     /** Model name without its reasoning effort, which is dropped first. */
     model?: StatusSegment;
     /** Reasoning effort, kept only while the model name still fits beside it. */
@@ -42,7 +42,19 @@ export interface StatusGroups {
     turns?: StatusSegment;
     /** Cumulative tokens. */
     tokens?: StatusSegment;
+    /** Cache-hit share of billed prompt input; it restates the token total, so the packer drops it first. */
+    cache?: StatusSegment;
 }
+/** Cache-hit share of billed prompt input, without reporting a partial hit as a full one.
+ *
+ * A prefix served from cache is what the provider charges least for, so the share is the reading
+ * that explains a cheap session; rounding it up to `100%` would instead claim that input stopped
+ * being billed, so the display gains precision until the number it shows is below a full hit.
+ * @param cacheReadTokens - Prompt tokens the provider served from cache.
+ * @param billedInputTokens - Uncached input, cache read and cache write, the prompt tokens that were billed.
+ * @returns Percentage text, or undefined when no prompt input has been billed yet.
+ */
+export declare function cacheHitText(cacheReadTokens: number | undefined, billedInputTokens: number | undefined): string | undefined;
 /** Elapsed time as `m:ss`, adding hours only when they exist.
  * @param milliseconds - Duration to format.
  * @returns Clock text without a leading zero on minutes.

package/dist/ui/chat/status.js

@@ -51,6 +51,27 @@ export function metricLines(values, defaultModel, running) {
         `In ${compact(buckets[0])} · Out ${compact(buckets[1])} · Cache ${compact(buckets[2])}/${compact(buckets[3])}`,
     ];
 }
+/** Cache-hit share of billed prompt input, without reporting a partial hit as a full one.
+ *
+ * A prefix served from cache is what the provider charges least for, so the share is the reading
+ * that explains a cheap session; rounding it up to `100%` would instead claim that input stopped
+ * being billed, so the display gains precision until the number it shows is below a full hit.
+ * @param cacheReadTokens - Prompt tokens the provider served from cache.
+ * @param billedInputTokens - Uncached input, cache read and cache write, the prompt tokens that were billed.
+ * @returns Percentage text, or undefined when no prompt input has been billed yet.
+ */
+export function cacheHitText(cacheReadTokens, billedInputTokens) {
+    if (cacheReadTokens === undefined || billedInputTokens === undefined || billedInputTokens <= 0)
+        return undefined;
+    if (cacheReadTokens >= billedInputTokens)
+        return '100%';
+    for (let digits = 0; digits <= 3; digits++) {
+        const text = (cacheReadTokens / billedInputTokens * 100).toFixed(digits);
+        if (Number(text) < 100)
+            return `${text}%`;
+    }
+    return '<100%';
+}
 /** Elapsed time as `m:ss`, adding hours only when they exist.
  * @param milliseconds - Duration to format.
  * @returns Clock text without a leading zero on minutes.
@@ -84,23 +105,61 @@ export function compactStatusRows(groups, width) {
         return [];
     // Remote text reaches this bar, so every group is stripped of control characters before packing.
     const clean = (group) => group === undefined ? undefined : { ...group, text: safeText(group.text).replace(/[\r\n\t]+/g, ' ') };
-    groups = { state: clean(groups.state), phase: clean(groups.phase), stop: clean(groups.stop), session: clean(groups.session),
-        context: clean(groups.context), day: clean(groups.day), model: clean(groups.model), effort: clean(groups.effort),
-        turns: clean(groups.turns), tokens: clean(groups.tokens) };
+    groups = { state: clean(groups.state), phase: clean(groups.phase), stop: clean(groups.stop), cost: clean(groups.cost),
+        context: clean(groups.context), contextBar: clean(groups.contextBar),
+        model: clean(groups.model), effort: clean(groups.effort), turns: clean(groups.turns), tokens: clean(groups.tokens),
+        cache: clean(groups.cache) };
     const cluster = [groups.state, groups.phase, groups.stop].filter(Boolean);
-    const rest = [groups.session, groups.context, groups.day, groups.model, groups.effort, groups.turns, groups.tokens].filter(Boolean);
-    // One row while enough of the sequence fits; each step drops the least valuable group first.
-    // The cost is never dropped, only moved to the second row, so the search stops above it.
-    const floor = groups.session === undefined ? 0 : 1;
-    for (let keep = rest.length; keep >= floor; keep--) {
-        const row = pack(cluster, rest.slice(0, keep));
+    // The cost is one group carrying two scopes: this session's spend, with today's in parentheses.
+    // Display order reads the model beside its effort and the money after the share it sits next to;
+    // keep order is by value, so a narrow bar holds the cost and the share before a model it cannot
+    // show, and the cache share goes before the token total it restates.
+    const order = [groups.model, groups.effort, groups.context, groups.cost, groups.turns, groups.tokens, groups.cache].filter(Boolean);
+    const rank = [groups.cost, groups.context, groups.model, groups.effort, groups.turns, groups.tokens, groups.cache].filter(Boolean);
+    // One row while enough of the sequence fits; each step drops the least valuable group first. The
+    // cost is never dropped while a row can hold it, only moved to the second one, so the search stops
+    // above it; a second row that cannot hold even the cost is not opened.
+    const floor = groups.cost === undefined ? 0 : 1;
+    for (let keep = rank.length; keep >= floor; keep--) {
+        const kept = new Set(rank.slice(0, keep));
+        const row = pack(cluster, order.filter(group => kept.has(group)));
         if (measure(row) <= width)
-            return [row];
+            return [keep > floor ? widen(row, groups, width) : row];
     }
-    if (groups.session === undefined && measure(pack(cluster, [])) > width)
+    if (groups.cost === undefined && measure(pack(cluster, [])) > width)
         return [fitCluster(cluster, width)];
     // Not even the state cluster and the cost share a row, so the cost opens the second one.
-    return [fitCluster(cluster, width), packGreedy(rest, width)];
+    const first = fitCluster(cluster, width);
+    const second = widen(packGreedy(rank, width), groups, width);
+    return second.length === 0 ? [first] : [first, second];
+}
+/** Offer the clearer reading of a group already on the row: the ten-cell context share.
+ *
+ * The bar is a rendering of the same share the plain percentage reports, not an additional group, so
+ * it never displaces a group that fits: below the width that holds it, the plain form keeps its place.
+ * @param row - A packed row that already fits.
+ * @param groups - Cleaned groups, used to find the pair by identity.
+ * @param width - Available terminal columns.
+ * @returns The row with the reading that fits.
+ */
+function widen(row, groups, width) {
+    return swap(row, groups.context, groups.contextBar, width);
+}
+/** Replace one group with its fuller rendering where the whole row still fits.
+ * @param row - A packed row that already fits.
+ * @param from - Group to replace, matched by identity.
+ * @param to - Fuller rendering of that group.
+ * @param width - Available terminal columns.
+ * @returns The row with the replacement, or the row unchanged where it does not fit.
+ */
+function swap(row, from, to, width) {
+    if (from === undefined || to === undefined)
+        return row;
+    const index = row.indexOf(from);
+    if (index < 0)
+        return row;
+    const replaced = [...row.slice(0, index), to, ...row.slice(index + 1)];
+    return measure(replaced) <= width ? replaced : row;
 }
 /** Fit the state cluster, dropping the phase and then the stop hint before truncating the state.
  * @param cluster - State, phase and stop hint in that order.
@@ -166,9 +225,11 @@ export const StatusBar = memo(function StatusBar({ controller, expanded = false,
     const since = controller.workingSince;
     useEffect(() => {
         setNow(Date.now());
-        if (!running || paused)
+        if (paused)
             return;
-        const timer = setInterval(() => setNow(Date.now()), 1000);
+        // An idle bar still re-reads the clock, so a day rollover reaches the cost it reports without
+        // waiting for an unrelated render; a running bar keeps its per-second clock.
+        const timer = setInterval(() => setNow(Date.now()), running ? 1000 : 60_000);
         return () => clearInterval(timer);
     }, [running, since, paused]);
     const state = controller.state;
@@ -176,7 +237,7 @@ export const StatusBar = memo(function StatusBar({ controller, expanded = false,
     const view = controller.telemetry.view(state.sessionId);
     const costs = controller.costs;
     const sessionCost = costs?.hasSession(state.sessionId) ? costText(costs.total(state.sessionId)) : '?';
-    const todayCost = costs ? costText(costs.total(undefined, 1, Date.now())) : '?';
+    const todayCost = costs ? costText(costs.today()) : '?';
     // `*` belongs to costText alone; incomplete coverage is a separate degradation, reported by `!`.
     const coverage = costs?.coverage ?? 'complete';
     const label = workspace ? `${workspace.title} · ${workspace.path}` : 'none selected';
@@ -192,6 +253,10 @@ export const StatusBar = memo(function StatusBar({ controller, expanded = false,
         const usage = record(view.values.tokenUsage);
         const buckets = [usage.uncachedInputTokens, usage.outputTokens, usage.cacheReadTokens, usage.cacheWriteTokens].map(numeric);
         const total = buckets.every(value => value !== undefined) ? buckets.reduce((a, b) => a + b, 0) : undefined;
+        // Billed prompt input is the three disjoint prompt buckets; a provider that reports no cache
+        // write has not billed one, which is how the ledger reads the same projection.
+        const billed = buckets[0] === undefined || buckets[2] === undefined ? undefined : buckets[0] + buckets[2] + (buckets[3] ?? 0);
+        const hit = cacheHitText(buckets[2], billed);
         const compactCount = (value) => value === undefined ? '?' : compactNumber.format(value);
         const phase = state.transcript.livePhase;
         const clock = running && since !== undefined ? ` ${clockText(now - since)}` : '';
@@ -207,23 +272,33 @@ export const StatusBar = memo(function StatusBar({ controller, expanded = false,
                 : pauseReason !== undefined
                     ? { text: `⏸ ${pauseReason}${clock}`, color: theme.colors.muted }
                     : running ? { text: `◐${clock}`, color: theme.status.working } : { text: '● Ready', color: theme.status.ready };
-        // The marker names the scope it belongs to: a subtotal is inexact when a record could not be
-        // priced, when it is only estimated, or when the scan has not covered every session yet.
+        // One marker covers both scopes, because either an unpriceable record or a scan that has not
+        // covered every session makes the pair inexact as a reading.
         const inexact = coverage !== 'complete';
-        const money = (value) => `¥${value.amount.toFixed(2)}${value.unknown || value.estimated || inexact ? '*' : ''}`;
+        const money = (session, today) => `¥: ${session === undefined ? '?' : session.amount.toFixed(2)}(${today.amount.toFixed(2)})${session?.unknown || today.unknown || inexact ? '*' : ''}`;
+        const todayTotal = costs?.today();
         const sessionTotal = costs !== undefined && costs.hasSession(state.sessionId) ? costs.total(state.sessionId) : undefined;
+        const contextColor = percent === undefined ? theme.status.usage
+            : percent >= 95 ? theme.status.critical : percent >= 80 ? theme.status.warning : theme.status.context;
+        // Ten cells resolve context to tenths, the same resolution the percentage beside them reports.
+        const cells = percent === undefined ? 0 : Math.round(percent / 10);
         const groups = {
             state: stateToken,
-            ...(phaseLabel === undefined || pauseReason !== undefined ? {} : { phase: { text: phaseLabel } }),
+            // A paused bar keeps the phase: the reason already says why the clock stopped, and dropping the
+            // running tool would leave the one question this bar exists to answer unanswered. A ready bar
+            // has none: the transcript keeps the last event it saw, and only the host knows the turn ended.
+            ...(phaseLabel === undefined || !running ? {} : { phase: { text: phaseLabel } }),
             ...(running && pauseReason === undefined ? { stop: { text: '^C' } } : {}),
-            ...(sessionTotal === undefined ? {} : { session: { text: `S${money(sessionTotal)}`, color: theme.status.cost } }),
-            ...(percent === undefined ? {} : { context: { text: `ctx ${percent}%`,
-                    color: percent >= 95 ? theme.status.critical : percent >= 80 ? theme.status.warning : theme.status.context } }),
-            ...(costs === undefined ? {} : { day: { text: `D${money(costs.total(undefined, 1, Date.now()))}`, color: theme.status.cost } }),
+            ...(todayTotal === undefined ? {} : { cost: { text: money(sessionTotal, todayTotal), color: theme.status.cost } }),
+            ...(percent === undefined ? {} : {
+                context: { text: `ctx ${percent}%`, color: contextColor },
+                contextBar: { text: `ctx: ${'█'.repeat(cells)}${'░'.repeat(10 - cells)} ~${percent}%`, color: contextColor }
+            }),
             ...(model === undefined ? {} : { model: { text: model, color: theme.status.model } }),
             ...(model === undefined || effort === undefined ? {} : { effort: { text: effort, color: theme.status.model } }),
             ...(numeric(record(view.values.sessionStats).turns) === undefined ? {} : { turns: { text: `${count(numeric(record(view.values.sessionStats).turns))} turns`, color: theme.status.usage } }),
             ...(total === undefined ? {} : { tokens: { text: `${compactCount(total)} tok`, color: theme.status.usage } }),
+            ...(hit === undefined ? {} : { cache: { text: `hit ${hit}`, color: theme.status.usage } }),
         };
         const rows = compactStatusRows(groups, width ?? Math.max(1, (stdout.columns ?? 80) - 2));
         if (rows.length !== reported) {
@@ -248,7 +323,7 @@ const StatusDetails = memo(function StatusDetails({ controller, theme, width, no
     const view = controller.telemetry.view(state.sessionId);
     const costs = controller.costs;
     const sessionCost = costs?.hasSession(state.sessionId) ? costText(costs.total(state.sessionId)) : '?';
-    const todayCost = costs ? costText(costs.total(undefined, 1, Date.now())) : '?';
+    const todayCost = costs ? costText(costs.today()) : '?';
     // `*` belongs to costText alone; incomplete coverage is a separate degradation, reported by `!`.
     const coverage = costs?.coverage ?? 'complete';
     const label = workspace ? `${workspace.title} · ${workspace.path}` : 'none selected';
@@ -307,5 +382,5 @@ function modelName(value) {
     return safeText(`${model.provider}/${model.model}${typeof model.reasoningEffort === 'string' ? ` (${model.reasoningEffort})` : ''}`);
 }
 function compactCost(total) {
-    return `~¥${total.amount.toFixed(2)}${total.unknown || total.estimated ? '*' : ''}`;
+    return `~¥${total.amount.toFixed(2)}${total.unknown ? '*' : ''}`;
 }

package/dist/ui/commands/parse.d.ts

@@ -62,6 +62,9 @@ export type Submission = {
 } | {
     kind: 'exportHtml';
     destination?: string;
+} | {
+    kind: 'coredump';
+    tag?: string;
 } | {
     kind: 'answer';
     text: string;

package/dist/ui/commands/parse.js

@@ -109,6 +109,11 @@ export function classifySubmission(raw, context) {
         const destination = value.slice(12).trim().replace(/^(["'])(.*)\1$/, '$2');
         return { kind: 'exportHtml', ...(destination ? { destination } : {}) };
     }
+    if (/^\/coredump(?:\s|$)/.test(value)) {
+        // A diagnostic of this client's own heap needs neither a session nor a connected host.
+        const tag = value.slice(9).trim().replace(/^(["'])(.*)\1$/, '$2');
+        return { kind: 'coredump', ...(tag ? { tag } : {}) };
+    }
     if (context.question)
         return { kind: 'answer', text: value };
     if (context.pending)

package/dist/ui/commands/registry.js

@@ -21,6 +21,7 @@ export const COMMAND_HINTS = [
     { command: '/feedback', usage: 'text', description: 'Record feedback about the session' },
     { command: '/export', usage: '[local.zip]', description: 'Save the session log ZIP to a new local file' },
     { command: '/export-html', usage: '[local.html]', description: 'Save loaded conversation with diagrams and math as offline HTML' },
+    { command: '/coredump', usage: '[tag]', description: 'Write a V8 heap snapshot for memory diagnosis' },
     { command: '/allow', description: 'Approve the pending request once' },
     { command: '/deny', description: 'Reject the pending request' },
     { command: '/status', description: 'Show full session status details' },

package/dist/ui/dialogs/cost.js

@@ -16,10 +16,10 @@ export function CostPanel({ controller }) {
     const id = controller.state.sessionId;
     const rows = [
         ['Session', id && costs.hasSession(id) ? costs.total(id) : undefined],
-        ['Today', costs.total(undefined, 1)], ['3 days (today + previous 2)', costs.total(undefined, 3)],
+        ['Today', costs.today()],
     ];
-    return _jsxs(Box, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Cost \u00B7 CNY estimate \u00B7 Asia/Shanghai \u00B7 /cost closes" }), rows.map(([label, total]) => _jsxs(Text, { children: [label, ": ", total ? `${costText(total)} · ${total.unknown} unpriced${total.estimated ? ` · ${total.estimated} estimated` : ''} / ${total.records} requests` : '?'] }, label)), _jsx(Text, { dimColor: true, children: costs.scanning ? 'Refreshing all visible sessions…'
+    return _jsxs(Box, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Cost \u00B7 CNY estimate \u00B7 Asia/Shanghai \u00B7 /cost closes" }), rows.map(([label, total]) => _jsxs(Text, { children: [label, ": ", total ? `${costText(total)} · ${total.unknown} unpriced / ${total.records} requests` : '?'] }, label)), _jsx(Text, { dimColor: true, children: costs.scanning ? 'Refreshing all visible sessions…'
                     : costs.coverage === 'partial' ? 'Partial totals · awaiting a complete scan'
                         : costs.scannedAt ? `Last refresh: ${new Date(costs.scannedAt).toISOString()}`
-                            : 'Cached totals from the previous run' }), _jsx(Text, { dimColor: true, children: "Recorded settlement time determines tariff; * means a subtotal is not exact. Provider invoices are authoritative." }), costs.error && _jsxs(Text, { color: theme.colors.context, children: ["Partial totals: ", safeText(costs.error)] }), costs.missing().slice(0, 6).map(reason => _jsx(Text, { color: theme.colors.context, children: safeText(reason) }, reason))] });
+                            : 'Cached totals from the previous run' }), costs.customPrices && _jsx(Text, { color: theme.colors.context, children: "Rates come from prices.json, not the shipped table." }), _jsx(Text, { dimColor: true, children: "Recorded settlement time determines tariff; * means a subtotal is not exact. Provider invoices are authoritative." }), costs.error && _jsxs(Text, { color: theme.colors.context, children: ["Partial totals: ", safeText(costs.error)] }), costs.missing().slice(0, 6).map(reason => _jsx(Text, { color: theme.colors.context, children: safeText(reason) }, reason))] });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itookit/dsht",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "type": "module",
   "description": "Remote-first TUI for DeepSeek Harness with SSH-friendly mobile access and request-level cost tracking",
   "engines": {
@@ -26,7 +26,7 @@
   },
   "scripts": {
     "start": "tsx src/cli/index.tsx",
-    "start:profile": "NODE_OPTIONS=\"--expose-gc --heapsnapshot-signal=SIGUSR2\" tsx src/cli/index.tsx",
+    "start:profile": "node -e \"require('node:fs').mkdirSync('.diagnostics',{recursive:true})\" && NODE_OPTIONS=\"--expose-gc --heapsnapshot-signal=SIGUSR2 --diagnostic-dir=.diagnostics\" tsx src/cli/index.tsx",
     "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
     "typecheck": "tsc --noEmit && tsc -p tsconfig.tests.json",
     "test": "tsx --test tests/*/*.test.ts tests/*/*.test.tsx",