dsh-task-time-cost 0.0.0-stage → 0.2.8-beta.2

package/src/client/index.tsx

@@ -0,0 +1,225 @@
+import * as React from 'react';
+import { createPortal } from 'react-dom';
+import type { Context } from '@deepseek-ai/cordis';
+import type { ChatSnapshot, TurnTailChatData } from '@deepseek-ai/dsh-client-ui-chat/client';
+import type { EstimateSnapshot, EstimatorRemote } from '../shared/wire.ts';
+import { EstimateDetails } from './details.tsx';
+import { costSummary, costUnconfigured, formatDuration, formatEta, isTerminal, localTiming } from './format.ts';
+import { en, zh, LOCALE_NAMESPACE } from './locale.ts';
+import type { Translate } from './locale.ts';
+import { Management } from './management.tsx';
+import { errorText } from './remote.ts';
+import { SnapshotStore } from './store.ts';
+import { styles } from './styles.ts';
+import { usePanelPlacement } from './use-panel-placement.ts';
+
+// Narrow structural surfaces mirror inspected SDK contracts; only Cordis Context is imported.
+interface ProjectionMarker { revision: number; currentTurn: number | null }
+interface SlotProps {
+  sessionId: string;
+  useProjection: (key: string) => unknown;
+  turn?: { turn: number; status: 'open' | 'closed' | 'unknown' };
+  seq?: number;
+  messageId?: string;
+  useChat: <T>(selector: (snapshot: ChatSnapshot) => T) => T;
+}
+interface Slots {
+  inject(key: string, install: () => unknown): unknown;
+  register(options: { name: string; id?: string; order?: number }, component: React.ComponentType<SlotProps>): unknown;
+}
+interface LocaleSnapshot { active: string; revision: number }
+interface LocaleService {
+  register(namespace: string, locale: string, dictionary: Record<string, string>): () => void;
+  bind(namespace: string): Translate;
+  subscribe(listener: () => void): () => void;
+  getSnapshot(): LocaleSnapshot;
+}
+
+function readMarker(value: unknown): ProjectionMarker | null {
+  if (!value || typeof value !== 'object') return null;
+  if (!('revision' in value) || typeof value.revision !== 'number') return null;
+  if (!('currentTurn' in value) || !(value.currentTurn === null || typeof value.currentTurn === 'number')) return null;
+  return { revision: value.revision, currentTurn: value.currentTurn };
+}
+const idleSubscribe = () => () => {};
+
+/** Compact human token count, matching the host's own usage meta. */
+function compactTokens(value: number | null | undefined): string | null {
+  if (value == null || !Number.isFinite(value) || value < 0) return null;
+  if (value < 1_000) return String(Math.round(value));
+  if (value < 1_000_000) {
+    const scaled = value / 1_000;
+    return `${scaled >= 100 ? Math.round(scaled) : Number(scaled.toFixed(1))}k`;
+  }
+  const scaled = value / 1_000_000;
+  return `${scaled >= 100 ? Math.round(scaled) : Number(scaled.toFixed(1))}M`;
+}
+
+/**
+ * The bare count, for places whose own label already says "tokens": a row
+ * reading `Observed tokens  46.2M tokens` repeats the unit the label supplied.
+ */
+function tokenValue(snapshot: EstimateSnapshot | null, _locale: string, t: Translate): string {
+  if (!snapshot) return t('unknown');
+  const observed = compactTokens(snapshot.observedTokens);
+  if (observed) return observed;
+  const estimate = snapshot.estimatedTotalTokens;
+  if (!estimate) return t('unknown');
+  const low = compactTokens(estimate.low) ?? t('unknown');
+  const high = compactTokens(estimate.high) ?? t('unknown');
+  return low === high ? low : t('range', { low, high });
+}
+
+  /**
+   * Small clock that carries the task state by colour instead of by text: the
+   * line itself must stay a single short ETA, so a dot plus a word would repeat
+   * what the conversation already prints above the composer.
+   */
+  function ClockIcon({ state }: { state: string }) {
+    const live = state === 'running' || state === 'queued';
+    return <svg className="dte-icon" data-state={state} viewBox="0 0 16 16" width="13" height="13" aria-hidden="true" focusable="false">
+      <circle cx="8" cy="8" r="5.9" fill="none" stroke="currentColor" strokeWidth="1.6" />
+      <path d="M8 4.7v3.6l2.4 1.5" fill="none" stroke="currentColor" strokeWidth="1.6" strokeLinecap="round" strokeLinejoin="round" />
+      {live && <circle className="dte-icon-ring" cx="8" cy="8" r="5.9" fill="none" stroke="currentColor" strokeWidth="1.6" />}
+    </svg>;
+  }
+
+export const inject = ['slots', 'locale', 'remote'];
+
+/** Lead wrapper mounts the RPC contribution before calling this function. No remote access occurs at module evaluation. */
+export function applyClient(ctx: Context): void {
+  const slots = ctx.get('slots') as Slots;
+  const locale = ctx.get('locale') as LocaleService;
+  // $mount creates an independent service. A traced root Remote property read
+  // requires an inject declaration for that namespace; this bootstrap owns its
+  // dynamic mount, so read the completed service explicitly instead.
+  const namespace = ctx.get('remote.taskEstimator') as EstimatorRemote | undefined;
+  if (!slots || !locale || !namespace) throw new Error('task-estimate: required Client services have not been mounted');
+  const remote = namespace;
+  const store = new SnapshotStore(remote);
+  ctx.effect(() => () => store.dispose());
+  ctx.effect(() => locale.register(LOCALE_NAMESPACE, 'en', en));
+  ctx.effect(() => locale.register(LOCALE_NAMESPACE, 'zh', zh));
+  const t = locale.bind(LOCALE_NAMESPACE);
+  const subscribeLocale = (listener: () => void) => locale.subscribe(listener);
+  const readLocale = () => locale.getSnapshot();
+
+  function EstimateWidget({ props, tail }: { props: SlotProps; tail: boolean }) {
+    const localeSnapshot = React.useSyncExternalStore(subscribeLocale, readLocale, readLocale);
+    const marker = readMarker(props.useProjection('taskEstimator'));
+    const targetTurn = tail ? props.turn?.turn ?? null : marker?.currentTurn ?? null;
+    const revision = tail && marker?.currentTurn !== targetTurn ? props.seq ?? 0 : marker?.revision;
+    const subscribe = React.useCallback((listener: () => void) => store.subscribe(props.sessionId, targetTurn, listener), [props.sessionId, targetTurn]);
+    const read = React.useCallback(() => store.getSnapshot(props.sessionId, targetTurn), [props.sessionId, targetTurn]);
+    const state = React.useSyncExternalStore(subscribe, read, read);
+    React.useEffect(() => { store.projectionChanged(props.sessionId, targetTurn, revision); }, [props.sessionId, targetTurn, revision]);
+    const snapshot = state.view?.snapshot ?? null;
+    const ticking = !!snapshot && !isTerminal(snapshot.state);
+    const frozenNow = React.useCallback(() => state.receivedAt, [state.receivedAt]);
+    const now = React.useSyncExternalStore(ticking ? store.clock.subscribe : idleSubscribe, ticking ? store.clock.getSnapshot : frozenNow, frozenNow);
+    const [expanded, setExpanded] = React.useState(false);
+    const [view, setView] = React.useState<'summary' | 'details' | 'settings'>('summary');
+    const summary = React.useRef<HTMLButtonElement>(null);
+    const panel = React.useRef<HTMLDivElement>(null);
+    const firstAction = React.useRef<HTMLButtonElement>(null);
+    const id = React.useId();
+    // The body portal keeps the native surface; owned rectangles keep tall
+    // management content inside the viewport as its size changes.
+    usePanelPlacement(expanded, summary, panel, firstAction);
+    const active = !!snapshot && !isTerminal(snapshot.state);
+    // A settled turn has no remaining work, so an ETA row would print a
+    // meaningless "5s" beside a finished duration.
+    const terminal = !!snapshot && !active;
+    const timing = snapshot ? localTiming(snapshot, state.receivedAt, now) : null;
+    const refresh = () => { void store.refresh(props.sessionId, targetTurn); };
+    // Escape closes the panel from anywhere inside it and returns focus to the
+    // line that opened it, so the popover never traps a keyboard user.
+    React.useEffect(() => {
+      if (!expanded) return;
+      const onKeyDown = (event: KeyboardEvent) => {
+        if (event.key !== 'Escape') return;
+        event.preventDefault();
+        setExpanded(false);
+        summary.current?.focus();
+      };
+      const onOutside = (event: Event) => {
+        const target = event.target as Node | null;
+        if (!target || summary.current?.contains(target) || panel.current?.contains(target)) return;
+        setExpanded(false);
+      };
+      document.addEventListener('keydown', onKeyDown);
+      document.addEventListener('pointerdown', onOutside, true);
+      document.addEventListener('click', onOutside, true);
+      return () => {
+        document.removeEventListener('keydown', onKeyDown);
+        document.removeEventListener('pointerdown', onOutside, true);
+        document.removeEventListener('click', onOutside, true);
+      };
+    }, [expanded]);
+
+    if (tail && !snapshot && !state.error && !state.pending) return null;
+    const sessionRemaining = snapshot?.sessionRemainingMs ?? snapshot?.remainingMs ?? null;
+    const elapsed = formatDuration(timing?.activeMs ?? snapshot?.elapsedActiveMs, t);
+    const retained = !tail && sessionRemaining === null && state.lastForecast
+      && (!snapshot || state.lastForecast.taskKey === snapshot.taskKey) && (active || !snapshot && targetTurn !== null) ? state.lastForecast : null;
+    const eta = formatEta(sessionRemaining ?? retained?.remainingMs, t);
+    // Keep the last time reference while the new plan is unavailable. It is
+    // frozen and labelled in the dialog, never used as a current cost budget.
+    const line = tail ? t('doneElapsed', { elapsed }) : (active && sessionRemaining !== null || retained) ? t('etaEstimate', { value: eta }) : t('titleShort');
+    const unconfigured = !!snapshot && costUnconfigured(snapshot);
+    const referencePrice = snapshot?.reasons.includes('public-reference-price-not-provider-bill') ?? false;
+    return <div className="dte" data-slot={tail ? 'assistant-actions' : 'composer-dock'}>
+      <style>{styles}</style>
+      <button type="button" className={tail ? 'dte-line dte-line-tail' : 'dte-line'} aria-haspopup="dialog" aria-expanded={expanded} aria-controls={`${id}-panel`}
+        aria-label={line} onClick={() => setExpanded((value) => !value)} ref={summary}
+        title={terminal ? line : snapshot || retained ? t('etaFull', { value: eta }) : t('title')}>
+        <ClockIcon state={snapshot?.state ?? 'idle'} />
+        <span className="dte-line-text">{line}</span>
+      </button>
+      {expanded && createPortal(<div className="dte" style={{ display: 'contents' }}
+        onPointerDown={event => event.stopPropagation()} onMouseDown={event => event.stopPropagation()} onClick={event => event.stopPropagation()}><div id={`${id}-panel`} className="dte-pop" role="dialog"
+        aria-label={t(tail ? 'turnTimeTitle' : 'titleShort')} ref={panel}>
+        <div className="dte-pop-head">
+          <span className="dte-pop-title"><ClockIcon state={snapshot?.state ?? 'idle'} />{t(tail ? 'turnTimeTitle' : 'titleShort')}</span>
+          <span className="dte-pop-value dte-tabular">{terminal ? elapsed : eta}</span>
+        </div>
+        <div className="dte-pop-rule" aria-hidden="true" />
+        <dl className="dte-summary">
+          <dt>{t('activeTime')}</dt><dd>{snapshot ? elapsed : t('unknown')}</dd>
+          <dt>{t('estimatedTotal')}</dt><dd>{formatEta(snapshot?.estimatedTotalMs ?? retained?.estimatedTotalMs, t)}</dd>
+          <dt>{t('tokenTotal')}</dt><dd>{tokenValue(snapshot, localeSnapshot.active, t)}</dd>
+          <dt>{t(referencePrice ? 'referenceCost' : 'knownCost')}</dt><dd>{unconfigured ? t('unpriced') : snapshot ? costSummary(snapshot, localeSnapshot.active, t) : t('unknown')}</dd>
+        </dl>
+        {retained && <p className="dte-muted dte-small">{t('retainedForecastHint', { time: new Date(retained.updatedAt).toLocaleString(localeSnapshot.active) })}</p>}
+        {referencePrice && <p className="dte-muted dte-small">{t('referencePriceHint')}</p>}
+        {unconfigured && <p className="dte-muted dte-small">{t('unpricedHint')}</p>}
+        {!unconfigured && snapshot && (snapshot.observedCostStatus === 'partial' || snapshot.forecastCostStatus === 'partial') && <p className="dte-muted dte-small">{t('incompleteCostDetail')}</p>}
+        {state.error && <p className="dte-error dte-small" role="alert">{errorText(state.error, t)}</p>}
+        <div className="dte-pop-actions">
+          <button type="button" ref={firstAction} className={view === 'details' ? 'dte-link dte-link-active' : 'dte-link'} aria-pressed={view === 'details'} onClick={() => setView(view === 'details' ? 'summary' : 'details')}>{t('details')}</button>
+          <button type="button" className={view === 'settings' ? 'dte-link dte-link-active' : 'dte-link'} aria-pressed={view === 'settings'} onClick={() => setView(view === 'settings' ? 'summary' : 'settings')}>{t('settings')}</button>
+          <span className="dte-spacer" />
+          {view === 'details' && <button type="button" className="dte-link" disabled={state.pending} onClick={refresh}>{t('refresh')}</button>}
+        </div>
+        {view === 'details' && (snapshot ? <EstimateDetails snapshot={snapshot} receivedAt={state.receivedAt} now={now} locale={localeSnapshot.active} t={t} /> : <p className="dte-muted">{t(tail ? 'noSnapshot' : 'noTask')}</p>)}
+        {view === 'settings' && <Management remote={remote} store={store} t={t} locale={localeSnapshot.active} />}
+      </div></div>, document.body)}
+    </div>;
+  }
+
+  function Activity(props: SlotProps) { return <EstimateWidget key={props.sessionId} props={props} tail={false} />; }
+  function CompletedAction(props: SlotProps) {
+    // Public Chat data identifies the footer's durable closing message. Reading
+    // only its identity/Turn avoids attaching a full-Turn duration to each step.
+    const closing = props.useChat(snapshot => snapshot.nodes.values().find(node => node.kind === 'turn-tail'
+      && (node.data as TurnTailChatData).closing?.finalNode.messageId === props.messageId));
+    if (closing?.kind !== 'turn-tail') return null;
+    const turn = closing.location.kind === 'turn' || closing.location.kind === 'step' ? closing.location.turn : undefined;
+    if (turn?.status !== 'closed') return null;
+    return <EstimateWidget key={`${props.sessionId}:${turn.turn}`} props={{ ...props, turn, seq: closing.anchorSeq }} tail />;
+  }
+  slots.inject('conversation.composer.dock', () => slots.register({ name: 'conversation.composer.dock', id: 'task-estimate', order: 2 }, Activity));
+  slots.inject('conversation.chat.assistant-actions', () => slots.register({ name: 'conversation.chat.assistant-actions', id: 'task-estimate', order: 20 }, CompletedAction));
+}
+
+export const apply = applyClient;

