@symerian/symi 3.5.4 → 3.5.5

package/dist/{pi-tools.policy-uHgu_nx0.js → pi-tools.policy-CU8U7--z.js}

@@ -1,8 +1,8 @@
 import { S as resolveThreadParentSessionKey, c as resolveAgentIdFromSessionKey } from "./session-key-CFxFgYxM.js";
 import { r as resolveAgentConfig } from "./agent-scope-C-Jte08L.js";
-import { A as DEFAULT_SUBAGENT_MAX_SPAWN_DEPTH } from "./config-_DaupjQd.js";
+import { A as DEFAULT_SUBAGENT_MAX_SPAWN_DEPTH } from "./config-D7TcU4qN.js";
 import { l as normalizeMessageChannel } from "./message-channel-DXToSaWK.js";
-import { T as matchesAnyGlobPattern, w as compileGlobPatterns, x as normalizeToolName, y as expandToolGroups } from "./sandbox-BjQ6n3zl.js";
+import { T as matchesAnyGlobPattern, w as compileGlobPatterns, x as normalizeToolName, y as expandToolGroups } from "./sandbox-J92UBQK8.js";
 import { a as resolveChannelGroupToolsPolicy, t as getChannelDock } from "./dock-DZ6SgvTh.js";
 
 //#region src/agents/sandbox-tool-policy.ts

package/dist/{pi-tools.policy-CTzYYKRt.js → pi-tools.policy-WaLKhqJQ.js}

@@ -1,7 +1,7 @@
 import { S as resolveThreadParentSessionKey, c as resolveAgentIdFromSessionKey } from "./session-key-DUSb7CCb.js";
 import { r as resolveAgentConfig } from "./agent-scope-DOrZjOnW.js";
-import { A as DEFAULT_SUBAGENT_MAX_SPAWN_DEPTH } from "./config-D7SS4vdk.js";
-import { T as matchesAnyGlobPattern, w as compileGlobPatterns, x as normalizeToolName, y as expandToolGroups } from "./sandbox-DQdjlC-w.js";
+import { A as DEFAULT_SUBAGENT_MAX_SPAWN_DEPTH } from "./config-B4jkreCN.js";
+import { T as matchesAnyGlobPattern, w as compileGlobPatterns, x as normalizeToolName, y as expandToolGroups } from "./sandbox-61-kshSF.js";
 import { a as resolveChannelGroupToolsPolicy, t as getChannelDock } from "./dock-hF45sewN.js";
 import { l as normalizeMessageChannel } from "./message-channel-DgjXWzf-.js";
 

package/dist/{plugin-auto-enable-C4b23B35.js → plugin-auto-enable-Bt2sVz8w.js}

@@ -1,8 +1,8 @@
 import { o as getChatChannelMeta, s as listChatChannels, u as normalizeChatChannelId } from "./registry-Sbac4a4z.js";
 import { u as isRecord } from "./utils-CTPsqyE_.js";
 import { u as normalizeProviderId } from "./model-selection-7wdmO-Iw.js";
-import { n as getChannelPluginCatalogEntry, r as listChannelPluginCatalogEntries } from "./catalog-BXxi5-YC.js";
-import { t as ensurePluginAllowlisted } from "./plugins-allowlist-BvQZxkGy.js";
+import { n as getChannelPluginCatalogEntry, r as listChannelPluginCatalogEntries } from "./catalog-BnLcGVie.js";
+import { t as ensurePluginAllowlisted } from "./plugins-allowlist-C5r7biDp.js";
 
 //#region src/config/plugin-auto-enable.ts
 const CHANNEL_PLUGIN_IDS = Array.from(new Set([...listChatChannels().map((meta) => meta.id), ...listChannelPluginCatalogEntries().map((entry) => entry.id)]));

package/dist/{plugin-auto-enable-BkhVwtbW.js → plugin-auto-enable-PBDcVF_-.js}

@@ -1,7 +1,7 @@
 import { At as isRecord, D as getChatChannelMeta, O as listChatChannels, j as normalizeChatChannelId } from "./entry.js";
 import { u as normalizeProviderId } from "./model-selection-CMx1evaF.js";
