@devries-cameron20 / t3code-1 / commits / c893353618
Fork 0

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

feat(usage): include Muse Code session history (#22443)

Co-authored-by: Theo Browne <me@theo.li> Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Wiktor Golicz committed Oct 24, 2026 at 07:12 UTC c89335361870087b64a2fc6ba0f7f3459aa23f39
17 files changed +926 -7
apps/mobile/src/features/usage/usageProviders.ts
+3
@@ -9,6 +9,7 @@ export const PROVIDER_ORDER: readonly UsageProviderKind[] = [
9 "opencode",
10 "antigravity",
11 "pi",
12 + "muse",
13 ];
14
15 /** The usage series a provider driver reports under, or null for drivers without one. */
@@ -25,6 +26,7 @@ export const PROVIDER_LABEL: Record<UsageProviderKind, string> = {
26 opencode: "OpenCode",
27 antigravity: "Antigravity",
28 pi: "Pi",
29 + muse: "Muse Code",
30 };
31
32 export function useProviderColors(): Record<UsageProviderKind, string> {
@@ -37,6 +39,7 @@ export function useProviderColors(): Record<UsageProviderKind, string> {
39 opencode: "#5b9bbd",
40 antigravity: "#8c7bd1",
41 pi: "#4d9f8a",
42 + muse: "#0866ff",
43 };
44 }
45
apps/server/src/provider/builtInDrivers.ts
+3 -1
@@ -45,7 +45,8 @@ export type BuiltInUsageReadersEnv =
45 | ProviderUsageReaderEnv<typeof OpenCodeDriver>
46 | ProviderUsageReaderEnv<typeof AntigravityDriver>
47 | ProviderUsageReaderEnv<typeof CursorDriver>
48 - | ProviderUsageReaderEnv<typeof PiDriver>;
48 + | ProviderUsageReaderEnv<typeof PiDriver>
49 + | ProviderUsageReaderEnv<typeof MuseDriver>;
50
51 /**
52 * Aggregation keeps the first copy of a duplicate record, so the order is part
@@ -59,6 +60,7 @@ export const BUILT_IN_USAGE_DRIVERS: ReadonlyArray<
60 GrokDriver,
61 PiDriver,
62 OpenCodeDriver,
63 + MuseDriver,
64 AntigravityDriver,
65 CursorDriver,
66 ];
apps/server/src/server.ts
+2
@@ -168,6 +168,7 @@ import * as ResourceMonitorBinary from "./resourceTelemetry/ResourceMonitorBinar
168 import * as ProcessGroupMetrics from "./resourceTelemetry/ProcessGroupMetrics.ts";
169 import * as ResourceTelemetry from "./resourceTelemetry/ResourceTelemetry.ts";
170 import * as AntigravityUsage from "./provider/Drivers/AntigravityUsage.ts";
171 +import { MuseUsageHome } from "@t3tools/provider-muse/server";
172 import * as CursorAccountReader from "@t3tools/provider-cursor/server/CursorAccountReader";
173 import * as CursorKeychain from "@t3tools/provider-cursor/server/CursorKeychain";
174 import * as CursorUsageAccounts from "@t3tools/provider-cursor/server/CursorUsageAccounts";
@@ -269,6 +270,7 @@ const layerUsage = UsageService.layer.pipe(
270 Layer.provide(
271 Layer.mergeAll(
272 AntigravityUsage.layer,
273 + MuseUsageHome.layer,
274 CodexUsageHistory.layer,
275 CursorUsageAccounts.layer.pipe(
276 Layer.provide(CursorAccountReader.layer.pipe(Layer.provide(CursorKeychain.layer))),
apps/server/src/usage/UsageService.test.ts
+232
@@ -48,9 +48,19 @@ import * as AntigravityUsage from "../provider/Drivers/AntigravityUsage.ts";
48 import * as ProviderHostLive from "../provider/ProviderHostLive.ts";
49 import { totalTokens, type UsageRecord } from "@t3tools/provider-core/server/usage";
50 import * as UsageService from "./UsageService.ts";
51 +import * as MuseSdk from "../../../../packages/provider-muse/src/server/sdk.ts";
52 +import { MuseUsageHome } from "@t3tools/provider-muse/server";
53 import { encodeScanCache, SCAN_CACHE_FILE_NAME } from "./usageScanCache.ts";
54
55 vi.mock("node:fs/promises", { spy: true });
56 +vi.mock("../../../../packages/provider-muse/src/server/sdk.ts", async (importOriginal) => ({
57 + ...(await importOriginal<typeof MuseSdk>()),
58 + createMuseSdkHostEffect: vi.fn(() =>
59 + Effect.try(() => {
60 + throw new Error("Muse is not installed in this test");
61 + }),
62 + ),
63 +}));
64
65 const encodeUnknownJson = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown));
66 const encodeUnknownJsonString = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
@@ -137,6 +147,7 @@ const layerService = (input: {
147 CursorAccountReader.layer.pipe(Layer.provide(CursorKeychain.layer)),
148 ).pipe(
149 Layer.provideMerge(AntigravityUsage.layer),
150 + Layer.provideMerge(MuseUsageHome.layer),
151 Layer.provideMerge(ProviderHostLive.layer),
152 Layer.provideMerge(CodexUsageHistory.layer.pipe(Layer.provideMerge(Sqlite.layerMemory))),
153 Layer.provideMerge(Layer.mock(BackgroundPolicy.BackgroundPolicy)({})),
@@ -797,6 +808,227 @@ describe("UsageService", () => {
808 }).pipe(Effect.scoped),
809 );
810
811 + it.live(
812 + "reads Muse inference history once, persists appended usage, and reprices unknown models",
813 + () =>
814 + Effect.gen(function* () {
815 + const { home, settings } = yield* setup;
816 + const museHome = NodePath.join(home, "configured-data", "muse");
817 + const dir = NodePath.join(museHome, "sessions", "2026", "08", "01", "parent");
818 + const child = NodePath.join(dir, "subagent", "child");
819 + const entry = (
820 + id: string,
821 + sessionId = "parent",
822 + timestamp = "2026-08-01T00:00:00Z",
823 + model = "muse-unknown",
824 + ) => ({
825 + schema_version: 1,
826 + record_type: "event",
827 + payload_type: "runtime.session",
828 + payload_schema_version: 1,
829 + id,
830 + recorded_at: Date.parse(timestamp) * 1000 + 999,
831 + stream: { kind: "session", id: sessionId },
832 + payload: {
833 + source_run_record_id: id,
834 + event: {
835 + kind: "model_completed",
836 + model,
837 + usage: {
838 + input_tokens: 100,
839 + cached_tokens: 60,
840 + cache_read_tokens: 60,
841 + cache_write_tokens: 10,
842 + output_tokens: 20,
843 + reasoning_tokens: 8,
844 + },
845 + },
846 + },
847 + });
848 + const parent = entry("inference-1");
849 + const review = {
850 + ...entry("review", "child"),
851 + payload_schema_version: 3,
852 + payload: {
853 + event: {
854 + ...parent.payload.event,
855 + kind: "automated_review_completed",
856 + model: { model_id: "priced-model" },
857 + usage: {
858 + input_tokens: 100,
859 + cached_input_tokens: 60,
860 + output_tokens: 20,
861 + reasoning_tokens: 8,
862 + },
863 + },
864 + },
865 + };
866 + yield* Effect.promise(async () => {
867 + await NodeFSP.mkdir(child, { recursive: true });
868 + await NodeFSP.writeFile(
869 + NodePath.join(dir, "session.jsonl"),
870 + [
871 + parent,
872 + parent,
873 + {
874 + ...parent,
875 + payload: { event: { ...parent.payload.event, kind: "workflow_completed" } },
876 + },
877 + { ...parent, payload_type: "goal_usage_attribution" },
878 + entry("before", "parent", "2026-07-31T23:59:59.999Z"),
879 + entry("after", "parent", "2026-08-02T00:00:00Z"),
880 + ]
881 + .map((line) => encodeUnknownJsonString(line))
882 + .join("\n") + "\n{broken}\n",
883 + );
884 + await NodeFSP.writeFile(
885 + NodePath.join(child, "session.jsonl"),
886 + [
887 + { ...parent, id: "copied-envelope", stream: { kind: "session", id: "child" } },
888 + entry("child-inference", "child"),
889 + review,
890 + ]
891 + .map((line) => encodeUnknownJsonString(line))
892 + .join("\n") + "\n",
893 + );
894 + await NodeFSP.writeFile(
895 + NodePath.join(child, "telemetry.jsonl"),
896 + encodeUnknownJsonString(entry("not-a-session")) + "\n",
897 + );
898 + });
899 + using _create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockImplementation((options) =>
900 + Effect.succeed({
901 + initializeResult: {
902 + grantedCapabilities: [],
903 + museHome: NodePath.join(options.environment?.XDG_DATA_HOME ?? home, "muse"),
904 + },
905 + close: async () => {},
906 + } as unknown as MuseSdk.MuseSdkHost),
907 + );
908 + yield* Effect.gen(function* () {
909 + const service = yield* UsageService.make;
910 + const window = {
911 + timeZone: "UTC",
912 + sinceDay: UsageDay.make("2026-08-01"),
913 + untilDay: UsageDay.make("2026-08-01"),
914 + };
915 + const muse = (summary: UsageSummary) =>
916 + summary.buckets.filter((bucket) => bucket.provider === "muse");
917 + const first = yield* service.readSummary(window);
918 + const buckets = muse(first);
919 + assert.strictEqual(
920 + buckets.reduce((sum, b) => sum + b.records, 0),
921 + 3,
922 + );
923 + assert.strictEqual(
924 + buckets.reduce((sum, b) => sum + totalTokens(b.totals), 0),
925 + 360,
926 + );
927 + const unknown = buckets.find((b) => b.model === "muse-unknown");
928 + assert.strictEqual(unknown?.costSource, "unpriced");
929 + assert.strictEqual(unknown?.unpricedRecords, 2);
930 + assert.deepStrictEqual(unknown?.totals, {
931 + uncachedInputTokens: 60,
932 + cachedInputTokens: 120,
933 + cacheCreationTokens: 20,
934 + outputTokens: 40,
935 + reasoningTokens: 16,
936 + });
937 + const priced = buckets.find((b) => b.model === "priced-model");
938 + assert.strictEqual(priced?.costSource, "modelPriced");
939 + assert.closeTo(priced?.costUsd ?? NaN, 0.000172, 1e-12);
940 + assert.closeTo(priced?.cacheSavingsUsd ?? NaN, 0.000108, 1e-12);
941 + const sources = first.sources.filter((source) => source.fingerprint.provider === "muse");
942 + assert.strictEqual(sources.length, 1);
943 + assert.strictEqual(sources[0]?.scannedFiles, 2);
944 + assert.strictEqual(sources[0]?.distinctSessions, 2);
945 + const local = muse(
946 + yield* service.readSummary({ ...window, timeZone: "America/Los_Angeles" }),
947 + );
948 + assert.strictEqual(
949 + local.reduce((sum, b) => sum + b.records, 0),
950 + 1,
951 + );
952 + assert.strictEqual(local[0]?.day, "2026-08-01");
953 + const hourly = muse(
954 + yield* service.readSummary({
955 + ...window,
956 + resolution: "hour",
957 + sinceTime: "2026-08-01T00:00:00.000Z",
958 + untilTime: "2026-08-02T00:00:00.000Z",
959 + }),
960 + );
961 + assert.strictEqual(
962 + hourly.reduce((sum, b) => sum + b.records, 0),
963 + 3,
964 + );
965 + const appended = encodeUnknownJsonString(entry("appended", "child"));
966 + const file = NodePath.join(child, "session.jsonl");
967 + yield* Effect.promise(() => NodeFSP.appendFile(file, appended.slice(0, -10)));
968 + assert.deepStrictEqual(muse(yield* service.readSummary(window)), buckets);
969 + yield* service.awaitPersisted;
970 + const restarted = yield* UsageService.make;
971 + yield* Effect.promise(() => NodeFSP.appendFile(file, appended.slice(-10) + "\n"));
972 + const grown = muse(yield* restarted.readSummary(window));
973 + assert.strictEqual(
974 + grown.reduce((sum, b) => sum + b.records, 0),
975 + 4,
976 + );
977 + assert.strictEqual(
978 + grown.reduce((sum, b) => sum + totalTokens(b.totals), 0),
979 + 480,
980 + );
981 + const settingsService = yield* ServerSettings.ServerSettingsService;
982 + yield* settingsService.updateSettings({
983 + usagePriceOverrides: {
984 + "muse-unknown": {
985 + inputCostPerMillionTokens: 2,
986 + outputCostPerMillionTokens: 4,
987 + cacheReadCostPerMillionTokens: 0.2,
988 + cacheWriteCostPerMillionTokens: 1,
989 + },
990 + },
991 + });
992 + const repriced = muse(yield* restarted.readSummary(window)).find(
993 + (b) => b.model === "muse-unknown",
994 + );
995 + assert.strictEqual(repriced?.unpricedRecords, 0);
996 + assert.closeTo(repriced?.costUsd ?? NaN, 0.000486, 1e-12);
997 + }).pipe(
998 + Effect.scoped,
999 + Effect.provide(
1000 + layerService({
1001 + prefix: "usage-muse",
1002 + home,
1003 + environment: { XDG_DATA_HOME: NodePath.dirname(museHome) },
1004 + settings: {
1005 + ...settings,
1006 + providerInstances: {
1007 + ...settings.providerInstances,
1008 + [ProviderInstanceId.make("muse")]: {
1009 + driver: ProviderDriverKind.make("muse"),
1010 + enabled: false,
1011 + },
1012 + [ProviderInstanceId.make("muse-alias")]: {
1013 + driver: ProviderDriverKind.make("muse"),
1014 + enabled: false,
1015 + },
1016 + },
1017 + },
1018 + ratesDocument: {
1019 + "priced-model": {
1020 + input_cost_per_token: 0.000002,
1021 + output_cost_per_token: 0.000004,
1022 + cache_read_input_token_cost: 0.0000002,
1023 + cache_creation_input_token_cost: 0.0000002,
1024 + },
1025 + },
1026 + }),
1027 + ),
1028 + );
1029 + }).pipe(Effect.scoped),
1030 + );
1031 +
1032 it.live("reports missing Pi history and skips malformed records without losing valid usage", () =>
1033 Effect.gen(function* () {
1034 const { home, settings } = yield* setup;
apps/server/src/usage/usageTestFormats.ts
+3 -1
@@ -2,18 +2,20 @@ import type { UsageProviderKind } from "@t3tools/contracts";
2 import type { TranscriptUsageFormat } from "@t3tools/provider-core/server/usage";
3 import { piUsageFormat } from "@t3tools/provider-pi/server/usage";
4 import { grokUsageFormat } from "@t3tools/provider-grok/server/usage";
5 +import { museUsageFormat } from "@t3tools/provider-muse/server/usage";
6
7 import { claudeUsageFormat } from "../provider/Drivers/claudeUsage.ts";
8 import { codexUsageFormat } from "../provider/Drivers/codexUsage.ts";
9
10 export const TEST_FORMATS: Record<
10 - "claude" | "codex" | "grok" | "pi",
11 + "claude" | "codex" | "grok" | "pi" | "muse",
12 TranscriptUsageFormat<unknown>
13 > = {
14 claude: claudeUsageFormat,
15 codex: codexUsageFormat,
16 grok: grokUsageFormat,
17 pi: piUsageFormat,
18 + muse: museUsageFormat,
19 };
20
21 export const TEST_FORMAT_MAP = new Map<UsageProviderKind, TranscriptUsageFormat<unknown>>(
apps/server/src/usage/usageTranscriptStreaming.test.ts
+47
@@ -108,6 +108,53 @@ async function scan(
108 }
109
110 describe("large usage records", () => {
111 + it("streams Muse completion envelopes and resumes a partial appended event", async () => {
112 + const entry = {
113 + schema_version: 1,
114 + record_type: "event",
115 + payload_type: "runtime.session",
116 + payload_schema_version: 3,
117 + id: "envelope-1",
118 + recorded_at: 1_785_578_400_123_456,
119 + stream: { kind: "session", id: "parent" },
120 + payload: {
121 + source_run_record_id: "inference-1",
122 + event: {
123 + kind: "automated_review_completed",
124 + model: { model_id: "review-model" },
125 + usage: {
126 + input_tokens: 100,
127 + cached_input_tokens: 60,
128 + output_tokens: 20,
129 + reasoning_tokens: 8,
130 + },
131 + },
132 + },
133 + };
134 + const small = await scan([entry], "muse", "small-muse");
135 + expect(small.records[0]?.totals).toMatchObject({
136 + uncachedInputTokens: 40,
137 + cachedInputTokens: 60,
138 + });
139 + const path = NodePath.join(dir, "large-muse.jsonl");
140 + await NodeFSP.writeFile(path, JSON.stringify({ ...entry, discarded: { content } }) + "\n");
141 + const large = await readTranscriptRecords(path, "muse");
142 + expect(large?.records).toEqual(small.records);
143 + const appended = JSON.stringify({
144 + ...entry,
145 + id: "envelope-2",
146 + payload: { ...entry.payload, source_run_record_id: "inference-2" },
147 + });
148 + await NodeFSP.appendFile(path, appended.slice(0, -7));
149 + const partial = await readTranscriptRecords(path, "muse", large!.position);
150 + expect(partial?.records).toEqual([]);
151 + await NodeFSP.appendFile(path, appended.slice(-7) + "\n");
152 + const completed = await readTranscriptRecords(path, "muse", partial!.position);
153 + expect(completed?.records).toHaveLength(1);
154 + expect(completed?.records[0]?.dedupeKey).not.toBe(large?.records[0]?.dedupeKey);
155 + expect(completed?.records[0]?.totals).toEqual(small.records[0]?.totals);
156 + });
157 +
158 it("keeps Pi model, cost, and fork identity after large assistant content", async () => {
159 const entry = {
160 type: "message",
apps/web/src/components/usage/UsageProviderChart.test.ts
+4 -2
@@ -9,12 +9,13 @@ describe("buildPeriodColumns", () => {
9 "2026-08-01",
10 {
11 day: "2026-08-01",
12 - costUsd: 35,
13 - totalTokens: 350,
12 + costUsd: 42,
13 + totalTokens: 420,
14 byProvider: new Map([
15 ["codex" as const, { costUsd: 10, totalTokens: 100 }],
16 ["claude" as const, { costUsd: 20, totalTokens: 200 }],
17 ["pi" as const, { costUsd: 5, totalTokens: 50 }],
18 + ["muse" as const, { costUsd: 7, totalTokens: 70 }],
19 ]),
20 },
21 ],
@@ -40,6 +41,7 @@ describe("buildPeriodColumns", () => {
41 { provider: "opencode", value: 0 },
42 { provider: "antigravity", value: 0 },
43 { provider: "pi", value: 5 },
44 + { provider: "muse", value: 7 },
45 ]);
46 });
47 });
apps/web/src/components/usage/usageProviders.ts
+5
@@ -40,6 +40,11 @@ export const PROVIDER_PRESENTATION = {
40 color: "#4d9f8a",
41 driverKind: ProviderDriverKind.make("pi"),
42 },
43 + muse: {
44 + label: "Muse Code",
45 + color: "#0866ff",
46 + driverKind: ProviderDriverKind.make("muse"),
47 + },
48 } satisfies Record<UsageProviderKind, UsageProviderPresentation>;
49
50 export const PROVIDER_ORDER = Object.keys(PROVIDER_PRESENTATION) as UsageProviderKind[];
docs/user/usage.md
+4 -1
@@ -6,7 +6,7 @@ desktop when the terminal is not focused. Customize `usage.open` in
6
7 ## Understand your usage
8
9 -**Usage** combines Codex, Claude Code, Grok Build, OpenCode, Antigravity, Pi, and Cursor history
9 +**Usage** combines Codex, Claude Code, Grok Build, OpenCode, Antigravity, Pi, Muse Code, and Cursor history
10 from your connected environments. It shows token use, cache savings, model breakdowns, and estimated API-equivalent
11 cost, split by token type and by speed. These estimates are not your subscription bill.
12 **Premium** is what Fast and Ultrafast requests cost above standard rates. Cost that cannot be
@@ -34,6 +34,9 @@ variable. Pi reads `~/.pi/agent/sessions`, or the `sessions` directory under
34 `PI_CODING_AGENT_DIR`. Set `PI_CODING_AGENT_SESSION_DIR` to read a different session directory.
35 To include sessions saved through `--session-dir` or Pi's `sessionDir` setting, set this environment
36 variable to the same directory. Pi includes recorded tool and summary costs under `Tools/summaries`.
37 +Muse Code reads native session history, including child sessions, from the home reported by the
38 +configured Muse CLI. Its environment settings, including `XDG_DATA_HOME`, apply. Models without
39 +known prices still contribute tokens and appear as unpriced; set custom prices to estimate their cost.
40 Use absolute paths or `~/` paths in the account's environment settings; relative environment paths
41 depend on each project's working directory and cannot be reliably discovered by Usage. Accounts
42 sharing a history directory count once.
packages/contracts/src/usage.ts
+1
@@ -19,6 +19,7 @@ export const UsageProviderKind = Schema.Literals([
19 "opencode",
20 "antigravity",
21 "pi",
22 + "muse",
23 ]);
24 export type UsageProviderKind = typeof UsageProviderKind.Type;
25
packages/provider-muse/package.json
+4
@@ -15,6 +15,10 @@
15 "types": "./src/server.ts",
16 "import": "./src/server.ts"
17 },
18 + "./server/usage": {
19 + "types": "./src/server/usage.ts",
20 + "import": "./src/server/usage.ts"
21 + },
22 "./testing": {
23 "types": "./src/testing.ts",
24 "import": "./src/testing.ts"
packages/provider-muse/src/server.ts
+1
@@ -1,2 +1,3 @@
1 export { MuseDriver, type MuseDriverEnv } from "./server/driver.ts";
2 +export * as MuseUsageHome from "./server/MuseUsageHome.ts";
3 export { makeMuseAdapterV2, type MuseAdapterV2Options } from "./server/adapter.ts";
packages/provider-muse/src/server/MuseUsageHome.ts new
+58
@@ -0,0 +1,58 @@
1 +import * as Cache from "effect/Cache";
2 +import * as Context from "effect/Context";
3 +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 +
8 +import { createMuseSdkHostEffect } from "./sdk.ts";
9 +
10 +export class MuseUsageHome extends Context.Service<
11 + MuseUsageHome,
12 + {
13 + readonly resolve: (input: {
14 + readonly binaryPath: string;
15 + readonly environment: NodeJS.ProcessEnv;
16 + }) => Effect.Effect<string | undefined>;
17 + }
18 +>()("@t3tools/provider-muse/server/MuseUsageHome") {}
19 +
20 +const make = Effect.gen(function* () {
21 + const cache = yield* Cache.makeWith(
22 + Effect.fn("MuseUsageHome.initialize")(function* (
23 + input: Parameters<MuseUsageHome["Service"]["resolve"]>[0],
24 + ) {
25 + return yield* Effect.scoped(
26 + Effect.gen(function* () {
27 + const host = yield* Effect.acquireRelease(
28 + createMuseSdkHostEffect({ ...input, readOnly: true, startupTimeoutMs: 5_000 }),
29 + (host) => Effect.tryPromise(() => host.close()).pipe(Effect.ignore),
30 + { interruptible: true },
31 + );
32 + return host.initializeResult.museHome;
33 + }),
34 + );
35 + }),
36 + {
37 + capacity: 32,
38 + // Retry unavailable installations, but keep resolved homes across scans.
39 + timeToLive: (exit) =>
40 + Exit.isSuccess(exit) && exit.value ? Duration.infinity : Duration.seconds(30),
41 + },
42 + );
43 + const resolve: MuseUsageHome["Service"]["resolve"] = Effect.fn("MuseUsageHome.resolve")(
44 + function* ({ binaryPath, environment }) {
45 + // Cache keys compare structurally. Omitted and undefined variables both
46 + // disappear from the child process environment and must share an entry.
47 + return yield* Cache.get(cache, {
48 + binaryPath,
49 + environment: Object.fromEntries(
50 + Object.entries(environment).filter(([, value]) => value !== undefined),
51 + ),
52 + }).pipe(Effect.orElseSucceed(() => undefined));
53 + },
54 + );
55 + return MuseUsageHome.of({ resolve });
56 +});
57 +
58 +export const layer = Layer.effect(MuseUsageHome, make);
packages/provider-muse/src/server/driver.ts
+8 -1
@@ -22,6 +22,8 @@ import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEve
22 import { makeManagedServerProvider } from "@t3tools/provider-core/server/managedProvider";
23 import { enrichMuseSnapshot, latestMuseVersion, museMaintenance } from "./maintenance.ts";
24 import { makeMuseEnvironment } from "./sdk.ts";
25 +import { museUsageReader } from "./usage.ts";
26 +import type * as MuseUsageHome from "./MuseUsageHome.ts";
27 import {
28 defaultProviderContinuationIdentity,
29 type ProviderDriver,
@@ -53,9 +55,14 @@ export type MuseDriverEnv =
55 | Path.Path
56 | ProviderEventLoggers.ProviderEventLoggers;
57
56 -export const MuseDriver: ProviderDriver<MuseSettings, MuseDriverEnv> = {
58 +export const MuseDriver: ProviderDriver<
59 + MuseSettings,
60 + MuseDriverEnv,
61 + Path.Path | MuseUsageHome.MuseUsageHome
62 +> = {
63 driverKind: DRIVER_KIND,
64 metadata: { displayName: "Muse Code", supportsMultipleInstances: true },
65 + usage: museUsageReader,
66 configSchema: MuseSettings,
67 defaultConfig: () => decodeMuseSettings({}),
68 create: Effect.fn("MuseDriver.create")(function* ({
packages/provider-muse/src/server/sdk.ts
+2 -1
@@ -25,7 +25,8 @@ export interface MuseSdkHost {
25 | "onProtocolError"
26 | "closed"
27 >;
28 - readonly initializeResult: Pick<SpawnedMspConnection["initializeResult"], "grantedCapabilities">;
28 + readonly initializeResult: Pick<SpawnedMspConnection["initializeResult"], "grantedCapabilities"> &
29 + Partial<Pick<SpawnedMspConnection["initializeResult"], "museHome">>;
30 readonly exited: Promise<ProcessExit>;
31 readonly stderrTail?: () => ReadonlyArray<string>;
32 readonly close: () => Promise<void>;
packages/provider-muse/src/server/usage.test.ts new
+409
@@ -0,0 +1,409 @@
1 +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 * as Effect from "effect/Effect";
6 +import * as Deferred from "effect/Deferred";
7 +import * as Fiber from "effect/Fiber";
8 +import * as TestClock from "effect/testing/TestClock";
9 +import * as Path from "effect/Path";
10 +import * as Schema from "effect/Schema";
11 +import { it } from "@effect/vitest";
12 +import { describe, expect, vi } from "vite-plus/test";
13 +import { MuseSettings } from "../settings.ts";
14 +import * as MuseSdk from "./sdk.ts";
15 +import * as MuseUsageHome from "./MuseUsageHome.ts";
16 +import { museUsageFormat, museUsageReader } from "./usage.ts";
17 +
18 +vi.mock("./sdk.ts", { spy: true });
19 +
20 +const entry = () => ({
21 + schema_version: 1,
22 + record_type: "event",
23 + payload_type: "runtime.session",
24 + payload_schema_version: 1,
25 + id: "envelope-1",
26 + recorded_at: 1_785_578_400_123_456,
27 + stream: { kind: "session", id: "session-1" },
28 + payload: {
29 + source_run_record_id: "inference-1",
30 + event: {
31 + kind: "model_completed",
32 + model: "muse-wonder-full-1.0",
33 + usage: {
34 + input_tokens: 100,
35 + cached_tokens: 60,
36 + cache_read_tokens: 60,
37 + cache_write_tokens: 10,
38 + output_tokens: 20,
39 + reasoning_tokens: 8,
40 + },
41 + },
42 + },
43 +});
44 +const decodeSettings = Schema.decodeSync(MuseSettings);
45 +const parse = (value: unknown) => museUsageFormat.parseLine(JSON.stringify(value), undefined);
46 +
47 +it("normalizes inclusive cache and reasoning counters without doubling the subsets", () => {
48 + const [record] = parse(entry());
49 + expect(record).toMatchObject({
50 + provider: "muse",
51 + timestampMs: Date.parse("2026-08-01T10:00:00.123Z"),
52 + sessionId: "session-1",
53 + model: "muse-wonder-full-1.0",
54 + reportedCostUsd: null,
55 + totals: {
56 + uncachedInputTokens: 30,
57 + cachedInputTokens: 60,
58 + cacheCreationTokens: 10,
59 + outputTokens: 20,
60 + reasoningTokens: 8,
61 + },
62 + });
63 + expect(totalTokens(record!.totals)).toBe(120);
64 + const value = entry();
65 + const { cache_read_tokens: _read, ...usage } = value.payload.event.usage;
66 + expect(
67 + parse({ ...value, payload: { ...value.payload, event: { ...value.payload.event, usage } } }),
68 + ).toEqual([record]);
69 +});
70 +
71 +it("keeps individual inference identity across copied parent/child envelopes", () => {
72 + const original = entry();
73 + const [first] = parse(original);
74 + const [copy] = parse({ ...original, id: "copy", stream: { kind: "session", id: "child" } });
75 + expect(copy?.dedupeKey).toBe(first?.dedupeKey);
76 + const next = entry();
77 + next.payload.source_run_record_id = "inference-2";
78 + expect(parse(next)[0]?.dedupeKey).not.toBe(first?.dedupeKey);
79 + const { source_run_record_id: _source, ...payload } = original.payload;
80 + const fallback = parse({ ...original, payload });
81 + expect(fallback[0]?.dedupeKey).toBe(JSON.stringify(["muse", original.id]));
82 +});
83 +
84 +it("includes automated review inference models and ignores workflow and telemetry rollups", () => {
85 + const value = entry();
86 + expect(
87 + parse({
88 + ...value,
89 + payload: {
90 + ...value.payload,
91 + event: {
92 + ...value.payload.event,
93 + kind: "automated_review_completed",
94 + model: { model_id: "review-model", provider_id: "meta" },
95 + },
96 + },
97 + })[0]?.model,
98 + ).toBe("review-model");
99 + for (const kind of [
100 + "workflow_completed",
101 + "goal_usage_attribution",
102 + "turn_completed",
103 + "usage_summary",
104 + ]) {
105 + expect(
106 + parse({ ...value, payload: { ...value.payload, event: { ...value.payload.event, kind } } }),
107 + ).toEqual([]);
108 + }
109 + expect(parse({ ...value, payload_type: "run.telemetry" })).toEqual([]);
110 + expect(parse({ ...value, record_type: "snapshot" })).toEqual([]);
111 + expect(parse({ ...value, stream: { kind: "run", id: "run-1" } })).toEqual([]);
112 +});
113 +
114 +it("includes native version 3 automated review inferences", () => {
115 + const value = entry();
116 + const review = {
117 + ...value,
118 + payload_schema_version: 3,
119 + payload: {
120 + ...value.payload,
121 + event: {
122 + ...value.payload.event,
123 + kind: "automated_review_completed",
124 + model: { provider_id: "meta", model_id: "review-model", reasoning_effort: "high" },
125 + usage: {
126 + input_tokens: 100,
127 + cached_input_tokens: 60,
128 + output_tokens: 20,
129 + reasoning_tokens: 8,
130 + },
131 + },
132 + },
133 + };
134 + expect(parse(review)).toEqual([
135 + {
136 + ...parse(value)[0],
137 + model: "review-model",
138 + totals: {
139 + uncachedInputTokens: 40,
140 + cachedInputTokens: 60,
141 + cacheCreationTokens: 0,
142 + outputTokens: 20,
143 + reasoningTokens: 8,
144 + },
145 + },
146 + ]);
147 + expect(museUsageFormat.parseProjected(review, undefined)).toEqual(parse(review));
148 +});
149 +
150 +it("handles malformed and partial data and rejects unsupported timestamps or schemas", () => {
151 + expect(museUsageFormat.parseLine("not json", undefined)).toEqual([]);
152 + expect(museUsageFormat.parseLine(JSON.stringify(entry()).slice(0, -1), undefined)).toEqual([]);
153 + for (const recorded_at of [NaN, Infinity, -1, "1785578400123456", Number.MAX_SAFE_INTEGER + 1]) {
154 + expect(museUsageFormat.parseProjected({ ...entry(), recorded_at }, undefined)).toEqual([]);
155 + }
156 + expect(parse({ ...entry(), schema_version: 2 })).toEqual([]);
157 + expect(parse({ ...entry(), payload_schema_version: 2 })).toEqual([]);
158 + expect(parse({ ...entry(), id: "" })).toEqual([]);
159 + expect(parse({ ...entry(), payload: { event: { kind: "model_completed" } } })).toEqual([]);
160 + const value = entry();
161 + const result = parse({
162 + ...value,
163 + payload: {
164 + event: {
165 + ...value.payload.event,
166 + usage: {
167 + input_tokens: 10,
168 + cache_read_tokens: 20,
169 + cache_write_tokens: 8,
170 + output_tokens: 3,
171 + reasoning_tokens: 9,
172 + },
173 + },
174 + },
175 + });
176 + expect(result[0]?.totals).toEqual({
177 + uncachedInputTokens: 0,
178 + cachedInputTokens: 10,
179 + cacheCreationTokens: 0,
180 + outputTokens: 3,
181 + reasoningTokens: 3,
182 + });
183 + expect(
184 + parse({
185 + ...value,
186 + payload: {
187 + event: { ...value.payload.event, usage: { input_tokens: -5, output_tokens: "20" } },
188 + },
189 + }),
190 + ).toEqual([]);
191 +});
192 +
193 +describe("Muse history discovery", () => {
194 + it.effect.each([undefined, "/custom/xdg-data"])(
195 + "uses the initialized home with XDG_DATA_HOME=%s and closes without starting a session",
196 + (xdg) =>
197 + Effect.gen(function* () {
198 + const path = yield* Path.Path;
199 + const close = vi.fn(async () => {});
200 + using create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockReturnValue(
201 + Effect.succeed({
202 + initializeResult: { grantedCapabilities: [], museHome: "/native/configured-home" },
203 + close,
204 + } as unknown as MuseSdk.MuseSdkHost),
205 + );
206 + 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 + });
213 + expect(directories).toEqual([
214 + { dir: path.join("/native/configured-home", "sessions"), fileName: "session.jsonl" },
215 + ]);
216 + expect(create).toHaveBeenCalledWith({
217 + binaryPath: path.join("/test-home", "bin/custom-muse"),
218 + environment: {
219 + PATH: "/host/bin",
220 + XDG_DATA_HOME: xdg ?? "/host/data",
221 + MUSE_NO_AUTO_UPDATE: "1",
222 + },
223 + readOnly: true,
224 + startupTimeoutMs: 5_000,
225 + });
226 + expect(close).toHaveBeenCalledOnce();
227 + }).pipe(
228 + Effect.provide([NodeServices.layer, MuseUsageHome.layer]),
229 + Effect.provideService(HostProcess.HomeDirectory, "/test-home"),
230 + Effect.provideService(HostProcess.Environment, {
231 + PATH: "/host/bin",
232 + XDG_DATA_HOME: "/host/data",
233 + }),
234 + ),
235 + );
236 +
237 + it.effect("does not guess a directory when initialization fails", () =>
238 + Effect.gen(function* () {
239 + using _create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockReturnValue(
240 + Effect.try(() => {
241 + throw new Error("not installed");
242 + }),
243 + );
244 + if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
245 + const directories = yield* museUsageReader.directories({
246 + instanceId: ProviderInstanceId.make("muse"),
247 + configured: false,
248 + config: undefined,
249 + environment: {},
250 + });
251 + expect(directories).toEqual([]);
252 + }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer])),
253 + );
254 +
255 + it.effect(
256 + "reuses discovery across accounts, date scans, and equivalent effective environments",
257 + () =>
258 + Effect.gen(function* () {
259 + const path = yield* Path.Path;
260 + const close = vi.fn(async () => {});
261 + using create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockReturnValue(
262 + Effect.succeed({
263 + initializeResult: { museHome: "/native/home" },
264 + close,
265 + } as unknown as MuseSdk.MuseSdkHost),
266 + );
267 + if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
268 + const instance = {
269 + instanceId: ProviderInstanceId.make("disabled-muse"),
270 + configured: true,
271 + config: decodeSettings({ binaryPath: "~/bin/muse", enabled: false }),
272 + environment: { PATH: "/bin", XDG_DATA_HOME: "/data" },
273 + };
274 + const first = yield* museUsageReader.directories(instance);
275 + const second = yield* museUsageReader.directories({
276 + ...instance,
277 + instanceId: ProviderInstanceId.make("another-account"),
278 + config: decodeSettings({
279 + binaryPath: path.join("/test-home", "bin/muse"),
280 + enabled: true,
281 + }),
282 + environment: {
283 + XDG_DATA_HOME: "/data",
284 + PATH: "/bin",
285 + UNUSED: undefined,
286 + META_API_KEY: "ignored",
287 + },
288 + });
289 + expect(second).toEqual(first);
290 + expect(first).toEqual([
291 + { dir: path.join("/native/home", "sessions"), fileName: "session.jsonl" },
292 + ]);
293 + expect(create).toHaveBeenCalledOnce();
294 + expect(close).toHaveBeenCalledOnce();
295 + }).pipe(
296 + Effect.provide([NodeServices.layer, MuseUsageHome.layer]),
297 + Effect.provideService(HostProcess.HomeDirectory, "/test-home"),
298 + Effect.provideService(HostProcess.Environment, {}),
299 + ),
300 + );
301 +
302 + it.effect(
303 + "rediscovers when the binary, instance environment, or inherited environment changes",
304 + () =>
305 + Effect.gen(function* () {
306 + using create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockImplementation((options) =>
307 + Effect.succeed({
308 + initializeResult: { museHome: options.environment?.XDG_DATA_HOME },
309 + close: async () => {},
310 + } as unknown as MuseSdk.MuseSdkHost),
311 + );
312 + if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
313 + const instance = {
314 + instanceId: ProviderInstanceId.make("muse"),
315 + configured: true,
316 + config: undefined,
317 + environment: {},
318 + };
319 + const first = yield* museUsageReader.directories(instance);
320 + expect(
321 + yield* museUsageReader.directories({
322 + ...instance,
323 + config: decodeSettings({ binaryPath: "custom-muse" }),
324 + }),
325 + ).toEqual(first);
326 + const changed = yield* museUsageReader.directories({
327 + ...instance,
328 + environment: { XDG_DATA_HOME: "/other-data" },
329 + });
330 + expect(changed).not.toEqual(first);
331 + const inherited = yield* museUsageReader
332 + .directories(instance)
333 + .pipe(
334 + Effect.provideService(HostProcess.Environment, { XDG_DATA_HOME: "/new-host-data" }),
335 + );
336 + expect(inherited).not.toEqual(first);
337 + expect(inherited).not.toEqual(changed);
338 + expect(create).toHaveBeenCalledTimes(4);
339 + }).pipe(
340 + Effect.provide([NodeServices.layer, MuseUsageHome.layer]),
341 + Effect.provideService(HostProcess.Environment, { XDG_DATA_HOME: "/host-data" }),
342 + ),
343 + );
344 +
345 + it.effect("shares pending initialization across concurrent directory reads", () =>
346 + Effect.gen(function* () {
347 + const started = yield* Deferred.make<void>();
348 + const ready = yield* Deferred.make<MuseSdk.MuseSdkHost>();
349 + using create = vi
350 + .spyOn(MuseSdk, "createMuseSdkHostEffect")
351 + .mockImplementation(() =>
352 + Deferred.succeed(started, undefined).pipe(Effect.andThen(Deferred.await(ready))),
353 + );
354 + const close = vi.fn(async () => {});
355 + if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
356 + const instance = {
357 + instanceId: ProviderInstanceId.make("muse"),
358 + configured: true,
359 + config: undefined,
360 + environment: {},
361 + };
362 + const reads = yield* Effect.all(
363 + [museUsageReader.directories(instance), museUsageReader.directories(instance)],
364 + { concurrency: "unbounded" },
365 + ).pipe(Effect.forkChild);
366 + yield* Deferred.await(started);
367 + yield* Deferred.succeed(ready, {
368 + initializeResult: { museHome: "/native/home" },
369 + close,
370 + } as unknown as MuseSdk.MuseSdkHost);
371 + const [first, second] = yield* Fiber.join(reads);
372 + expect(first).toEqual(second);
373 + expect(first).toHaveLength(1);
374 + expect(create).toHaveBeenCalledOnce();
375 + expect(close).toHaveBeenCalledOnce();
376 + }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer])),
377 + );
378 +
379 + it.effect("briefly caches failed discovery and retries after installation recovers", () =>
380 + Effect.gen(function* () {
381 + using create = vi
382 + .spyOn(MuseSdk, "createMuseSdkHostEffect")
383 + .mockReturnValueOnce(
384 + Effect.try(() => {
385 + throw new Error("not installed");
386 + }),
387 + )
388 + .mockReturnValue(
389 + Effect.succeed({
390 + initializeResult: { museHome: "/installed/home" },
391 + close: async () => {},
392 + } as unknown as MuseSdk.MuseSdkHost),
393 + );
394 + if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
395 + const instance = {
396 + instanceId: ProviderInstanceId.make("muse"),
397 + configured: false,
398 + config: undefined,
399 + environment: {},
400 + };
401 + expect(yield* museUsageReader.directories(instance)).toEqual([]);
402 + expect(yield* museUsageReader.directories(instance)).toEqual([]);
403 + expect(create).toHaveBeenCalledOnce();
404 + yield* TestClock.adjust("30 seconds");
405 + expect(yield* museUsageReader.directories(instance)).toHaveLength(1);
406 + expect(create).toHaveBeenCalledTimes(2);
407 + }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer])),
408 + );
409 +});
packages/provider-muse/src/server/usage.ts new
+140
@@ -0,0 +1,140 @@
1 +import * as Effect from "effect/Effect";
2 +import * as Option from "effect/Option";
3 +import * as Path from "effect/Path";
4 +import * as Schema from "effect/Schema";
5 +
6 +import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment";
7 +import { expandHomePath } from "@t3tools/provider-core/server/pathExpansion";
8 +import {
9 + tokenCount,
10 + totalTokens,
11 + type ProviderUsageReader,
12 + type TranscriptUsageFormat,
13 + type UsageRecord,
14 +} from "@t3tools/provider-core/server/usage";
15 +import * as HostProcess from "@t3tools/shared/HostProcess";
16 +import type { MuseSettings } from "../settings.ts";
17 +import { makeMuseEnvironment } from "./sdk.ts";
18 +import * as MuseUsageHome from "./MuseUsageHome.ts";
19 +
20 +const Entry = Schema.Struct({
21 + schema_version: Schema.Literal(1),
22 + record_type: Schema.Literal("event"),
23 + payload_type: Schema.Literal("runtime.session"),
24 + // Native automated review completions use session payload version 3.
25 + payload_schema_version: Schema.Literals([1, 3]),
26 + id: Schema.NonEmptyString,
27 + recorded_at: Schema.Number,
28 + stream: Schema.Struct({ kind: Schema.Literal("session"), id: Schema.NonEmptyString }),
29 + payload: Schema.Struct({
30 + source_run_record_id: Schema.optional(Schema.NonEmptyString),
31 + event: Schema.Struct({
32 + kind: Schema.Literals(["model_completed", "automated_review_completed"]),
33 + model: Schema.Union([
34 + Schema.NonEmptyString,
35 + Schema.Struct({ model_id: Schema.NonEmptyString }),
36 + ]),
37 + usage: Schema.Struct({
38 + input_tokens: Schema.optional(Schema.Unknown),
39 + output_tokens: Schema.optional(Schema.Unknown),
40 + cached_tokens: Schema.optional(Schema.Unknown),
41 + cached_input_tokens: Schema.optional(Schema.Unknown),
42 + cache_read_tokens: Schema.optional(Schema.Unknown),
43 + cache_write_tokens: Schema.optional(Schema.Unknown),
44 + reasoning_tokens: Schema.optional(Schema.Unknown),
45 + }),
46 + }),
47 + }),
48 +});
49 +const decodeEntry = Schema.decodeUnknownOption(Entry);
50 +
51 +function parseRecord(parsed: unknown): readonly UsageRecord[] {
52 + const decoded = decodeEntry(parsed);
53 + if (Option.isNone(decoded)) return [];
54 + const entry = decoded.value;
55 + if (!Number.isSafeInteger(entry.recorded_at) || entry.recorded_at < 0) return [];
56 + const { event } = entry.payload;
57 + const { usage } = event;
58 + const input = tokenCount(usage.input_tokens);
59 + const cachedInputTokens = Math.min(
60 + input,
61 + tokenCount(usage.cache_read_tokens ?? usage.cached_input_tokens ?? usage.cached_tokens),
62 + );
63 + const cacheCreationTokens = Math.min(
64 + input - cachedInputTokens,
65 + tokenCount(usage.cache_write_tokens),
66 + );
67 + const outputTokens = tokenCount(usage.output_tokens);
68 + const totals = {
69 + // Muse's cache counters are subsets of input; reasoning is a subset of output.
70 + uncachedInputTokens: input - cachedInputTokens - cacheCreationTokens,
71 + cachedInputTokens,
72 + cacheCreationTokens,
73 + outputTokens,
74 + reasoningTokens: Math.min(outputTokens, tokenCount(usage.reasoning_tokens)),
75 + };
76 + if (totalTokens(totals) === 0) return [];
77 + return [
78 + {
79 + provider: "muse",
80 + timestampMs: Math.trunc(entry.recorded_at / 1_000),
81 + model: typeof event.model === "string" ? event.model : event.model.model_id,
82 + sessionId: entry.stream.id,
83 + totals,
84 + reportedCostUsd: null,
85 + speed: "standard",
86 + // Runtime envelopes can be copied into another session. The source record
87 + // identifies the inference even when the enclosing envelope has a new ID.
88 + dedupeKey: JSON.stringify(["muse", entry.payload.source_run_record_id ?? entry.id]),
89 + },
90 + ];
91 +}
92 +
93 +export const museUsageFormat: TranscriptUsageFormat<unknown> = {
94 + selectFields: {
95 + schema_version: true,
96 + record_type: true,
97 + payload_type: true,
98 + payload_schema_version: true,
99 + id: true,
100 + recorded_at: true,
101 + stream: { kind: true, id: true },
102 + payload: { source_run_record_id: true, event: { kind: true, model: true, usage: true } },
103 + },
104 + usageMarkers: ['"model_completed"', '"automated_review_completed"'],
105 + parseLine: (line) => {
106 + let parsed: unknown;
107 + try {
108 + parsed = JSON.parse(line);
109 + } catch {
110 + return [];
111 + }
112 + return parseRecord(parsed);
113 + },
114 + parseProjected: parseRecord,
115 +};
116 +
117 +export const museUsageReader: ProviderUsageReader<
118 + MuseSettings,
119 + Path.Path | MuseUsageHome.MuseUsageHome
120 +> = {
121 + kind: "transcripts",
122 + provider: "muse",
123 + format: museUsageFormat,
124 + directories: Effect.fn("museUsageReader.directories")(function* ({ config, environment }) {
125 + const path = yield* Path.Path;
126 + const home = yield* HostProcess.HomeDirectory;
127 + const usageHome = yield* MuseUsageHome.MuseUsageHome;
128 + const processEnvironment = yield* mergeProviderInstanceEnvironment(
129 + Object.entries(environment).flatMap(([name, value]) =>
130 + value === undefined ? [] : [{ name, value, sensitive: false }],
131 + ),
132 + yield* HostProcess.Environment,
133 + );
134 + const museHome = yield* usageHome.resolve({
135 + binaryPath: expandHomePath(config?.binaryPath ?? "muse", home),
136 + environment: makeMuseEnvironment(processEnvironment),
137 + });
138 + return museHome ? [{ dir: path.join(museHome, "sessions"), fileName: "session.jsonl" }] : [];
139 + }),
140 +};