tokmon 0.28.2 → 0.28.4

package/dist/{chunk-WUK3MQUB.js → chunk-JZSZEHVD.js}

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
 import {
-  PROVIDER_IDS
-} from "./chunk-HP5UZCXP.js";
+  BUILT_IN_THEME_PRESET_IDS,
+  DESKTOP_GRAPH_RANGES,
+  PROVIDER_IDS,
+  THEME_PRESET_IDS
+} from "./chunk-HNWEJ6MS.js";
 
 // src/rpc/contract.ts
 import { Schema } from "effect";
@@ -9,7 +12,7 @@ import * as Rpc from "effect/unstable/rpc/Rpc";
 import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
 var TOKMON_WS_PATH = "/ws";
 var TOKMON_PROTOCOL_VERSION = 3;
-var TOKMON_CAPABILITIES = ["config-cas", "config-revision", "allowed-hosts"];
+var TOKMON_CAPABILITIES = ["config-cas", "config-revision", "allowed-hosts", "tray-config", "usage-activity", "tray-pins", "provider-pins", "desktop-disclosure", "desktop-graph-range", "provider-headroom", "canonical-identity", "appearance-v1", "theme-engine", "account-detection-v1"];
 var TOKMON_WS_METHODS = {
   getConfig: "tokmon.getConfig",
   setConfig: "tokmon.setConfig",
@@ -35,6 +38,65 @@ var AccountSchema = Schema.Struct({
   homeDir: Schema.String,
   color: Schema.optionalKey(Schema.String)
 });
+var TrayConfigSchema = Schema.Struct({
+  enabled: Schema.Boolean,
+  showMenuBarText: Schema.Boolean,
+  displayMetric: Schema.Literals(["smartHeadroom", "tightestRemaining"]),
+  pollIntervalSec: Schema.Finite.check(Schema.isBetween({ minimum: 1, maximum: 86400 })),
+  activeTimeoutMin: Schema.Finite.check(Schema.isBetween({ minimum: 1, maximum: 1440 })),
+  graceMin: Schema.Finite.check(Schema.isBetween({ minimum: 1, maximum: 10080 })),
+  promotionHoldMin: Schema.Finite.check(Schema.isBetween({ minimum: 0, maximum: 1440 })),
+  lowWatermarkPct: Schema.Finite.check(Schema.isBetween({ minimum: 0, maximum: 100 })),
+  criticalWatermarkPct: Schema.Finite.check(Schema.isBetween({ minimum: 0, maximum: 100 })),
+  pinnedAccount: Schema.NullOr(Schema.String),
+  pins: Schema.Array(Schema.String),
+  // Additive since `tray-pins`: older daemons omit it, so tolerate absence and let
+  // `repairConfig` materialise the empty default rather than failing the decode.
+  pinnedProviders: Schema.optionalKey(Schema.Array(Schema.String)),
+  launchAtLogin: Schema.Boolean,
+  theme: Schema.Literal("dark")
+});
+var DesktopConfigSchema = Schema.Struct({
+  expandedProviders: Schema.Array(Schema.String),
+  graphRangeDays: Schema.optionalKey(Schema.Literals(DESKTOP_GRAPH_RANGES))
+});
+var AccountDetectionConfigSchema = Schema.Struct({
+  enabled: Schema.Boolean,
+  disabledProviders: Schema.Array(ProviderIdSchema),
+  excludedAccounts: Schema.Array(Schema.Struct({
+    providerId: ProviderIdSchema,
+    homeDir: Schema.String
+  }))
+});
+var HexColorSchema = Schema.String.check(Schema.isPattern(/^#[0-9a-f]{6}$/i));
+var ThemeOverridesSchema = Schema.Struct({
+  canvas: Schema.optionalKey(HexColorSchema),
+  panel: Schema.optionalKey(HexColorSchema),
+  inset: Schema.optionalKey(HexColorSchema),
+  insetStrong: Schema.optionalKey(HexColorSchema),
+  chrome: Schema.optionalKey(HexColorSchema),
+  line: Schema.optionalKey(HexColorSchema),
+  lineStrong: Schema.optionalKey(HexColorSchema),
+  lineFaint: Schema.optionalKey(HexColorSchema),
+  text: Schema.optionalKey(HexColorSchema),
+  textDim: Schema.optionalKey(HexColorSchema),
+  textFaint: Schema.optionalKey(HexColorSchema),
+  textStrong: Schema.optionalKey(HexColorSchema),
+  accent: Schema.optionalKey(HexColorSchema),
+  cost: Schema.optionalKey(HexColorSchema),
+  positive: Schema.optionalKey(HexColorSchema)
+});
+var AppearanceConfigSchema = Schema.Struct({
+  version: Schema.Literal(1),
+  mode: Schema.Literals(["auto", "light", "dark"]),
+  preset: Schema.Literals(THEME_PRESET_IDS),
+  terminal: Schema.Literals(["ansi", "dark", "light", "off"]),
+  custom: Schema.optionalKey(Schema.Struct({
+    base: Schema.Literals(BUILT_IN_THEME_PRESET_IDS),
+    light: ThemeOverridesSchema,
+    dark: ThemeOverridesSchema
+  }))
+});
 var ConfigSchema = Schema.Struct({
   revision: NonNegativeIntegerSchema,
   interval: PositiveFiniteSchema,
@@ -53,7 +115,17 @@ var ConfigSchema = Schema.Struct({
   allowNetworkAccess: Schema.Boolean,
   allowedHosts: Schema.Array(Schema.String),
   resetDisplay: Schema.Literals(["relative", "absolute"]),
-  knownProviders: Schema.Array(ProviderIdSchema)
+  knownProviders: Schema.Array(ProviderIdSchema),
+  // Additive under `appearance-v1`; omission is accepted for old clients and
+  // preserved by the daemon's CAS boundary rather than resetting the theme.
+  appearance: Schema.optionalKey(AppearanceConfigSchema),
+  // Additive: older clients omit detector policy, so the daemon preserves its
+  // current value and repairConfig supplies legacy current-behaviour defaults.
+  accountDetection: Schema.optionalKey(AccountDetectionConfigSchema),
+  // The complete tray block was added within protocol v3. Accept omission from
+  // older peers and normalize it at the client / preserve it at the CAS boundary.
+  tray: Schema.optionalKey(TrayConfigSchema),
+  desktop: Schema.optionalKey(DesktopConfigSchema)
 });
 var ProtocolInfoSchema = Schema.Struct({
   version: Schema.Literal(TOKMON_PROTOCOL_VERSION),
@@ -70,14 +142,46 @@ var ConfigUpdateRequestSchema = Schema.Struct({
   expectedRevision: NonNegativeIntegerSchema,
   config: ConfigSchema
 });
-var ConfigUpdateConflictSchema = Schema.Struct({
+var LegacyConfigUpdateConflictSchema = Schema.Struct({
   kind: Schema.Literal("conflict"),
   state: ConfigStateSchema
 });
-var ConfigPersistenceFailureSchema = Schema.Struct({
+var ConfigUpdateConflictFailure = class extends Schema.TaggedErrorClass()(
+  "ConfigUpdateConflictFailure",
+  {
+    kind: Schema.Literal("conflict"),
+    state: ConfigStateSchema
+  }
+) {
+};
+var LegacyConfigPersistenceFailureSchema = Schema.Struct({
   kind: Schema.Literal("persistence"),
   message: Schema.String
 });
+var ConfigPersistenceFailure = class extends Schema.TaggedErrorClass()(
+  "ConfigPersistenceFailure",
+  {
+    kind: Schema.Literal("persistence"),
+    message: Schema.String
+  }
+) {
+};
+var ConfigUpdateConflictSchema = Schema.Union([
+  ConfigUpdateConflictFailure,
+  LegacyConfigUpdateConflictSchema
+]);
+var ConfigPersistenceFailureSchema = Schema.Union([
+  ConfigPersistenceFailure,
+  LegacyConfigPersistenceFailureSchema
+]);
+var RefreshFailure = class extends Schema.TaggedErrorClass()(
+  "RefreshFailure",
+  {
+    kind: Schema.Literal("refresh"),
+    message: Schema.String
+  }
+) {
+};
 var FsEntrySchema = Schema.Struct({
   name: Schema.String,
   path: Schema.String,
@@ -123,7 +227,8 @@ var DashboardDataSchema = Schema.Struct({
   week: UsageSummarySchema,
   month: UsageSummarySchema,
   burnRate: Schema.Finite,
-  series: Schema.Array(Schema.Finite)
+  series: Schema.Array(Schema.Finite),
+  lastActivityAt: Schema.NullOr(NonNegativeIntegerSchema)
 });
 var TableDataSchema = Schema.Struct({
   daily: Schema.Array(TableRowSchema),
@@ -136,6 +241,10 @@ var MetricFormatSchema = Schema.Union([
   Schema.Struct({ kind: Schema.Literal("count"), suffix: Schema.optionalKey(Schema.String) })
 ]);
 var MetricSchema = Schema.Struct({
+  key: Schema.optionalKey(Schema.String),
+  role: Schema.optionalKey(Schema.Literals(["session", "weekly", "model", "other", "unbounded"])),
+  modelId: Schema.optionalKey(Schema.NullOr(Schema.String)),
+  active: Schema.optionalKey(Schema.Boolean),
   label: Schema.String,
   used: Schema.Finite,
   limit: Schema.NullOr(Schema.Finite),
@@ -143,6 +252,45 @@ var MetricSchema = Schema.Struct({
   resetsAt: Schema.optionalKey(Schema.NullOr(Schema.String)),
   primary: Schema.optionalKey(Schema.Boolean)
 });
+var MetricRoleSchema = Schema.Literals(["session", "weekly", "model", "other", "unbounded"]);
+var AccountIdentityViewSchema = Schema.Struct({
+  title: Schema.String,
+  subtitle: Schema.NullOr(Schema.String),
+  accessibleLabel: Schema.String,
+  redacted: Schema.Boolean
+});
+var QuotaViewSchema = Schema.Struct({
+  key: Schema.String,
+  label: Schema.String,
+  role: MetricRoleSchema,
+  modelId: Schema.NullOr(Schema.String),
+  usedPct: Schema.NullOr(Schema.Finite),
+  remainingPct: Schema.NullOr(Schema.Finite),
+  resetsAt: Schema.NullOr(NonNegativeIntegerSchema),
+  bounded: Schema.Boolean,
+  primary: Schema.Boolean,
+  active: Schema.Boolean,
+  displayOrder: NonNegativeIntegerSchema,
+  valueText: Schema.String
+});
+var HeadroomFactorSchema = Schema.Struct({
+  key: Schema.String,
+  label: Schema.String,
+  role: MetricRoleSchema,
+  remainingPct: Schema.Finite,
+  included: Schema.Boolean,
+  reason: Schema.Literals(["session", "active-model", "weekly-cap", "primary", "fallback-floor"])
+});
+var HeadroomViewSchema = Schema.Struct({
+  value: Schema.NullOr(Schema.Finite),
+  unit: Schema.Literal("index-100"),
+  mode: Schema.Literals(["smart", "single-window", "fallback-floor", "unavailable"]),
+  basis: Schema.Literals(["active", "idle-runway", "unavailable"]),
+  representativeAccountId: Schema.NullOr(Schema.String),
+  activeAccountIds: Schema.Array(Schema.String),
+  factors: Schema.Array(HeadroomFactorSchema),
+  explanation: Schema.String
+});
 var BillingResultSchema = Schema.Struct({
   plan: Schema.NullOr(Schema.String),
   metrics: Schema.Array(MetricSchema),
@@ -158,7 +306,7 @@ var BillingResultSchema = Schema.Struct({
     usd: Schema.Finite,
     requests: Schema.Finite
   })))),
-  asOfMs: Schema.optionalKey(Schema.Finite)
+  asOfMs: Schema.optionalKey(NonNegativeIntegerSchema)
 });
 var WebAccountSchema = Schema.Struct({
   id: Schema.String,
@@ -170,7 +318,11 @@ var WebAccountSchema = Schema.Struct({
   hasBilling: Schema.Boolean,
   email: Schema.optionalKey(Schema.NullOr(Schema.String)),
   displayName: Schema.optionalKey(Schema.NullOr(Schema.String)),
+  identity: Schema.optionalKey(AccountIdentityViewSchema),
+  quotas: Schema.optionalKey(Schema.Array(QuotaViewSchema)),
+  headroom: Schema.optionalKey(HeadroomViewSchema),
   plan: Schema.optionalKey(Schema.NullOr(Schema.String)),
+  lastActivityAt: Schema.NullOr(NonNegativeIntegerSchema),
   dashboard: Schema.NullOr(DashboardDataSchema),
   table: Schema.NullOr(TableDataSchema),
   billing: Schema.NullOr(BillingResultSchema),
@@ -190,7 +342,8 @@ var WebSnapshotSchema = Schema.Struct({
   providers: Schema.Array(Schema.Struct({
     id: ProviderIdSchema,
     name: Schema.String,
-    color: Schema.String
+    color: Schema.String,
+    headroom: Schema.optionalKey(HeadroomViewSchema)
   })),
   accounts: Schema.Array(WebAccountSchema),
   seeded: Schema.Boolean,
@@ -215,7 +368,8 @@ var SetConfigRpc = Rpc.make(TOKMON_WS_METHODS.setConfig, {
 });
 var RefreshRpc = Rpc.make(TOKMON_WS_METHODS.refresh, {
   payload: Schema.Struct({ scope: RefreshScopeSchema }),
-  success: Schema.Void
+  success: Schema.Void,
+  error: RefreshFailure
 });
 var BrowseFsRpc = Rpc.make(TOKMON_WS_METHODS.browseFs, {
   payload: Schema.Struct({ path: Schema.String }),
@@ -245,5 +399,8 @@ export {
   TOKMON_PROTOCOL_VERSION,
   TOKMON_CAPABILITIES,
   TOKMON_WS_METHODS,
+  ConfigUpdateConflictFailure,
+  ConfigPersistenceFailure,
+  RefreshFailure,
   TokmonRpcGroup
 };

package/dist/{chunk-6ZEW2M6P.js → chunk-P57DVFNH.js}

@@ -1,23 +1,32 @@
 #!/usr/bin/env node
+import {
+  resolveDaemonChannel
+} from "./chunk-UYPDMVW5.js";
 import {
   buildAccounts,
   colorHex,
+  deriveAccountIdentity,
+  deriveProviderHeadroom,
+  deriveQuotaViews,
   fetchPeak,
   namedHex
-} from "./chunk-44ZSQEOS.js";
+} from "./chunk-TN6V7XSL.js";
 import {
   PROVIDERS,
   detectProviders,
   resolveTimezone,
   withTimeout
-} from "./chunk-LCAHTRGP.js";
+} from "./chunk-CFKUZCMB.js";
 import {
+  ConfigPersistenceFailure,
+  ConfigUpdateConflictFailure,
+  RefreshFailure,
   TOKMON_CAPABILITIES,
   TOKMON_PROTOCOL_VERSION,
   TOKMON_WS_METHODS,
   TOKMON_WS_PATH,
   TokmonRpcGroup
-} from "./chunk-WUK3MQUB.js";
+} from "./chunk-JZSZEHVD.js";
 import {
   cacheDir,
   expandHome,
@@ -25,7 +34,7 @@ import {
   normalizeConfig,
   saveConfig,
   snapshotCacheFile
-} from "./chunk-HP5UZCXP.js";
+} from "./chunk-HNWEJ6MS.js";
 
 // src/web/server.ts
 import { createServer } from "http";
@@ -61,9 +70,13 @@ async function fetchAccountBilling(account, tz) {
   return p.fetchBilling(account, tz);
 }
 function assembleSnapshot(opts) {
+  const providerOrdinals = /* @__PURE__ */ new Map();
   const accounts = opts.resolved.map((r) => {
     const u = opts.usage.get(r.account.id);
     const billing = opts.billing.get(r.account.id) ?? null;
+    const ordinal = (providerOrdinals.get(r.account.providerId) ?? 0) + 1;
+    providerOrdinals.set(r.account.providerId, ordinal);
+    const quotas = deriveQuotaViews(billing?.metrics ?? []);
     return {
       id: r.account.id,
       providerId: r.account.providerId,
@@ -74,7 +87,22 @@ function assembleSnapshot(opts) {
       hasBilling: r.hasBilling,
       email: billing?.email ?? null,
       displayName: billing?.displayName ?? null,
+      identity: deriveAccountIdentity({
+        name: r.account.name,
+        email: billing?.email,
+        displayName: billing?.displayName,
+        providerName: PROVIDERS[r.account.providerId].name,
+        ordinal,
+        privacyMode: opts.config.privacyMode
+      }),
+      quotas,
+      headroom: deriveProviderHeadroom([{
+        id: r.account.id,
+        lastActivityAt: u?.dashboard?.lastActivityAt ?? null,
+        quotas
+      }], opts.config.tray.activeTimeoutMin, Date.now(), opts.config.tray.displayMetric),
       plan: billing?.plan ?? null,
+      lastActivityAt: u?.dashboard?.lastActivityAt ?? null,
       dashboard: u?.dashboard ?? null,
       table: u?.table ?? null,
       billing,
@@ -86,6 +114,12 @@ function assembleSnapshot(opts) {
       tableUpdatedAt: opts.tableUpdatedAt?.get(r.account.id) ?? null
     };
   });
+  const accountsByProvider = /* @__PURE__ */ new Map();
+  for (const account of accounts) {
+    const group = accountsByProvider.get(account.providerId) ?? [];
+    group.push(account);
+    accountsByProvider.set(account.providerId, group);
+  }
   const seen = /* @__PURE__ */ new Set();
   const providers = [];
   for (const r of opts.resolved) {
@@ -94,7 +128,17 @@ function assembleSnapshot(opts) {
     providers.push({
       id: r.account.providerId,
       name: PROVIDERS[r.account.providerId].name,
-      color: namedHex(PROVIDERS[r.account.providerId].color)
+      color: namedHex(PROVIDERS[r.account.providerId].color),
+      headroom: deriveProviderHeadroom(
+        (accountsByProvider.get(r.account.providerId) ?? []).map((account) => ({
+          id: account.id,
+          lastActivityAt: account.lastActivityAt,
+          quotas: account.quotas ?? []
+        })),
+        opts.config.tray.activeTimeoutMin,
+        Date.now(),
+        opts.config.tray.displayMetric
+      )
     });
   }
   return {
@@ -238,6 +282,7 @@ function isDevMode() {
   const forced = process.env.TOKMON_WEB_MODE;
   if (forced === "dev") return true;
   if (forced === "prod") return false;
+  if (process.env.NODE_TEST_CONTEXT) return false;
   return import.meta.url.includes("/src/");
 }
 function findWebSource() {
@@ -442,7 +487,8 @@ function createDataEngine(opts) {
     billingUpdatedAt,
     tableUpdatedAt,
     seeded,
-    peak
+    peak,
+    config: currentConfig
   });
   const hydrateFromCache = () => {
     try {
@@ -450,7 +496,11 @@ function createDataEngine(opts) {
       if (!cached || !Array.isArray(cached.accounts)) return;
       for (const a of cached.accounts) {
         if (a.dashboard || a.table) {
-          usage.set(a.id, { dashboard: a.dashboard, table: a.table });
+          const dashboard = a.dashboard ? {
+            ...a.dashboard,
+            lastActivityAt: typeof a.dashboard.lastActivityAt === "number" && Number.isSafeInteger(a.dashboard.lastActivityAt) && a.dashboard.lastActivityAt >= 0 ? a.dashboard.lastActivityAt : null
+          } : null;
+          usage.set(a.id, { dashboard, table: a.table });
           if (a.dashboard) {
             summaryState.set(a.id, "ready");
             if (typeof a.summaryUpdatedAt === "number") summaryUpdatedAt.set(a.id, a.summaryUpdatedAt);
@@ -689,6 +739,7 @@ function createDataEngine(opts) {
     broadcastConfig(config) {
       if (stopped) return;
       currentConfig = config;
+      rebuild();
       for (const onConfig of configSubscribers) {
         try {
           onConfig(config);
@@ -776,23 +827,51 @@ async function resolveEngineConfig(config) {
     billingIntervalMs: billingIntervalFor(config)
   };
 }
+function configAffectsEngine(previous, next) {
+  return previous.interval !== next.interval || previous.billingInterval !== next.billingInterval || previous.timezone !== next.timezone || JSON.stringify(previous.accounts) !== JSON.stringify(next.accounts) || JSON.stringify(previous.disabledProviders) !== JSON.stringify(next.disabledProviders) || JSON.stringify(previous.accountDetection) !== JSON.stringify(next.accountDetection);
+}
 var updateQueues = /* @__PURE__ */ new WeakMap();
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function mergeCapabilityFields(incomingConfig, current) {
+  const incoming = incomingConfig;
+  const incomingTray = incoming.tray;
+  const incomingDesktop = incoming.desktop;
+  return {
+    ...incoming,
+    appearance: hasOwn(incoming, "appearance") ? incoming.appearance : current.appearance,
+    accountDetection: hasOwn(incoming, "accountDetection") ? incoming.accountDetection : current.accountDetection,
+    tray: hasOwn(incoming, "tray") && incomingTray ? {
+      ...current.tray,
+      ...incomingTray,
+      pinnedProviders: hasOwn(incomingTray, "pinnedProviders") ? incomingTray.pinnedProviders : current.tray.pinnedProviders
+    } : current.tray,
+    desktop: hasOwn(incoming, "desktop") && incomingDesktop ? {
+      ...current.desktop,
+      ...incomingDesktop,
+      expandedProviders: hasOwn(incomingDesktop, "expandedProviders") ? incomingDesktop.expandedProviders : current.desktop.expandedProviders,
+      graphRangeDays: hasOwn(incomingDesktop, "graphRangeDays") ? incomingDesktop.graphRangeDays : current.desktop.graphRangeDays
+    } : current.desktop
+  };
+}
 async function applyConfigUpdateUnlocked(engine, state, input) {
   if (input.expectedRevision !== state.config.revision) {
     throw new ConfigConflictError(toConfigState(state.config));
   }
   const normalized = normalizeConfig({
-    ...input.config,
+    ...mergeCapabilityFields(input.config, state.config),
     revision: state.config.revision + 1
   });
-  const engineConfig = await resolveEngineConfig(normalized);
+  const reconfigureEngine = configAffectsEngine(state.config, normalized);
+  const engineConfig = reconfigureEngine ? await resolveEngineConfig(normalized) : null;
   try {
     await saveConfig(normalized);
   } catch (error) {
     throw new ConfigPersistenceError(error);
   }
   state.config = normalized;
-  engine.setConfig(engineConfig);
+  if (engineConfig) engine.setConfig(engineConfig);
   engine.broadcastConfig(normalized);
   return toConfigState(normalized);
 }
@@ -958,27 +1037,45 @@ function configStream(engine) {
     yield* Scope.addFinalizer(scope, Effect.sync(unsubscribe));
   }), { bufferSize: 16, strategy: "sliding" });
 }
-function toConfigUpdateFailure(error) {
+function configUpdateFailureEffect(error) {
   if (error instanceof ConfigConflictError) {
-    return { kind: "conflict", state: error.state };
+    return Effect.fail(new ConfigUpdateConflictFailure({ kind: "conflict", state: error.state }));
   }
   if (error instanceof ConfigPersistenceError) {
-    return { kind: "persistence", message: error.message };
+    return Effect.fail(new ConfigPersistenceFailure({ kind: "persistence", message: error.message }));
   }
-  return { kind: "persistence", message: error instanceof Error ? error.message : "config update failed" };
+  return Effect.die(error);
+}
+function configUpdateEffect(engine, state, input) {
+  return Effect.tryPromise({
+    try: () => applyConfigUpdate(engine, state, input),
+    catch: (error) => error
+  }).pipe(Effect.matchEffect({
+    onFailure: configUpdateFailureEffect,
+    onSuccess: Effect.succeed
+  }));
+}
+function refreshFailureEffect(error) {
+  return error instanceof AggregateError ? Effect.fail(new RefreshFailure({ kind: "refresh", message: error.message })) : Effect.die(error);
+}
+function refreshEffect(engine, scope) {
+  return Effect.tryPromise({
+    try: () => engine.refresh(scope),
+    catch: (error) => error
+  }).pipe(Effect.matchEffect({
+    onFailure: refreshFailureEffect,
+    onSuccess: Effect.succeed
+  }));
 }
 async function mountWsRpc(server, deps) {
   const scope = await Effect.runPromise(Scope.make());
   const wss = new NodeWS.WebSocketServer({ noServer: true });
   const handlersLayer = TokmonRpcGroup.toLayer(
     TokmonRpcGroup.of({
-      [TOKMON_WS_METHODS.getConfig]: () => Effect.tryPromise(() => Promise.resolve(deps.state.config ?? loadConfig()).then(toConfigState)),
-      [TOKMON_WS_METHODS.setConfig]: (config) => Effect.tryPromise({
-        try: () => applyConfigUpdate(deps.engine, deps.state, config),
-        catch: toConfigUpdateFailure
-      }),
-      [TOKMON_WS_METHODS.refresh]: ({ scope: scope2 }) => Effect.promise(() => deps.engine.refresh(scope2)),
-      [TOKMON_WS_METHODS.browseFs]: ({ path }) => Effect.tryPromise(() => listHomeDirectory(path)),
+      [TOKMON_WS_METHODS.getConfig]: () => Effect.promise(() => Promise.resolve(deps.state.config ?? loadConfig()).then(toConfigState)),
+      [TOKMON_WS_METHODS.setConfig]: (config) => configUpdateEffect(deps.engine, deps.state, config),
+      [TOKMON_WS_METHODS.refresh]: ({ scope: scope2 }) => refreshEffect(deps.engine, scope2),
+      [TOKMON_WS_METHODS.browseFs]: ({ path }) => Effect.promise(() => listHomeDirectory(path)),
       [TOKMON_WS_METHODS.snapshot]: () => snapshotStream(deps.engine),
       [TOKMON_WS_METHODS.config]: () => configStream(deps.engine).pipe(Stream.map(toConfigState))
     })
@@ -1068,7 +1165,7 @@ function guardSameOrigin(req, res) {
   }
   return true;
 }
-function createRouter(engine, state, vite, webRoot, wsToken, version, protocolVersion, capabilities, ownerKind) {
+function createRouter(engine, state, vite, webRoot, wsToken, version, protocolVersion, capabilities, ownerKind, channel) {
   return (req, res) => {
     const url = req.url || "/";
     const path = url.split("?")[0];
@@ -1087,6 +1184,7 @@ function createRouter(engine, state, vite, webRoot, wsToken, version, protocolVe
         protocolVersion,
         capabilities,
         ownerKind,
+        channel,
         // Discovery requires this proof; public health checks retain their useful 200 response.
         owner: tokenMatches(header2(req, "x-tokmon-token"), wsToken)
       });
@@ -1117,10 +1215,11 @@ function createRouter(engine, state, vite, webRoot, wsToken, version, protocolVe
 async function startWebServer(opts) {
   const state = { config: opts.config };
   const tz = tzFor(state.config);
-  const version = appVersion();
+  const version = opts.version ?? appVersion();
   const protocolVersion = opts.protocolVersion ?? TOKMON_PROTOCOL_VERSION;
   const capabilities = opts.capabilities ?? TOKMON_CAPABILITIES;
   const ownerKind = opts.ownerKind ?? "cli";
+  const channel = resolveDaemonChannel(opts.channel);
   const summaryIntervalMs = summaryIntervalFor(state.config);
   const billingIntervalMs = billingIntervalFor(state.config);
   const wsToken = opts.wsToken ?? randomBytes(32).toString("base64url");
@@ -1134,7 +1233,7 @@ async function startWebServer(opts) {
   let closeWsRpc = null;
   try {
     if (isDevMode()) vite = await createViteDevServer(server, log);
-    const webRoot = vite ? null : findWebRoot();
+    const webRoot = vite ? null : opts.webRoot ?? findWebRoot();
     if (!vite && !webRoot) log("  \u26A0 no dashboard available \u2014 see the page for build/dev instructions");
     engine = createDataEngine({ version, config: state.config, tz, summaryIntervalMs, billingIntervalMs, resolved });
     server.addListener("request", createRouter(
@@ -1146,7 +1245,8 @@ async function startWebServer(opts) {
       version,
       protocolVersion,
       capabilities,
-      ownerKind
+      ownerKind,
+      channel
     ));
     closeWsRpc = await mountWsRpc(server, { engine, state });
     const bindHost = state.config.allowNetworkAccess ? NETWORK_HOST : LOOPBACK_HOST;