-import { n as getChannelPluginCatalogEntry, r as listChannelPluginCatalogEntries } from "./catalog-CriSxQMH.js";
-import { t as ensurePluginAllowlisted } from "./plugins-allowlist-BuJjTWyS.js";
+import { n as getChannelPluginCatalogEntry, r as listChannelPluginCatalogEntries } from "./catalog-BaM8d1-T.js";
+import { t as ensurePluginAllowlisted } from "./plugins-allowlist-CD4oIJNk.js";
 
 //#region src/config/plugin-auto-enable.ts
 const CHANNEL_PLUGIN_IDS = Array.from(new Set([...listChatChannels().map((meta) => meta.id), ...listChannelPluginCatalogEntries().map((entry) => entry.id)]));

package/dist/{plugin-registry-CxUYRmLh.js → plugin-registry-Dq6OJ45H.js}

@@ -1,9 +1,9 @@
 import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
-import { s as loadSymiPlugins } from "./unified-runner-DnikxMFg.js";
+import { s as loadSymiPlugins } from "./unified-runner-Bm3r8UOg.js";
 import { d as getActivePluginRegistry } from "./registry-Sbac4a4z.js";
 import { t as createSubsystemLogger } from "./subsystem-CHbO_DkH.js";
 import { c as resolveAgentWorkspaceDir, l as resolveDefaultAgentId } from "./agent-scope-DOrZjOnW.js";
-import { i as loadConfig } from "./config-D7SS4vdk.js";
+import { i as loadConfig } from "./config-B4jkreCN.js";
 
 //#region src/cli/plugin-registry.ts
 var plugin_registry_exports = /* @__PURE__ */ __exportAll({ ensurePluginRegistryLoaded: () => ensurePluginRegistryLoaded });

package/dist/{plugin-registry-V5jShvbP.js → plugin-registry-L1h7mxjX.js}

@@ -1,8 +1,8 @@
 import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
 import { M as getActivePluginRegistry, o as createSubsystemLogger } from "./entry.js";
 import { c as resolveAgentWorkspaceDir, l as resolveDefaultAgentId } from "./agent-scope-C-Jte08L.js";
-import { i as loadConfig } from "./config-_DaupjQd.js";
-import { m as loadSymiPlugins } from "./subagent-registry-BnHgIGX-.js";
+import { i as loadConfig } from "./config-D7TcU4qN.js";
+import { m as loadSymiPlugins } from "./subagent-registry-DQ_BPb-T.js";
 
 //#region src/cli/plugin-registry.ts
 var plugin_registry_exports = /* @__PURE__ */ __exportAll({ ensurePluginRegistryLoaded: () => ensurePluginRegistryLoaded });

package/dist/plugin-sdk/auto-reply/reply/commands-info.d.ts

@@ -6,6 +6,7 @@ export declare function buildCommandsPaginationKeyboard(currentPage: number, tot
     callback_data: string;
 }>>;
 export declare const handleStatusCommand: CommandHandler;
+export declare const handleCostCommand: CommandHandler;
 export declare const handleContextCommand: CommandHandler;
 export declare const handleExportSessionCommand: CommandHandler;
 export declare const handleWhoamiCommand: CommandHandler;

package/dist/plugin-sdk/auto-reply/status.d.ts

@@ -38,6 +38,19 @@ type StatusArgs = {
     queue?: QueueStatus;
     mediaDecisions?: ReadonlyArray<MediaUnderstandingDecision>;
     subagentsLine?: string;
+    engineLine?: string;
+    hardwareLine?: string;
+    /**
+     * Instance-derived USD cost from the cost subsystem (Phase 3). When the
+     * raw per-token rate yields $0 and this is set, the cost line displays
+     * this value instead, with a "(self-hosted)" tag.
+     */
+    costOverrideUsd?: number;
+    /**
+     * Suffix appended to the cost line for benchmark comparison (Phase 4).
+     * Example: "vs Claude Sonnet 4.6 would be $0.2320 (save 93%)".
+     */
+    costLineSuffix?: string;
     includeTranscriptUsage?: boolean;
     now?: number;
 };

package/dist/plugin-sdk/config/types.models.d.ts

