@devries-cameron20 / t3code-1 / commits / 8e89fe1918
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

fix(server): usage no longer waits on Muse home discovery (#30859)

Julius Marminge committed Nov 11, 2026 at 15:22 UTC 8e89fe191808d3595c3d047f63fe63c9598a2e22
6 files changed +233 -65
apps/server/src/usage/UsageService.test.ts
+63 -1
@@ -12,6 +12,7 @@ import { vi } from "vite-plus/test";
12 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
13 import * as NodeServices from "@effect/platform-node/NodeServices";
14 import * as HostProcess from "@t3tools/shared/HostProcess";
15 +import { SpawnExecutableResolution } from "@t3tools/shared/shell";
16 import { mergeUsage } from "@t3tools/shared/usageMerge";
17 import {
18 EnvironmentId,
@@ -1120,7 +1121,7 @@ describe("UsageService", () => {
1121 };
1122 const muse = (summary: UsageSummary) =>
1123 summary.buckets.filter((bucket) => bucket.provider === "muse");
1123 - const first = yield* service.readSummary(window);
1124 + const first = yield* service.readSummary({ ...window, awaitRefresh: true });
1125 const buckets = muse(first);
1126 assert.strictEqual(
1127 buckets.reduce((sum, b) => sum + b.records, 0),
@@ -1202,6 +1203,7 @@ describe("UsageService", () => {
1203 assert.closeTo(repriced?.costUsd ?? NaN, 0.000486, 1e-12);
1204 }).pipe(
1205 Effect.scoped,
1206 + Effect.provideService(SpawnExecutableResolution, (command: string) => command),
1207 Effect.provide(
1208 layerService({
1209 prefix: "usage-muse",
@@ -1235,6 +1237,66 @@ describe("UsageService", () => {
1237 }).pipe(Effect.scoped),
1238 );
1239
1240 + it.live("returns other providers' usage while Muse home discovery is still pending", () =>
1241 + Effect.gen(function* () {
1242 + const { transcript, settings, home } = yield* setup;
1243 + yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));
1244 + const museStarted = yield* Deferred.make<void>();
1245 + const museReady = yield* Deferred.make<MuseSdk.MuseSdkHost>();
1246 + const museHome = NodePath.join(home, "muse");
1247 + yield* Effect.promise(() =>
1248 + NodeFSP.mkdir(NodePath.join(museHome, "sessions"), { recursive: true }),
1249 + );
1250 + using _create = vi
1251 + .spyOn(MuseSdk, "createMuseSdkHostEffect")
1252 + .mockImplementation(() =>
1253 + Deferred.succeed(museStarted, undefined).pipe(Effect.andThen(Deferred.await(museReady))),
1254 + );
1255 + const museSources = (summary: UsageSummary) =>
1256 + summary.sources
1257 + .filter((source) => source.fingerprint.provider === "muse")
1258 + .map((source) => [source.fingerprint.resolvedHomePath, source.status, source.refreshing]);
1259 + const [pending, refreshed] = yield* Effect.gen(function* () {
1260 + const service = yield* UsageService.make;
1261 + const read = yield* Effect.forkChild(service.readSummary(WINDOW));
1262 + yield* Deferred.await(museStarted);
1263 + const pending = yield* Fiber.join(read);
1264 + const refresh = yield* Effect.forkChild(
1265 + service.readSummary({ ...WINDOW, awaitRefresh: true }),
1266 + );
1267 + yield* Deferred.succeed(museReady, {
1268 + initializeResult: { grantedCapabilities: [], museHome },
1269 + close: async () => {},
1270 + } as unknown as MuseSdk.MuseSdkHost);
1271 + return [pending, yield* Fiber.join(refresh)] as const;
1272 + }).pipe(
1273 + Effect.scoped,
1274 + Effect.provideService(SpawnExecutableResolution, (command: string) => command),
1275 + Effect.provide(
1276 + layerService({
1277 + prefix: "usage-muse-pending",
1278 + home,
1279 + settings: {
1280 + ...settings,
1281 + providerInstances: {
1282 + ...settings.providerInstances,
1283 + [ProviderInstanceId.make("muse")]: {
1284 + driver: ProviderDriverKind.make("muse"),
1285 + enabled: false,
1286 + },
1287 + },
1288 + },
1289 + }),
1290 + ),
1291 + );
1292 + assert.strictEqual(totalOutputTokens(pending), 5);
1293 + assert.deepStrictEqual(museSources(pending), [["muse", "ok", true]]);
1294 + assert.deepStrictEqual(museSources(refreshed), [
1295 + [NodePath.join(museHome, "sessions"), "ok", undefined],
1296 + ]);
1297 + }).pipe(Effect.scoped),
1298 + );
1299 +
1300 it.live("reports missing Pi history and skips malformed records without losing valid usage", () =>
1301 Effect.gen(function* () {
1302 const { home, settings } = yield* setup;
apps/server/src/usage/UsageService.ts
+18 -7
@@ -330,16 +330,25 @@ export const make = Effect.gen(function* () {
330 const resolveTranscriptDirs = Effect.fn("UsageService.resolveTranscriptDirs")(function* (
331 settings: ServerSettingsValue,
332 retentionCutoffMs: number,
333 + awaitRefresh: boolean,
334 ) {
335 const dirs: Array<TranscriptSource> = [];
336 + const pending: Array<ScannedDir> = [];
337 const seen = new Set<string>();
338 for (const { driver, reader } of transcriptReaders) {
339 const { provider, format } = reader;
340 const directories = yield* Effect.forEach(
341 yield* usageInstances(driver, settings),
340 - (instance) => reader.directories(instance),
342 + (instance) => reader.directories(instance, { awaitRefresh }),
343 );
342 - for (const { dir: directory, fileName } of directories.flat()) {
344 + for (const { dir: directory, fileName, refreshing } of directories.flat()) {
345 + if (refreshing) {
346 + const key = `${provider}\0${directory}`;
347 + if (seen.has(key)) continue;
348 + seen.add(key);
349 + pending.push({ provider, dir: directory, volumeId: "", files: [], refreshing });
350 + continue;
351 + }
352 const sourceKey = provider + "\0" + directory;
353 const previous = sourceCache.get(sourceKey);
354 const dir = yield* fileSystem
@@ -375,7 +384,7 @@ export const make = Effect.gen(function* () {
384 });
385 }
386 }
378 - return dirs;
387 + return { dirs, pending };
388 });
389
390 // Share first loads so concurrent readers cannot scan against a still-empty cache.
@@ -654,9 +663,11 @@ export const make = Effect.gen(function* () {
663 retentionCutoffMs: number,
664 awaitRefresh: boolean,
665 ) {
657 - const dirs = yield* resolveTranscriptDirs(settings, retentionCutoffMs).pipe(
658 - Effect.provideContext(readerContext),
659 - );
666 + const { dirs, pending } = yield* resolveTranscriptDirs(
667 + settings,
668 + retentionCutoffMs,
669 + awaitRefresh,
670 + ).pipe(Effect.provideContext(readerContext));
671
672 const scans = Effect.forEach(
673 scanReaders,
@@ -690,7 +701,7 @@ export const make = Effect.gen(function* () {
701 [Effect.forEach(dirs, (dir) => scanTranscriptDir(dir, windowStartMs)), scans],
702 { concurrency: "unbounded" },
703 );
693 - const scanned: readonly ScannedDir[] = [...transcripts, ...scanDirs.flat()];
704 + const scanned: readonly ScannedDir[] = [...transcripts, ...pending, ...scanDirs.flat()];
705 return scanned;
706 });
707
packages/provider-core/src/server/usage.ts
+7 -1
@@ -111,10 +111,16 @@ export type ProviderUsageReader<Config, R> =
111 readonly resolveServiceTiers?: (
112 records: readonly UsageRecord[],
113 ) => Effect.Effect<ReadonlyMap<UsageRecord, UsageSpeed>, never, R>;
114 + /** A `refreshing` entry is not scanned; it reports its source as still being located. */
115 readonly directories: (
116 instance: ProviderUsageInstance<Config>,
117 + options: { readonly awaitRefresh: boolean },
118 ) => Effect.Effect<
117 - ReadonlyArray<{ readonly dir: string; readonly fileName?: string }>,
119 + ReadonlyArray<{
120 + readonly dir: string;
121 + readonly fileName?: string;
122 + readonly refreshing?: true;
123 + }>,
124 never,
125 R
126 >;
packages/provider-muse/src/server/MuseUsageHome.ts
+28 -8
@@ -4,24 +4,32 @@ import * as Duration from "effect/Duration";
4 import * as Effect from "effect/Effect";
5 import * as Exit from "effect/Exit";
6 import * as Layer from "effect/Layer";
7 +import * as Option from "effect/Option";
8 +
9 +import * as HostProcess from "@t3tools/shared/HostProcess";
10 +import { SpawnExecutableResolution } from "@t3tools/shared/shell";
11
12 import { createMuseSdkHostEffect, MuseSdkError } from "./sdk.ts";
13
14 export class MuseUsageHome extends Context.Service<
15 MuseUsageHome,
16 {
17 + /** None while discovery is still running and `awaitRefresh` is false. */
18 readonly resolve: (input: {
19 readonly binaryPath: string;
20 readonly environment: NodeJS.ProcessEnv;
16 - }) => Effect.Effect<string | undefined>;
21 + readonly awaitRefresh: boolean;
22 + }) => Effect.Effect<Option.Option<string | undefined>>;
23 }
24 >()("@t3tools/provider-muse/server/MuseUsageHome") {}
25
26 const make = Effect.gen(function* () {
27 + const scope = yield* Effect.scope;
28 const cache = yield* Cache.makeWith(
22 - Effect.fn("MuseUsageHome.initialize")(function* (
23 - input: Parameters<MuseUsageHome["Service"]["resolve"]>[0],
24 - ) {
29 + Effect.fn("MuseUsageHome.initialize")(function* (input: {
30 + readonly binaryPath: string;
31 + readonly environment: NodeJS.ProcessEnv;
32 + }) {
33 return yield* Effect.scoped(
34 Effect.gen(function* () {
35 const host = yield* Effect.acquireRelease(
@@ -35,7 +43,7 @@ const make = Effect.gen(function* () {
43 );
44 return host.initializeResult.museHome;
45 }),
38 - );
46 + ).pipe(Effect.orElseSucceed(() => undefined));
47 }),
48 {
49 capacity: 32,
@@ -45,15 +53,27 @@ const make = Effect.gen(function* () {
53 },
54 );
55 const resolve: MuseUsageHome["Service"]["resolve"] = Effect.fn("MuseUsageHome.resolve")(
48 - function* ({ binaryPath, environment }) {
56 + function* ({ binaryPath, environment, awaitRefresh }) {
57 // Cache keys compare structurally. Omitted and undefined variables both
58 // disappear from the child process environment and must share an entry.
51 - return yield* Cache.get(cache, {
59 + const key = {
60 binaryPath,
61 environment: Object.fromEntries(
62 Object.entries(environment).filter(([, value]) => value !== undefined),
63 ),
56 - }).pipe(Effect.orElseSucceed(() => undefined));
64 + };
65 + const settled = yield* Cache.getSuccess(cache, key);
66 + if (Option.isSome(settled)) return settled;
67 + // Spawn failures surface asynchronously; without this a missing CLI would report as pending.
68 + const resolveExecutable = yield* SpawnExecutableResolution;
69 + if (resolveExecutable(binaryPath, yield* HostProcess.Platform, environment) === undefined) {
70 + return Option.some(undefined);
71 + }
72 + if (awaitRefresh) return Option.some(yield* Cache.get(cache, key));
73 + // Awaited in the layer scope so a departing caller cannot cancel discovery.
74 + yield* Effect.forkIn(Cache.get(cache, key), scope, { startImmediately: true });
75 + // A lookup that settled synchronously needs no refresh.
76 + return yield* Cache.getSuccess(cache, key);
77 },
78 );
79 return MuseUsageHome.of({ resolve });
packages/provider-muse/src/server/usage.test.ts
+106 -45
@@ -2,6 +2,7 @@ import * as NodeServices from "@effect/platform-node/NodeServices";
2 import { ProviderInstanceId } from "@t3tools/contracts";
3 import { totalTokens } from "@t3tools/provider-core/server/usage";
4 import * as HostProcess from "@t3tools/shared/HostProcess";
5 +import { SpawnExecutableResolution } from "@t3tools/shared/shell";
6 import * as Effect from "effect/Effect";
7 import * as Deferred from "effect/Deferred";
8 import * as Fiber from "effect/Fiber";
@@ -190,6 +191,9 @@ it("handles malformed and partial data and rejects unsupported timestamps or sch
191 ).toEqual([]);
192 });
193
194 +const AWAIT_REFRESH = { awaitRefresh: true };
195 +const onPath = Effect.provideService(SpawnExecutableResolution, (command: string) => command);
196 +
197 describe("Muse history discovery", () => {
198 it.effect.each([undefined, "/custom/xdg-data"])(
199 "uses the initialized home with XDG_DATA_HOME=%s and closes without starting a session",
@@ -204,12 +208,15 @@ describe("Muse history discovery", () => {
208 } as unknown as MuseSdk.MuseSdkHost),
209 );
210 if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
207 - const directories = yield* museUsageReader.directories({
208 - instanceId: ProviderInstanceId.make("muse-other"),
209 - configured: true,
210 - config: decodeSettings({ binaryPath: "~/bin/custom-muse" }),
211 - environment: { XDG_DATA_HOME: xdg, MUSE_NO_AUTO_UPDATE: "0" },
212 - });
211 + const directories = yield* museUsageReader.directories(
212 + {
213 + instanceId: ProviderInstanceId.make("muse-other"),
214 + configured: true,
215 + config: decodeSettings({ binaryPath: "~/bin/custom-muse" }),
216 + environment: { XDG_DATA_HOME: xdg, MUSE_NO_AUTO_UPDATE: "0" },
217 + },
218 + AWAIT_REFRESH,
219 + );
220 expect(directories).toEqual([
221 { dir: path.join("/native/configured-home", "sessions"), fileName: "session.jsonl" },
222 ]);
@@ -226,6 +233,7 @@ describe("Muse history discovery", () => {
233 expect(close).toHaveBeenCalledOnce();
234 }).pipe(
235 Effect.provide([NodeServices.layer, MuseUsageHome.layer]),
236 + onPath,
237 Effect.provideService(HostProcess.HomeDirectory, "/test-home"),
238 Effect.provideService(HostProcess.Environment, {
239 PATH: "/host/bin",
@@ -234,6 +242,27 @@ describe("Muse history discovery", () => {
242 ),
243 );
244
245 + it.effect("reports no history without starting Muse when its CLI is not installed", () =>
246 + Effect.gen(function* () {
247 + using create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect");
248 + if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
249 + const directories = yield* museUsageReader.directories(
250 + {
251 + instanceId: ProviderInstanceId.make("muse"),
252 + configured: false,
253 + config: undefined,
254 + environment: {},
255 + },
256 + { awaitRefresh: false },
257 + );
258 + expect(directories).toEqual([]);
259 + expect(create).not.toHaveBeenCalled();
260 + }).pipe(
261 + Effect.provide([NodeServices.layer, MuseUsageHome.layer]),
262 + Effect.provideService(SpawnExecutableResolution, () => undefined),
263 + ),
264 + );
265 +
266 it.effect("does not guess a directory when initialization fails", () =>
267 Effect.gen(function* () {
268 using _create = vi
@@ -244,14 +273,17 @@ describe("Muse history discovery", () => {
273 ),
274 );
275 if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
247 - const directories = yield* museUsageReader.directories({
248 - instanceId: ProviderInstanceId.make("muse"),
249 - configured: false,
250 - config: undefined,
251 - environment: {},
252 - });
276 + const directories = yield* museUsageReader.directories(
277 + {
278 + instanceId: ProviderInstanceId.make("muse"),
279 + configured: false,
280 + config: undefined,
281 + environment: {},
282 + },
283 + AWAIT_REFRESH,
284 + );
285 expect(directories).toEqual([]);
254 - }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer])),
286 + }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer]), onPath),
287 );
288
289 it.effect(
@@ -273,21 +305,24 @@ describe("Muse history discovery", () => {
305 config: decodeSettings({ binaryPath: "~/bin/muse", enabled: false }),
306 environment: { PATH: "/bin", XDG_DATA_HOME: "/data" },
307 };
276 - const first = yield* museUsageReader.directories(instance);
277 - const second = yield* museUsageReader.directories({
278 - ...instance,
279 - instanceId: ProviderInstanceId.make("another-account"),
280 - config: decodeSettings({
281 - binaryPath: path.join("/test-home", "bin/muse"),
282 - enabled: true,
283 - }),
284 - environment: {
285 - XDG_DATA_HOME: "/data",
286 - PATH: "/bin",
287 - UNUSED: undefined,
288 - META_API_KEY: "ignored",
308 + const first = yield* museUsageReader.directories(instance, AWAIT_REFRESH);
309 + const second = yield* museUsageReader.directories(
310 + {
311 + ...instance,
312 + instanceId: ProviderInstanceId.make("another-account"),
313 + config: decodeSettings({
314 + binaryPath: path.join("/test-home", "bin/muse"),
315 + enabled: true,
316 + }),
317 + environment: {
318 + XDG_DATA_HOME: "/data",
319 + PATH: "/bin",
320 + UNUSED: undefined,
321 + META_API_KEY: "ignored",
322 + },
323 },
290 - });
324 + AWAIT_REFRESH,
325 + );
326 expect(second).toEqual(first);
327 expect(first).toEqual([
328 { dir: path.join("/native/home", "sessions"), fileName: "session.jsonl" },
@@ -296,6 +331,7 @@ describe("Muse history discovery", () => {
331 expect(close).toHaveBeenCalledOnce();
332 }).pipe(
333 Effect.provide([NodeServices.layer, MuseUsageHome.layer]),
334 + onPath,
335 Effect.provideService(HostProcess.HomeDirectory, "/test-home"),
336 Effect.provideService(HostProcess.Environment, {}),
337 ),
@@ -318,20 +354,26 @@ describe("Muse history discovery", () => {
354 config: undefined,
355 environment: {},
356 };
321 - const first = yield* museUsageReader.directories(instance);
357 + const first = yield* museUsageReader.directories(instance, AWAIT_REFRESH);
358 expect(
323 - yield* museUsageReader.directories({
324 - ...instance,
325 - config: decodeSettings({ binaryPath: "custom-muse" }),
326 - }),
359 + yield* museUsageReader.directories(
360 + {
361 + ...instance,
362 + config: decodeSettings({ binaryPath: "custom-muse" }),
363 + },
364 + AWAIT_REFRESH,
365 + ),
366 ).toEqual(first);
328 - const changed = yield* museUsageReader.directories({
329 - ...instance,
330 - environment: { XDG_DATA_HOME: "/other-data" },
331 - });
367 + const changed = yield* museUsageReader.directories(
368 + {
369 + ...instance,
370 + environment: { XDG_DATA_HOME: "/other-data" },
371 + },
372 + AWAIT_REFRESH,
373 + );
374 expect(changed).not.toEqual(first);
375 const inherited = yield* museUsageReader
334 - .directories(instance)
376 + .directories(instance, AWAIT_REFRESH)
377 .pipe(
378 Effect.provideService(HostProcess.Environment, { XDG_DATA_HOME: "/new-host-data" }),
379 );
@@ -340,11 +382,12 @@ describe("Muse history discovery", () => {
382 expect(create).toHaveBeenCalledTimes(4);
383 }).pipe(
384 Effect.provide([NodeServices.layer, MuseUsageHome.layer]),
385 + onPath,
386 Effect.provideService(HostProcess.Environment, { XDG_DATA_HOME: "/host-data" }),
387 ),
388 );
389
347 - it.effect("shares pending initialization across concurrent directory reads", () =>
390 + it.effect("reports pending discovery without waiting and shares it with awaiting reads", () =>
391 Effect.gen(function* () {
392 const started = yield* Deferred.make<void>();
393 const ready = yield* Deferred.make<MuseSdk.MuseSdkHost>();
@@ -361,11 +404,21 @@ describe("Muse history discovery", () => {
404 config: undefined,
405 environment: {},
406 };
407 + const pending = [{ dir: "muse", refreshing: true }];
408 + expect(yield* museUsageReader.directories(instance, { awaitRefresh: false })).toEqual(
409 + pending,
410 + );
411 + yield* Deferred.await(started);
412 const reads = yield* Effect.all(
365 - [museUsageReader.directories(instance), museUsageReader.directories(instance)],
413 + [
414 + museUsageReader.directories(instance, AWAIT_REFRESH),
415 + museUsageReader.directories(instance, AWAIT_REFRESH),
416 + ],
417 { concurrency: "unbounded" },
418 ).pipe(Effect.forkChild);
368 - yield* Deferred.await(started);
419 + expect(yield* museUsageReader.directories(instance, { awaitRefresh: false })).toEqual(
420 + pending,
421 + );
422 yield* Deferred.succeed(ready, {
423 initializeResult: { museHome: "/native/home" },
424 close,
@@ -373,9 +426,17 @@ describe("Muse history discovery", () => {
426 const [first, second] = yield* Fiber.join(reads);
427 expect(first).toEqual(second);
428 expect(first).toHaveLength(1);
429 + expect(yield* museUsageReader.directories(instance, { awaitRefresh: false })).toEqual(first);
430 + const uninstalled = Effect.provideService(SpawnExecutableResolution, () => undefined);
431 + expect(
432 + yield* museUsageReader.directories(instance, { awaitRefresh: false }).pipe(uninstalled),
433 + ).toEqual(first);
434 + expect(yield* museUsageReader.directories(instance, AWAIT_REFRESH).pipe(uninstalled)).toEqual(
435 + first,
436 + );
437 expect(create).toHaveBeenCalledOnce();
438 expect(close).toHaveBeenCalledOnce();
378 - }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer])),
439 + }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer]), onPath),
440 );
441
442 it.effect("briefly caches failed discovery and retries after installation recovers", () =>
@@ -400,12 +461,12 @@ describe("Muse history discovery", () => {
461 config: undefined,
462 environment: {},
463 };
403 - expect(yield* museUsageReader.directories(instance)).toEqual([]);
404 - expect(yield* museUsageReader.directories(instance)).toEqual([]);
464 + expect(yield* museUsageReader.directories(instance, AWAIT_REFRESH)).toEqual([]);
465 + expect(yield* museUsageReader.directories(instance, { awaitRefresh: false })).toEqual([]);
466 expect(create).toHaveBeenCalledOnce();
467 yield* TestClock.adjust("30 seconds");
407 - expect(yield* museUsageReader.directories(instance)).toHaveLength(1);
468 + expect(yield* museUsageReader.directories(instance, AWAIT_REFRESH)).toHaveLength(1);
469 expect(create).toHaveBeenCalledTimes(2);
409 - }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer])),
470 + }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer]), onPath),
471 );
472 });
packages/provider-muse/src/server/usage.ts
+11 -3
@@ -121,7 +121,10 @@ export const museUsageReader: ProviderUsageReader<
121 kind: "transcripts",
122 provider: "muse",
123 format: museUsageFormat,
124 - directories: Effect.fn("museUsageReader.directories")(function* ({ config, environment }) {
124 + directories: Effect.fn("museUsageReader.directories")(function* (
125 + { config, environment },
126 + { awaitRefresh },
127 + ) {
128 const path = yield* Path.Path;
129 const home = yield* HostProcess.HomeDirectory;
130 const usageHome = yield* MuseUsageHome.MuseUsageHome;
@@ -131,10 +134,15 @@ export const museUsageReader: ProviderUsageReader<
134 ),
135 yield* HostProcess.Environment,
136 );
137 + const binaryPath = expandHomePath(config?.binaryPath ?? "muse", home);
138 const museHome = yield* usageHome.resolve({
135 - binaryPath: expandHomePath(config?.binaryPath ?? "muse", home),
139 + binaryPath,
140 environment: makeMuseEnvironment(processEnvironment),
141 + awaitRefresh,
142 });
138 - return museHome ? [{ dir: path.join(museHome, "sessions"), fileName: "session.jsonl" }] : [];
143 + if (Option.isNone(museHome)) return [{ dir: binaryPath, refreshing: true }];
144 + return museHome.value
145 + ? [{ dir: path.join(museHome.value, "sessions"), fileName: "session.jsonl" }]
146 + : [];
147 }),
148 };