package/src/client/locale.ts

@@ -0,0 +1,353 @@
+export const LOCALE_NAMESPACE = 'task-estimate';
+
+export const en = {
+  title: 'Task time and cost estimate',
+  titleShort: 'Estimates',
+  turnTimeTitle: 'Turn duration',
+  retainedForecastHint: 'Updating the estimate; using the last reference from {time}.',
+  tokenRemainingOutput: 'Estimated remaining output Tokens',
+  tokenRemainingNote: 'Visible output and tool arguments only; excludes hidden reasoning and repeated input.',
+  reassessingShort: 'Reassessing',
+  upTo: '≤{value}',
+  details: 'Estimate details',
+  settings: 'Settings and calibration',
+  close: 'Close',
+  refresh: 'Refresh',
+  retry: 'Retry',
+  loading: 'Loading…',
+  updating: 'Updating…',
+  unavailable: 'Estimate unavailable',
+  noTask: 'Estimates appear when a task starts.',
+  noSnapshot: 'No estimate for this turn.',
+  scope: 'Current turn only. Ranges are estimates, not guarantees.',
+  estimatedRemaining: 'Remaining {value}',
+  elapsed: 'Elapsed {value}',
+  activeTime: 'Active time',
+  pausedTime: 'Waiting for you',
+  wallTime: 'Wall time',
+  remaining: 'Estimated remaining',
+  estimatedTotal: 'Estimated total time',
+  estimatedCost: 'Estimated total cost',
+  knownCost: 'Known cost',
+  recordedCost: 'Recorded cost',
+  unknown: 'Unknown',
+  notAvailable: 'Not available',
+  free: 'Free',
+  incompleteCost: 'Unable to estimate the full cost',
+  incompleteCostDetail: 'Some calls have no price or forecast. The known amount is only a partial total.',
+  partialKnown: 'Partial: {value}',
+  referenceCost: 'Reference cost',
+  referencePriceHint: 'Automatic public list-price reference. Subscription charges, relay discounts and the provider invoice may differ.',
+  noPrice: 'Unpriced calls: {count}',
+  incompleteForecast: 'Units without a complete forecast: {count}',
+  observedCostStatus: 'Recorded cost coverage',
+  forecastCostStatus: 'Forecast coverage',
+  costComplete: 'Complete',
+  costPartial: 'Partial',
+  costUnpriced: 'Unpriced',
+  costReference: 'Reference',
+  costUnavailable: 'Unavailable',
+  stateQueued: 'Queued',
+  stateRunning: 'Running',
+  stateWaiting: 'Waiting for you',
+  stateCompleted: 'Completed',
+  stateFailed: 'Failed',
+  stateCancelled: 'Cancelled',
+  stateInterrupted: 'Interrupted',
+  durationMilliseconds: '{value}ms',
+  durationSeconds: '{value}s',
+  durationMinutes: '{value}m {seconds}s',
+  durationMinutesOnly: '{value}m',
+  durationHours: '{value}h {minutes}m',
+  durationHoursOnly: '{value}h',
+  range: '{low}–{high}',
+  money: '{currency} {value}',
+  moneyRange: '{currency} {low}–{high}',
+  listSeparator: ' · ',
+  labelSeparator: ': ',
+  timeAndCost: '{time} · {cost}',
+  count: '{value}',
+  tokenCount: '{value} tokens',
+  eta: 'ETA {value}', etaFull: 'Estimated {value} remaining', etaShort: 'ETA', etaEstimate: 'Est. {value}',
+  doneMeta: '{elapsed} · {tokens}',
+  doneElapsed: 'Elapsed {elapsed}',
+  sessionMeta: 'Session · {turns} turns',
+  sessionEta: 'Session ETA {value}',
+  unpriced: 'No matching price',
+  unpricedHint: 'No configured or public price matches this model. Time and tokens remain available; a model price can be added in Settings.',
+  advancedSettings: 'Advanced parameters',
+  tokenTotal: 'Observed tokens',
+  tokenInput: 'Input',
+  tokenCacheRead: 'Cache read',
+  tokenCacheWrite: 'Cache write',
+  tokenOutput: 'Output',
+  tokenReasoning: 'Reasoning',
+  tokenForecast: 'Estimated total tokens',
+  tokenCoverage: 'Token coverage',
+  tokenComplete: 'Complete',
+  tokenPartial: 'Partial',
+  tokenUnknown: 'Unknown',
+  tokensNote: 'Reasoning and cache tokens are provider-reported categories; they are not added a second time.',
+  basis: 'Estimate basis',
+  origin: 'Source',
+  originHeuristic: 'Heuristic assumptions',
+  originPublic: 'Public measurements',
+  originLocal: 'Local measurements',
+  originMixed: 'Mixed sources',
+  taskType: 'Task type',
+  taskQuestion: 'Question',
+  taskWriting: 'Writing',
+  taskFileAnalysis: 'File analysis',
+  taskCode: 'Code',
+  taskResearch: 'Research',
+  taskUnknown: 'Unclassified',
+  localSamples: 'Local performance samples',
+  workloadSamples: 'Workload samples',
+  calls: 'Model calls',
+  callCounts: '{completed} completed · {active} active · {failed} failed',
+  tools: 'Tools',
+  toolCounts: '{completed} completed · {active} active',
+  toolTime: 'Tool work time',
+  performance: 'Route performance',
+  performanceTrust: 'Performance evidence', performanceObserved: 'Observed; range remains a reference', performanceReference: 'Reference only',
+  firstContentSource: 'First content source', firstTextSource: 'First text source', speedSource: 'Generation speed source', totalSource: 'Total call time source',
+  provider: 'Provider',
+  model: 'Model',
+  endpoint: 'Endpoint fingerprint',
+  requestMode: 'Request mode',
+  reasoningEffort: 'Reasoning effort',
+  serviceTier: 'Service tier',
+  firstContent: 'First content latency',
+  firstText: 'First text latency',
+  visibleSpeed: 'Visible generation speed',
+  tokensPerSecond: '{value} tokens/s',
+  callDuration: 'Total call time',
+  staleProfile: 'This performance profile is stale; treat the estimate cautiously.',
+  priceSources: 'Price sources',
+  noPriceSources: 'No price source available.',
+  initialComparison: 'Initial estimate and current observation',
+  initialTime: 'Initial total time',
+  initialCost: 'Initial total cost',
+  reasons: 'Reasons and limits',
+  noReasons: 'No additional reasons reported.',
+  algorithm: 'Algorithm version',
+  turn: 'Turn {value}',
+  settingsHint: 'Calibration settings apply to this plugin. Save to apply changes.',
+  storageUnavailable: 'Storage is unavailable. Configuration and calibration changes may not persist.',
+  config: 'Configuration',
+  performanceAlpha: 'Performance smoothing α',
+  workloadAlpha: 'Workload smoothing α',
+  predictionRefreshMs: 'Prediction refresh (ms)',
+  timerRefreshMs: 'Local timer refresh (ms)',
+  historyRetentionDays: 'History retention (days)',
+  profileStaleDays: 'Profile stale age (days)',
+  minConditionalSamples: 'Minimum conditional samples',
+  heuristicFirstTextMs: 'Fallback first text latency (ms)',
+  heuristicVisibleTps: 'Fallback visible tokens/s',
+  heuristicTotalCallMs: 'Fallback total call time (ms)',
+  advancedJson: 'Advanced configuration (JSON)',
+  advancedHint: 'The JSON contains the complete configuration. Editing a field above updates this JSON.',
+  invalidConfig: 'Invalid configuration: {message}',
+  objectRequired: 'Enter a JSON object.',
+  fieldRequired: 'Enter a finite number for {field}.',
+  fieldMinimum: '{field} must be at least {value}.',
+  fieldMaximum: '{field} must be at most {value}.',
+  fieldInteger: '{field} must be a whole number.',
+  save: 'Save configuration',
+  saved: 'Configuration saved.',
+  reloaded: 'Settings reloaded.',
+  imported: 'Baseline data imported.',
+  exported: 'Export prepared. Check the save dialog or your downloads for the result.',
+  resetDone: 'Local calibration reset.',
+  operationFailed: 'Operation failed',
+  requestTimeout: 'The Host did not respond in time. Retry the request.',
+  requestCancelled: 'The request was cancelled.',
+  errorDetail: '{message} ({code})',
+  read: 'Reload settings',
+  data: 'Calibration data',
+  importLabel: 'Baseline JSON or CSV content',
+  importHint: 'Paste the complete file content. The Host detects JSON or CSV and validates it before importing.',
+  importPlaceholder: 'Paste JSON or CSV content…',
+  import: 'Import baseline data',
+  importRequired: 'Paste JSON or CSV content first.',
+  export: 'Export configuration and calibration',
+  reset: 'Reset local calibration',
+  resetWarning: 'Reset locally learned performance and workload calibration? Task history, configuration, imported baselines, and DSH sessions are kept.',
+  confirmReset: 'Confirm reset',
+  cancel: 'Cancel',
+  profiles: 'Performance profiles',
+  performanceProfiles: 'Per-route calibration',
+  profilesHint: 'Local measurements per route. A value without local samples is a reference prior, not a measurement.',
+  noProfiles: 'No local performance profiles yet.',
+  profileSamples: 'samples {value}',
+  profileMeasuredAt: 'last {value}',
+  profileNotMeasured: 'not measured yet',
+  referenceValue: 'reference {value}',
+  profilesShown: 'Showing the newest {shown} of {total}.',
+  mixedRouteShort: 'mixed upstream',
+  history: 'Recent task history',
+  noHistory: 'No recorded tasks.',
+  diagnostics: 'Diagnostics',
+  noDiagnostics: 'No diagnostics reported.',
+  timestamp: 'Time',
+  status: 'Status',
+  duration: 'Active time',
+  initialDifference: 'Difference from initial midpoint',
+  signedDuration: '{sign}{value}',
+  exportedFilename: 'task-estimate-data.json',
+  pendingRead: 'Reading settings…',
+  pendingSave: 'Saving configuration…',
+  pendingImport: 'Importing baseline data…',
+  pendingExport: 'Preparing export…',
+  pendingReset: 'Resetting calibration…',
+  snapshotError: 'Estimate error: {message}',
+  rawDetail: 'Host detail: {message}',
+  sourceDetail: 'Source: {value}',
+  unknownRemaining: 'Remaining time unknown',
+  unknownTime: 'Time estimate unavailable',
+  overdue: 'Estimate is being revised',
+  reasonHeuristic: 'Uses engineering assumptions until local measurements are available.',
+  reasonWorkloadTemplate: 'Workload comes from an engineering template.',
+  reasonLocalWorkload: 'Workload is smoothed from local completed tasks.',
+  reasonPublicEndpoint: 'Public endpoint measurements are a reference for this route.',
+  reasonReferenceRange: 'This is a reference range, not a calibrated confidence interval.',
+  reasonFewSamples: 'Too few comparable samples for a conditional remaining-time estimate.',
+  reasonAiPlan: 'The executing AI estimated the remaining work; timing uses the current route’s performance. This is a reference, not measured completion time.',
+  reasonContinuationHistory: 'Reference from completed local tasks of the same kind and route; this does not provide a future token or cost budget.',
+  reasonContinuationUnknown: 'The original plan has been exceeded and too few comparable completed tasks remain. Reassessing instead of counting down to a false finish.',
+  reasonReassessing: 'The reference range has elapsed; the estimate needs revision.',
+  reasonBudgetExhausted: 'The output budget has been exceeded while the task is still running.',
+  reasonWaitingModel: 'Waiting for a model response.',
+  reasonMixedRoute: 'The actual upstream endpoint is unknown or mixed.',
+  reasonRouteFallback: 'Uses another profile for the same provider and model.',
+  reasonSpeedPrior: 'Visible generation speed still uses a prior assumption.',
+  reasonStale: 'A stale profile is retained for comparison only.',
+  reasonEndpointUnknown: 'The endpoint identity is unknown, so this route stays a reference rather than a measured match.',
+  reasonReasoningUnknown: 'The reasoning mode is unknown.',
+  reasonNoPrice: 'No matching price is configured.',
+  reasonBillingUnknown: 'The billing model identity is unknown.',
+  reasonCacheUnknown: 'The split between future input and cache tokens is unknown.',
+  reasonFutureReasoning: 'The future reasoning-token budget is unknown.',
+  reasonReferencePrice: 'Public catalog pricing is a reference, not the provider invoice.',
+  reasonSameAs: 'Uses an explicit user-configured pricing alias.',
+  reasonPriceCondition: 'A price multiplier condition is unknown.',
+  reasonForecastScenario: 'Cost is based on a reference workload scenario.',
+  reasonNoRepeatWait: 'The first-text wait is not counted again after text generation starts.',
+  reasonReasoningIncluded: 'Reasoning time is already included in the first-text wait.',
+  reasonFirstTextBody: 'Combines first-text latency and visible text generation time.',
+  reasonTotalFallback: 'Uses total call time for the same request mode as a fallback.',
+  reasonConditional: 'Uses observed remaining times from comparable local samples.',
+  reasonClassification: 'Task classification is heuristic.',
+  reasonClassificationRule: 'Matched task classification rule: {value}.',
+  reasonArtifactCount: 'Includes the requested artifact count.',
+  reasonPlanSteps: 'Includes the observed plan steps.',
+  reasonFileBatch: 'File batches use a workload assumption.',
+  reasonOutputBudget: 'Uses an explicit output-token budget.',
+  reasonLengthConversion: 'Requested length is converted to tokens heuristically.',
+  reasonAttachments: 'Task classification uses the visible attachment count.',
+  reasonNoClassification: 'No task classification rule matched.',
+  reasonScopeChanged: 'The task scope changed; it is excluded from workload calibration.',
+  reasonIncompleteWorkload: 'Incomplete task data is excluded from workload calibration.',
+  reasonRequestCompleted: 'The model call is complete.',
+  reasonCode: 'Reported reason: {value}',
+} as const;
+
+export type MessageKey = keyof typeof en;
+export type Translate = (key: MessageKey, params?: Record<string, string | number>) => string;
+
+export const zh: Record<MessageKey, string> = {
+  title: '任务耗时与费用预估', titleShort: '耗时预估', turnTimeTitle: '本轮用时',
+  retainedForecastHint: '正在更新，暂用 {time} 的预估参考。',
+  tokenRemainingOutput: '预计剩余输出 Token', tokenRemainingNote: '包含可见输出和工具参数，不含隐藏推理与重复输入。',
+  reassessingShort: '重新评估', upTo: '≤{value}', details: '预估详情', settings: '设置与校准', close: '关闭',
+  refresh: '刷新', retry: '重试', loading: '正在加载…', updating: '正在更新…',
+  unavailable: '暂时无法预估', noTask: '任务开始后显示预估。', noSnapshot: '本回合暂无预估。',
+  scope: '仅统计当前回合。区间为参考预估，不是保证。', estimatedRemaining: '预计剩余 {value}',
+  elapsed: '已用 {value}', activeTime: '实际工作时间', pausedTime: '等待用户时间', wallTime: '总经过时间',
+  remaining: '预计剩余', estimatedTotal: '预计总耗时', estimatedCost: '预计总费用',
+  knownCost: '已知费用', recordedCost: '已记录费用', unknown: '未知', notAvailable: '暂无数据', free: '免费',
+  incompleteCost: '无法完整估算费用', incompleteCostDetail: '部分调用缺少价格或预测；已知金额仅为部分费用。',
+  partialKnown: '已知部分：{value}', referenceCost: '参考费用', referencePriceHint: '自动匹配公共目录价，仅作费用参考；订阅费用、渠道折扣和实际账单可能不同。', noPrice: '未定价调用：{count}',
+  incompleteForecast: '预测不完整单元：{count}', observedCostStatus: '已记录费用覆盖', forecastCostStatus: '费用预测覆盖',
+  costComplete: '完整', costPartial: '不完整', costUnpriced: '未定价', costReference: '参考区间', costUnavailable: '不可用',
+  stateQueued: '排队中', stateRunning: '进行中', stateWaiting: '等待用户', stateCompleted: '已完成',
+  stateFailed: '失败', stateCancelled: '已取消', stateInterrupted: '已中断',
+  durationMilliseconds: '{value}ms', durationSeconds: '{value}s', durationMinutes: '{value}m {seconds}s', durationMinutesOnly: '{value}m',
+  durationHours: '{value}h {minutes}m', durationHoursOnly: '{value}h',
+  range: '{low}–{high}', money: '{currency} {value}', moneyRange: '{currency} {low}–{high}',
+  listSeparator: ' · ', labelSeparator: '：', timeAndCost: '{time} · {cost}', count: '{value}', tokenCount: '{value} Token',
+  eta: 'ETA {value}', etaFull: '预计还需 {value}', etaShort: 'ETA', etaEstimate: '预计 {value}',
+  doneMeta: '已用 {elapsed} · {tokens}',
+  doneElapsed: '用时 {elapsed}',
+  sessionMeta: '会话 {turns} 轮',
+  sessionEta: '会话 ETA {value}',
+  unpriced: '暂无匹配价格',
+  unpricedHint: '此模型暂未匹配到自定义或公共价格，仍显示时间与 Token；可在设置中补充模型价格。',
+  advancedSettings: '高级参数',
+  tokenTotal: '已观测 Token', tokenInput: '输入', tokenCacheRead: '缓存读取', tokenCacheWrite: '缓存写入',
+  tokenOutput: '输出', tokenReasoning: '推理', tokenForecast: '预计总 Token', tokenCoverage: 'Token 覆盖',
+  tokenComplete: '完整', tokenPartial: '部分', tokenUnknown: '未知',
+  tokensNote: '推理与缓存 Token 按供应商返回的分类展示，不重复累加。',
+  basis: '预估依据', origin: '来源', originHeuristic: '启发式假设', originPublic: '公开实测',
+  originLocal: '本地实测', originMixed: '混合来源', taskType: '任务类型', taskQuestion: '问答',
+  taskWriting: '写作', taskFileAnalysis: '文件分析', taskCode: '代码', taskResearch: '研究', taskUnknown: '未分类',
+  localSamples: '本地性能样本', workloadSamples: '工作量样本', calls: '模型调用',
+  callCounts: '已完成 {completed} · 活跃 {active} · 失败 {failed}', tools: '工具',
+  toolCounts: '已完成 {completed} · 活跃 {active}', toolTime: '工具工作时间', performance: '调用线路性能',
+  provider: '供应商', model: '模型', endpoint: '端点指纹', requestMode: '请求模式', reasoningEffort: '推理强度',
+  serviceTier: '服务层级', firstContent: '首内容延迟', firstText: '首文本延迟', visibleSpeed: '可见生成速度',
+  tokensPerSecond: '{value} Token/秒', callDuration: '调用总耗时', staleProfile: '性能画像已过期，请谨慎参考预估。',
+  performanceTrust: '性能证据', performanceObserved: '有观测数据；区间仍为参考', performanceReference: '仅供参考',
+  firstContentSource: '首内容来源', firstTextSource: '首文本来源', speedSource: '生成速度来源', totalSource: '调用总耗时来源',
+  priceSources: '价格来源', noPriceSources: '暂无价格来源。', initialComparison: '初始预估与当前观测',
+  initialTime: '初始总耗时预估', initialCost: '初始总费用预估', reasons: '原因与局限', noReasons: '暂无补充原因。',
+  algorithm: '算法版本', turn: '第 {value} 回合', settingsHint: '校准设置仅作用于本插件，保存后生效。',
+  storageUnavailable: '存储不可用，配置与校准更改可能无法持久保存。', config: '配置',
+  performanceAlpha: '性能平滑系数 α', workloadAlpha: '工作量平滑系数 α', predictionRefreshMs: '预估刷新间隔（毫秒）',
+  timerRefreshMs: '本地计时间隔（毫秒）', historyRetentionDays: '历史保留天数', profileStaleDays: '画像过期天数',
+  minConditionalSamples: '条件样本最小数量', heuristicFirstTextMs: '兜底首文本延迟（毫秒）',
+  heuristicVisibleTps: '兜底可见生成速度（Token/秒）', heuristicTotalCallMs: '兜底调用总耗时（毫秒）',
+  advancedJson: '高级配置（JSON）', advancedHint: 'JSON 包含完整配置，修改上方字段会同步更新此处。',
+  invalidConfig: '配置无效：{message}', objectRequired: '请输入 JSON 对象。', fieldRequired: '请为「{field}」输入有限数值。',
+  fieldMinimum: '「{field}」不得小于 {value}。', fieldMaximum: '「{field}」不得大于 {value}。', fieldInteger: '「{field}」必须是整数。',
+  save: '保存配置', saved: '配置已保存。', reloaded: '设置已重新加载。', imported: '基准数据已导入。',
+  exported: '已生成导出文件，请在保存窗口或下载列表中确认结果。', resetDone: '本地校准已重置。', operationFailed: '操作失败',
+  requestTimeout: 'Host 未及时响应，请重试。', requestCancelled: '请求已取消。',
+  errorDetail: '{message}（{code}）', read: '重新加载设置', data: '校准数据', importLabel: '基准 JSON 或 CSV 内容',
+  importHint: '粘贴完整文件内容，Host 自动识别 JSON 或 CSV，验证后导入。', importPlaceholder: '粘贴 JSON 或 CSV 内容…',
+  import: '导入基准数据', importRequired: '请先粘贴 JSON 或 CSV 内容。', export: '导出配置与校准数据',
+  reset: '重置本地校准', resetWarning: '重置本地学习的性能与工作量校准？任务历史、配置、导入基准和 DSH 会话均保留。',
+  confirmReset: '确认重置', cancel: '取消', profiles: '性能画像数量',
+  performanceProfiles: '按路由的本地校准', profilesHint: '按路由显示本地实测的延迟、速度与样本；没有本地样本的数值是参考先验，不是实测。',
+  noProfiles: '暂无本地性能画像。', profileSamples: '样本 {value}', profileMeasuredAt: '最近 {value}',
+  profileNotMeasured: '尚未测量', referenceValue: '参考 {value}', profilesShown: '显示最近 {shown} / {total} 条。', mixedRouteShort: '混合线路',
+  history: '近期任务历史', noHistory: '暂无任务记录。',
+  diagnostics: '诊断', noDiagnostics: '暂无诊断信息。', timestamp: '时间', status: '状态', duration: '工作时间',
+  initialDifference: '与初始预估中值之差', signedDuration: '{sign}{value}', exportedFilename: 'task-estimate-data.json',
+  pendingRead: '正在读取设置…', pendingSave: '正在保存配置…', pendingImport: '正在导入基准…',
+  pendingExport: '正在准备导出…', pendingReset: '正在重置校准…', snapshotError: '预估错误：{message}',
+  rawDetail: 'Host 详情：{message}', sourceDetail: '来源：{value}', unknownRemaining: '剩余时间未知',
+  unknownTime: '暂时无法预估耗时', overdue: '正在修正预估',
+  reasonHeuristic: '本地实测不足时使用工程假设。', reasonWorkloadTemplate: '工作量来自工程模板。',
+  reasonLocalWorkload: '工作量由本地已完成任务平滑更新。', reasonPublicEndpoint: '公开端点实测仅作为当前线路的参考。',
+  reasonReferenceRange: '这是参考区间，并非经过校准的置信区间。', reasonFewSamples: '相似样本不足，无法给出条件剩余时间。',
+  reasonAiPlan: '执行 AI 评估了剩余工作量，再结合当前路由性能换算耗时；这是参考预估，不是已测得的完成时间。',
+  reasonContinuationHistory: '参考同类、同路由的已完成本地任务耗时；这些历史耗时不提供未来 Token 或费用预算。',
+  reasonContinuationUnknown: '实际工作已超出原计划，且可比的已完成任务不足。正在重新评估，避免倒计时制造即将完成的错觉。',
+  reasonReassessing: '参考区间已耗尽，正在重新评估。', reasonBudgetExhausted: '输出预算已耗尽，但任务仍在进行。',
+  reasonWaitingModel: '正在等待模型响应。', reasonMixedRoute: '实际上游端点未知或线路混合。',
+  reasonRouteFallback: '使用同供应商、同模型的其他性能画像。', reasonSpeedPrior: '可见生成速度仍采用先验假设。',
+  reasonStale: '过期画像仅保留用于对照。', reasonEndpointUnknown: '端点身份未知，该线路的延迟与速度只作参考，不作为实测匹配。', reasonReasoningUnknown: '推理模式未知。', reasonNoPrice: '未找到匹配的价格配置。',
+  reasonBillingUnknown: '实际计费模型身份未知。', reasonCacheUnknown: '未来输入与缓存 Token 的拆分未知。',
+  reasonFutureReasoning: '未来推理 Token 预算未知。', reasonReferencePrice: '公开目录价格仅为参考，并非供应商账单。',
+  reasonSameAs: '使用用户明确配置的价格别名。', reasonPriceCondition: '价格倍率的适用条件未知。',
+  reasonForecastScenario: '费用基于参考工作量场景。', reasonNoRepeatWait: '文本生成开始后，不重复计算首文本等待。',
+  reasonReasoningIncluded: '推理耗时已包含在首文本等待中。', reasonFirstTextBody: '结合首文本延迟和可见文本生成耗时。',
+  reasonTotalFallback: '以相同请求模式的调用总耗时兜底。', reasonConditional: '采用相似本地样本的实际剩余时间。',
+  reasonClassification: '任务分类采用启发式规则。', reasonClassificationRule: '匹配任务分类规则：{value}。',
+  reasonArtifactCount: '已计入明确请求的产物数量。', reasonPlanSteps: '已计入可观察的计划步骤。', reasonFileBatch: '文件批次工作量采用假设。',
+  reasonOutputBudget: '采用明确的输出 Token 预算。', reasonLengthConversion: '请求篇幅通过启发式换算为 Token。',
+  reasonAttachments: '任务分类参考了附件数量。', reasonNoClassification: '未匹配任务分类规则。',
+  reasonScopeChanged: '任务范围发生变化，不纳入工作量校准。', reasonIncompleteWorkload: '任务数据不完整，不纳入工作量校准。',
+  reasonRequestCompleted: '模型调用已完成。', reasonCode: '返回的原因：{value}',
+};