@@ -24,6 +24,9 @@ export type ModelDefinitionConfig = {
         output: number;
         cacheRead: number;
         cacheWrite: number;
+        gpuType?: string;
+        gpuCount?: number;
+        hourlyRate?: number;
     };
     contextWindow: number;
     maxTokens: number;
@@ -79,4 +82,6 @@ export type ModelsConfig = {
     providers?: Record<string, ModelProviderConfig>;
     profiles?: ModelProfileConfig[];
     bedrockDiscovery?: BedrockDiscoveryConfig;
+    gpuRates?: Record<string, number>;
+    benchmark?: "opus" | "sonnet" | "haiku" | "all" | "none";
 };

package/dist/plugin-sdk/config/zod-schema.core.d.ts

@@ -24,6 +24,9 @@ export declare const ModelDefinitionSchema: z.ZodObject<{
         output: z.ZodOptional<z.ZodNumber>;
         cacheRead: z.ZodOptional<z.ZodNumber>;
         cacheWrite: z.ZodOptional<z.ZodNumber>;
+        gpuType: z.ZodOptional<z.ZodString>;
+        gpuCount: z.ZodOptional<z.ZodNumber>;
+        hourlyRate: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
     contextWindow: z.ZodOptional<z.ZodNumber>;
     maxTokens: z.ZodOptional<z.ZodNumber>;
@@ -60,6 +63,9 @@ export declare const ModelProviderSchema: z.ZodObject<{
             output: z.ZodOptional<z.ZodNumber>;
             cacheRead: z.ZodOptional<z.ZodNumber>;
             cacheWrite: z.ZodOptional<z.ZodNumber>;
+            gpuType: z.ZodOptional<z.ZodString>;
+            gpuCount: z.ZodOptional<z.ZodNumber>;
+            hourlyRate: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
         contextWindow: z.ZodOptional<z.ZodNumber>;
         maxTokens: z.ZodOptional<z.ZodNumber>;
@@ -138,6 +144,9 @@ export declare const ModelsConfigSchema: z.ZodOptional<z.ZodObject<{
                 output: z.ZodOptional<z.ZodNumber>;
                 cacheRead: z.ZodOptional<z.ZodNumber>;
                 cacheWrite: z.ZodOptional<z.ZodNumber>;
+                gpuType: z.ZodOptional<z.ZodString>;
+                gpuCount: z.ZodOptional<z.ZodNumber>;
+                hourlyRate: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strict>>;
             contextWindow: z.ZodOptional<z.ZodNumber>;
             maxTokens: z.ZodOptional<z.ZodNumber>;
@@ -196,6 +205,8 @@ export declare const ModelsConfigSchema: z.ZodOptional<z.ZodObject<{
         defaultContextWindow: z.ZodOptional<z.ZodNumber>;
         defaultMaxTokens: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
+    gpuRates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    benchmark: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"opus">, z.ZodLiteral<"sonnet">, z.ZodLiteral<"haiku">, z.ZodLiteral<"all">, z.ZodLiteral<"none">]>>;
 }, z.core.$strict>>;
 export declare const GroupChatSchema: z.ZodOptional<z.ZodObject<{
     mentionPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/plugin-sdk/config/zod-schema.d.ts

@@ -122,6 +122,9 @@ export declare const SymiSchema: z.ZodObject<{
                     output: z.ZodOptional<z.ZodNumber>;
                     cacheRead: z.ZodOptional<z.ZodNumber>;
                     cacheWrite: z.ZodOptional<z.ZodNumber>;
+                    gpuType: z.ZodOptional<z.ZodString>;
+                    gpuCount: z.ZodOptional<z.ZodNumber>;
+                    hourlyRate: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strict>>;
                 contextWindow: z.ZodOptional<z.ZodNumber>;
                 maxTokens: z.ZodOptional<z.ZodNumber>;
@@ -180,6 +183,8 @@ export declare const SymiSchema: z.ZodObject<{
             defaultContextWindow: z.ZodOptional<z.ZodNumber>;
             defaultMaxTokens: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
+        gpuRates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        benchmark: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"opus">, z.ZodLiteral<"sonnet">, z.ZodLiteral<"haiku">, z.ZodLiteral<"all">, z.ZodLiteral<"none">]>>;
     }, z.core.$strict>>;
     nodeHost: z.ZodOptional<z.ZodObject<{
         browserProxy: z.ZodOptional<z.ZodObject<{

package/dist/plugin-sdk/cost/benchmark.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Claude reference rates and benchmark comparison.
+ *
+ * Hardcoded per-token USD rates for Claude Opus 4.7, Sonnet 4.6, and
+ * Haiku 4.5 (per million tokens, Anthropic public list as of 2026-Q1).
+ * Override via `models.gpuRates` is for GPU rates only — Claude rates can
+ * be overridden via the per-model `cost: { input, output }` configuration
+ * on the user's `anthropic` provider entry, which already exists.
+ *
+ * Display: pick a target tier via `agents.defaults.cost.benchmark`, default
+ * `sonnet`. Setting `"all"` shows comparisons against all three tiers.
+ */
+import { type ModelCostConfig } from "../utils/usage-format.js";
+export type ClaudeTier = "opus" | "sonnet" | "haiku";
+/** Per-million-token USD rates, applied via `estimateUsageCost`. */
+export declare const CLAUDE_RATES: Record<ClaudeTier, ModelCostConfig>;
+export declare const CLAUDE_LABEL: Record<ClaudeTier, string>;
+export type BenchmarkResult = {
+    tier: ClaudeTier;
+    costUsd: number;
+};
+export type BenchmarkTarget = ClaudeTier | "all";
+export declare function benchmarkUsage(args: {
+    usage?: {
+        input?: number;
+        output?: number;
+    };
+    target: BenchmarkTarget;
+}): BenchmarkResult[];
+export declare function formatBenchmarkSuffix(args: {
+    ourCostUsd: number;
+    benchmarks: BenchmarkResult[];
+}): string | undefined;
+export declare function isClaudeTier(value: string): value is ClaudeTier;
+export declare function isBenchmarkTarget(value: string): value is BenchmarkTarget;
+export declare function resolveBenchmarkTarget(value: unknown): BenchmarkTarget;

package/dist/plugin-sdk/cost/breakdown.d.ts

@@ -0,0 +1,63 @@
+/**
+ * High-level cost breakdown orchestrator. Combines:
+ *   - Phase 1 serving discovery (engine + observed throughput)
+ *   - Phase 2 GPU inference (gpu type + count) + hourly rate lookup
+ *   - Phase 3 instance-derived per-token cost (added in Phase 3)
+ *   - Phase 4 Claude benchmark comparison (added in Phase 4)
+ *
+ * One async call per /status invocation produces all the display lines.
+ */
+import type { SymiConfig } from "../config/config.js";
+import { type BenchmarkResult, type BenchmarkTarget } from "./benchmark.js";
+import { type GpuInference } from "./gpu-inference.js";
+import { type ServingInfo } from "./serving-discovery.js";
+export type CostBreakdown = {
+    serving: ServingInfo | null;
+    gpu?: GpuInference;
+    hourlyRate?: number;
+    hourlyRateSource?: "config-override" | "model-override" | "default-table";
+    decodeTps?: number;
+    prefillTps?: number;
+    throughputSource?: "observed" | "default-table";
+    engineLine?: string;
+    hardwareLine?: string;
+    /**
+     * Estimated USD cost for the supplied usage (input/output token counts),
+     * derived from the instance hourly rate and inferred throughput. Computed
+     * only when raw per-token rates would yield $0 AND we have a usable
+     * (gpuType, hourlyRate) pair.
+     */
+    instanceCostUsd?: number;
+    /**
+     * Equivalent per-token average for the request (USD per token). Useful
+     * for UI display only; not authoritative.
+     */
+    perTokenAvgUsd?: number;
+    /**
+     * The actual cost figure used for display — either the per-token rate
+     * (when non-zero) or the instance-derived estimate. Stored here so
+     * downstream consumers don't need to re-implement the precedence.
+     */
+    effectiveCostUsd?: number;
+    /** Comparison results against Claude tiers. Empty when target is "none". */
+    benchmarks: BenchmarkResult[];
+    /** Human-readable suffix for the cost line (e.g. "vs Sonnet $0.23 (save 93%)"). */
+    costLineSuffix?: string;
+    /** Resolved benchmark target. */
+    benchmarkTarget: BenchmarkTarget | "none";
+};
+export type BuildBreakdownArgs = {
+    baseUrl?: string;
+    provider?: string;
+    modelId?: string;
+    config?: SymiConfig;
+    probeTimeoutMs?: number;
+    forceProbeRefresh?: boolean;
+    /** Token usage for the current request — used to compute instance-derived cost. */
+    usage?: {
+        input?: number;
+        output?: number;
+    };
+};
+export declare function buildCostBreakdown(args: BuildBreakdownArgs): Promise<CostBreakdown>;
+export declare function formatHardwareLine(breakdown: CostBreakdown): string | undefined;

package/dist/plugin-sdk/cost/gpu-inference.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Heuristic GPU type + count inference for self-hosted serving endpoints.
+ *
+ * Two signals: the baseUrl hostname (often encodes "a100", "h100", etc.) and
+ * the model id (encodes parameter count + quantization, e.g. "qwen36-27b-fp8").
+ * Output is a confidence-tagged guess so downstream code (and the user) can
+ * decide whether to trust the inference or override it.
+ *
+ * Bytes-per-parameter table:
+ *   fp32        → 4
+ *   fp16/bf16   → 2 (default when unspecified)
+ *   fp8/int8/q8 → 1
+ *   int4/q4/fp4 → 0.5
+ *
+ * GPU count formula:
+ *   model_bytes = params × bytes_per_param
+ *   target_util = 0.6 (40% headroom for KV cache, activations, scheduler)
+ *   count       = max(1, ceil(model_bytes / (vram × target_util)))
+ */
+import { type GpuType } from "./rates.js";
+export type GpuConfidence = "high" | "medium" | "low";
+export type GpuInference = {
+    gpuType?: GpuType;
+    gpuCount: number;
+    confidence: GpuConfidence;
+    paramsB?: number;
+    bytesPerParam?: number;
+    reasoning: string[];
+};
+export declare function inferGpuFromUrl(baseUrl: string): {
+    gpuType?: GpuType;
+    confidence: GpuConfidence;
+    match?: string;
+};
+export declare function parseModelSize(modelId: string): {
+    paramsB?: number;
+    bytesPerParam?: number;
+};
+export declare function inferGpuCount(args: {
+    paramsB?: number;
+    bytesPerParam?: number;
+    vramGb: number;
+    targetUtilization?: number;
+}): number;
+export declare function inferGpu(args: {
+    baseUrl?: string;
+    modelId?: string;
+    override?: {
+        gpuType?: string;
+        gpuCount?: number;
+    };
+}): GpuInference;

package/dist/plugin-sdk/cost/rates.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Hourly USD rates for self-hosted GPU instance types, sourced from public
+ * CoreWeave / RunPod / Lambda Cloud price pages (as of 2026-Q1).
+ *
+ * These are reference defaults — users override per-instance via
+ * `models.gpuRates: { "a100-80gb": 2.5 }` in symi.json, or per-model via
+ * `cost.hourlyRate: 4.42` on a specific provider model.
+ */
+export type GpuType = "a100-40gb" | "a100-80gb" | "h100-pcie" | "h100-sxm" | "h200" | "l40" | "l40s" | "a40" | "a6000" | "a5000" | "v100" | "mi300x" | "rtx-4090";
+export declare const GPU_VRAM_GB: Record<GpuType, number>;
+export declare const GPU_LABEL: Record<GpuType, string>;
+export declare const DEFAULT_HOURLY_RATES_USD: Record<GpuType, number>;
+/**
+ * Rough decode (output) throughput defaults in tokens/sec for a 27-30B FP8
+ * model on a single GPU of each type. Scales roughly inversely with model
+ * parameter count and bytes-per-param. Used as a fallback when no live
+ * `vllm:generation_tokens_total` delta has been observed yet.
+ *
+ * These are conservative published-benchmark medians; treat as ballpark.
+ * Override via `models.gpuRates` is rate-only; throughput overrides are
+ * Phase 4+ (not yet wired to config).
+ */
+export declare const DEFAULT_DECODE_TPS: Record<GpuType, number>;
+/**
+ * Prefill throughput is typically 30-60× higher than decode for a given
+ * setup. Use 40× as a balanced midpoint.
+ */
+export declare const PREFILL_DECODE_RATIO = 40;
+export declare function resolveDefaultDecodeTps(gpuType: GpuType, paramsB: number | undefined, bytesPerParam: number | undefined): number;
+export type HourlyRateOverrides = Partial<Record<string, number>>;
+export declare function resolveHourlyRate(gpuType: string, overrides?: HourlyRateOverrides): number | undefined;
+export declare function isKnownGpuType(value: string): value is GpuType;

package/dist/plugin-sdk/cost/serving-discovery.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Probe a self-hosted LLM serving endpoint (vLLM / SGLang / OpenAI-compatible)
+ * for engine fingerprint, observed throughput, and live queue/KV state.
+ *
+ * Each probe issues parallel GETs to /version, /v1/models, and /metrics and
+ * tolerates individual failures. Results are cached per baseUrl with a 60s
+ * TTL on success and a 5-minute TTL on null (so dead/hosted endpoints don't
+ * get re-probed on every /status call). Throughput is computed from the
+ * delta between successive `vllm:generation_tokens_total` snapshots; the
+ * first probe in a process records counters but reports tps=undefined.
+ */
+export type ServingEngine = "vllm" | "sglang" | "openai-compat" | "unknown";
+export type CacheConfigInfo = {
+    blockSize?: number;
+    numGpuBlocks?: number;
+    cacheDtype?: string;
+    gpuMemoryUtilization?: number;
+    enablePrefixCaching?: boolean;
+};
+export type ServingInfo = {
+    engine: ServingEngine;
+    version?: string;
+    modelId?: string;
+    contextWindow?: number;
+    observedTps?: number;
+    kvCacheUsagePerc?: number;
+    queueDepth?: number;
+    numRequestsRunning?: number;
+    cacheConfig?: CacheConfigInfo;
+    probedAt: number;
+    baseUrl: string;
+    rootUrl: string;
+};
+export type ProbeOptions = {
+    fetchImpl?: typeof fetch;
+    now?: () => number;
+    timeoutMs?: number;
+    forceRefresh?: boolean;
+};
+export declare function probeServingEndpoint(baseUrl: string, opts?: ProbeOptions): Promise<ServingInfo | null>;
+type ParsedMetrics = {
+    promptTokensTotal?: number;
+    generationTokensTotal?: number;
+    kvCacheUsagePerc?: number;
+    queueDepth?: number;
+    numRequestsRunning?: number;
+    cacheConfig?: CacheConfigInfo;
+    foundVllmPrefix: boolean;
+    foundSglangPrefix: boolean;
+};
+export declare function parsePrometheusMetrics(text: string): ParsedMetrics;
+export declare function formatEngineLine(info: ServingInfo | null | undefined): string | null;
+export declare function _resetServingDiscoveryCache(): void;
+export {};

package/dist/plugin-sdk/cost/summary.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Cumulative cost summary with Claude benchmark math.
+ *
+ * Wraps the existing `loadCostUsageSummary` (which scans all session JSONL
+ * transcripts in `~/.symi/sessions/...`) and augments each day's totals with
+ * what the same input/output token mix would have cost on each Claude tier.
+ *
+ * For self-hosted providers whose totals come back as $0 (because the user
+ * configured `cost: { input: 0, output: 0, ... }`), this wrapper does NOT
+ * retroactively re-cost — that would require provider+model attribution per
+ * day, which the current scanner doesn't preserve. Phase 5 captures the
+ * comparison surface; instance-derived per-day rebilling can be a Phase 6+
+ * follow-up if useful.
+ */
+import type { SymiConfig } from "../config/config.js";
+import { type CostUsageDailyEntry, type CostUsageSummary } from "../infra/session-cost-usage.js";
+import { type ClaudeTier } from "./benchmark.js";
+export type BenchmarkPerTier = Record<ClaudeTier, number>;
+export type CostSummaryDailyEntry = CostUsageDailyEntry & {
+    benchmarkUsd: BenchmarkPerTier;
+};
+export type CostBenchmarkSummary = Omit<CostUsageSummary, "daily"> & {
+    daily: CostSummaryDailyEntry[];
+    benchmarkTotals: BenchmarkPerTier;
+    /** Total potential savings vs each tier (negative values mean overspend). */
+    savingsTotals: BenchmarkPerTier;
+};
+export declare function loadCostBenchmarkSummary(params?: {
+    startMs?: number;
+    endMs?: number;
+    days?: number;
+    config?: SymiConfig;
+    agentId?: string;
+}): Promise<CostBenchmarkSummary>;
+export type CostSummaryWindow = "today" | "week" | "month" | "all";
+export declare function resolveWindow(window: CostSummaryWindow, now?: number): {
+    startMs: number;
+    endMs: number;
+};
+export declare function formatSummaryReport(summary: CostBenchmarkSummary, label?: string): string;

package/dist/plugin-sdk/index.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import fs, { constants, readFileSync } from "node:fs";
 import os from "node:os";
 import { Logger } from "tslog";
-import json5 from "json5";
+import JSON5 from "json5";
 import chalk, { Chalk } from "chalk";
 import fs$1, { mkdtemp, rm } from "node:fs/promises";
 import { z } from "zod";
@@ -294,7 +294,7 @@ function readLoggingConfig() {
 	try {
 		if (!fs.existsSync(configPath)) return;
 		const raw = fs.readFileSync(configPath, "utf-8");
-		const logging = json5.parse(raw)?.logging;
+		const logging = JSON5.parse(raw)?.logging;
 		if (!logging || typeof logging !== "object" || Array.isArray(logging)) return;
 		return logging;
 	} catch {
@@ -1048,7 +1048,10 @@ const ModelDefinitionSchema = z.object({
 		input: z.number().optional(),
 		output: z.number().optional(),
 		cacheRead: z.number().optional(),
-		cacheWrite: z.number().optional()
+		cacheWrite: z.number().optional(),
+		gpuType: z.string().optional(),
+		gpuCount: z.number().int().positive().optional(),
+		hourlyRate: z.number().nonnegative().optional()
 	}).strict().optional(),
 	contextWindow: z.number().positive().optional(),
 	maxTokens: z.number().positive().optional(),
@@ -1116,7 +1119,15 @@ const ModelsConfigSchema = z.object({
 	mode: z.union([z.literal("merge"), z.literal("replace")]).optional(),
 	providers: z.record(z.string(), ModelProviderSchema).optional(),
 	profiles: z.array(ModelProfileSchema).optional(),
-	bedrockDiscovery: BedrockDiscoverySchema
+	bedrockDiscovery: BedrockDiscoverySchema,
+	gpuRates: z.record(z.string(), z.number().nonnegative()).optional(),
+	benchmark: z.union([
+		z.literal("opus"),
+		z.literal("sonnet"),
+		z.literal("haiku"),
+		z.literal("all"),
+		z.literal("none")
+	]).optional()
 }).strict().optional();
 const GroupChatSchema = z.object({
 	mentionPatterns: z.array(z.string()).optional(),
@@ -7381,7 +7392,7 @@ function safeRealpath(target) {
 }
 const defaultResolver = {
 	readFile: (p) => fs.readFileSync(p, "utf-8"),
-	parseJson: (raw) => json5.parse(raw)
+	parseJson: (raw) => JSON5.parse(raw)
 };
 /**
 * Resolves all $include directives in a parsed config object.
@@ -10612,7 +10623,7 @@ function resolveConfigPathForDeps(deps) {
 function normalizeDeps(overrides = {}) {
 	return {
 		fs: overrides.fs ?? fs,
-		json5: overrides.json5 ?? json5,
+		json5: overrides.json5 ?? JSON5,
 		env: overrides.env ?? process.env,
 		homedir: overrides.homedir ?? (() => resolveRequiredHomeDir(overrides.env ?? process.env, os.homedir)),
 		configPath: overrides.configPath ?? "",
@@ -10623,11 +10634,11 @@ function maybeLoadDotEnvForConfig(env) {
 	if (env !== process.env) return;
 	loadDotEnv({ quiet: true });
 }
-function parseConfigJson5(raw, json5$1 = json5) {
+function parseConfigJson5(raw, json5 = JSON5) {
 	try {
 		return {
 			ok: true,
-			parsed: json5$1.parse(raw)
+			parsed: json5.parse(raw)
 		};
 	} catch (err) {
 		return {