fix(opencode): read usage from each instance data directory

apps/server/src/usage/UsageService.test.ts

@@ -9,8 +9,10 @@ import * as NodeSqlite from "node:sqlite";
 import { assert, describe, it } from "@effect/vitest";
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import * as HostProcess from "@t3tools/shared/HostProcess";
+import { OpenCodeDriver } from "@t3tools/provider-opencode/server";
 import { mergeUsage } from "@t3tools/shared/usageMerge";
 import {
+  DEFAULT_SERVER_SETTINGS,
   EnvironmentId,
   ProviderDriverKind,
   ProviderInstanceId,
@@ -706,6 +708,17 @@ describe("UsageService", () => {
       yield* Effect.promise(async () => {
         await NodeFSP.mkdir(opencode);
         await NodeFSP.symlink(opencode, opencodeAlias, "junction");
+        const messages = NodePath.join(opencode, "storage", "message", "session-1");
+        await NodeFSP.mkdir(messages, { recursive: true });
+        await NodeFSP.writeFile(
+          NodePath.join(messages, "msg-aliased.json"),
+          JSON.stringify({
+            role: "assistant",
+            modelID: "example-model",
+            time: { created: Date.parse("2026-08-01T10:00:00Z") },
+            tokens: { input: 100, output: 20 },
+          }),
+        );
         await NodeFSP.mkdir(conversations);
         await NodeFSP.mkdir(antigravityA);
         await NodeFSP.mkdir(antigravityB);
@@ -720,12 +733,63 @@ describe("UsageService", () => {
           "junction",
         );
       });
+      const instances = [
+        {
+          instanceId: ProviderInstanceId.make("opencode-first"),
+          config: undefined,
+          environment: { OPENCODE_DATA_DIR: ` ${opencode}, ${opencodeAlias} ` },
+          configured: true,
+        },
+        {
+          instanceId: ProviderInstanceId.make("opencode-second"),
+          config: undefined,
+          environment: { OPENCODE_DATA_DIR: opencodeAlias },
+          configured: true,
+        },
+      ];
+      const reader = OpenCodeDriver.usage;
+      if (reader?.kind !== "scan") throw new Error("Expected an OpenCode scan reader");
+      const scans = yield* reader
+        .scan({
+          instances,
+          settings: DEFAULT_SERVER_SETTINGS,
+          windowStartMs: 0,
+          retentionCutoffMs: 0,
+          awaitRefresh: true,
+        })
+        .pipe(Effect.provide(NodeServices.layer));
+      assert.strictEqual(scans.length, 1);
+      assert.strictEqual(scans[0]?.dir, yield* Effect.promise(() => NodeFSP.realpath(opencode)));
+      assert.deepStrictEqual(
+        scans.flatMap(
+          (scan) =>
+            scan.files?.flatMap((file) => file.records.map((record) => record.dedupeKey)) ?? [],
+        ),
+        ["opencode:msg-aliased"],
+      );
       const service = yield* UsageService.make.pipe(
         Effect.provide(
           layerService({
             prefix: "usage-service-aliased-roots-test",
             home,
-            settings,
+            settings: {
+              providerInstances: {
+                ...settings.providerInstances,
+                ...Object.fromEntries(
+                  instances.map((instance) => [
+                    instance.instanceId,
+                    {
+                      driver: ProviderDriverKind.make("opencode"),
+                      environment: Object.entries(instance.environment).map(([name, value]) => ({
+                        name,
+                        value,
+                        sensitive: false,
+                      })),
+                    },
+                  ]),
+                ),
+              },
+            },
             environment: {
               OPENCODE_DATA_DIR: `${opencode},${opencodeAlias}`,
               ANTIGRAVITY_DATA_DIR: `${antigravityA},${antigravityB}`,
@@ -738,6 +802,10 @@ describe("UsageService", () => {
         summary.sources.filter((source) => source.fingerprint.provider === provider);
       assert.strictEqual(sourcesFor("opencode").length, 1);
       assert.strictEqual(sourcesFor("antigravity").length, 1);
+      assert.strictEqual(
+        summary.buckets.find((bucket) => bucket.provider === "opencode")?.totals.outputTokens,
+        20,
+      );
       assert.strictEqual(
         sourcesFor("opencode")[0]?.fingerprint.resolvedHomePath,
         yield* Effect.promise(() => NodeFSP.realpath(opencode)),

packages/provider-opencode/src/server/usage.test.ts

@@ -1,5 +1,8 @@
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { assert, describe, it } from "@effect/vitest";
+import { DEFAULT_SERVER_SETTINGS, ProviderInstanceId } from "@t3tools/contracts";
+import type { ProviderUsageInstance } from "@t3tools/provider-core/server/usage";
+import * as HostProcess from "@t3tools/shared/HostProcess";
 import * as NodeSqliteClient from "@t3tools/shared/nodeSqliteClient";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
@@ -8,14 +11,51 @@ import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";
 import * as SqlClient from "effect/sql/SqlClient";
 
-import { readOpenCodeUsage } from "./usage.ts";
+import type { OpenCodeSettings } from "../settings.ts";
+import { openCodeUsageReader, readOpenCodeUsage } from "./usage.ts";
 
 /** A writable connection that stays open until the test's scope closes. */
 const openDatabase = (filename: string) =>
   Layer.build(NodeSqliteClient.layer({ filename })).pipe(
     Effect.map(Context.get(SqlClient.SqlClient)),
   );
 
+const seedHistory = Effect.fn("seedHistory")(function* (root: string, id: string) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  yield* fileSystem.makeDirectory(root, { recursive: true });
+  const db = yield* openDatabase(path.join(root, "opencode.db"));
+  yield* db.unsafe("CREATE TABLE message (id TEXT, session_id TEXT, data TEXT)");
+  yield* db.unsafe("INSERT INTO message VALUES (?, ?, ?)", [
+    id,
+    "session-1",
+    JSON.stringify({
+      role: "assistant",
+      modelID: "claude-sonnet-4-5",
+      time: { created: 1780000000000 },
+      tokens: { input: 100, output: 20 },
+    }),
+  ]);
+});
+
+const usageInstance = (id: string, environment: NodeJS.ProcessEnv, configured = true) => ({
+  instanceId: ProviderInstanceId.make(id),
+  config: undefined,
+  environment,
+  configured,
+});
+
+const scanUsage = (instances: readonly ProviderUsageInstance<OpenCodeSettings>[]) => {
+  if (openCodeUsageReader.kind !== "scan") throw new Error("Expected an OpenCode scan reader");
+  return openCodeUsageReader.scan({
+    instances,
+    settings: DEFAULT_SERVER_SETTINGS,
+    windowStartMs: 0,
+    retentionCutoffMs: 0,
+    awaitRefresh: true,
+  });
+};
+
 describe("readOpenCodeUsage", () => {
   it.effect("counts migrated OpenCode messages once and sees subsequent WAL writes", () =>
     Effect.gen(function* () {
@@ -68,3 +108,92 @@ describe("readOpenCodeUsage", () => {
     }).pipe(Effect.provide(NodeServices.layer)),
   );
 });
+
+describe("openCodeUsageReader", () => {
+  it.effect("reads histories from each instance's environment", () =>
+    Effect.gen(function* () {
+      const fileSystem = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const temp = yield* fileSystem.makeTempDirectoryScoped({ prefix: "usage-instances-test-" });
+      const home = yield* fileSystem.realPath(temp);
+      const first = path.join(home, "first");
+      const dataHome = path.join(home, "second");
+      const second = path.join(dataHome, "opencode");
+      yield* seedHistory(first, "msg-first");
+      yield* seedHistory(second, "msg-second");
+
+      const sources = yield* scanUsage([
+        usageInstance("opencode-first", {
+          OPENCODE_DATA_DIR: " ~/first, , ",
+          XDG_DATA_HOME: path.join(home, "unused"),
+        }),
+        usageInstance("opencode-second", { XDG_DATA_HOME: ` ${dataHome} ` }),
+      ]).pipe(
+        Effect.provideService(HostProcess.Environment, {
+          OPENCODE_DATA_DIR: path.join(home, "host"),
+        }),
+        Effect.provideService(HostProcess.HomeDirectory, home),
+      );
+
+      assert.deepStrictEqual(
+        sources.map((source) => source.dir),
+        [first, second],
+      );
+      assert.deepStrictEqual(
+        sources.map((source) => source.status),
+        ["ok", "ok"],
+      );
+      const records = sources.flatMap(
+        (source) => source.files?.flatMap((file) => file.records) ?? [],
+      );
+      assert.deepStrictEqual(
+        records.map((record) => record.dedupeKey),
+        ["opencode:msg-first", "opencode:msg-second"],
+      );
+      assert.strictEqual(
+        records.reduce((sum, record) => sum + record.totals.uncachedInputTokens, 0),
+        200,
+      );
+    }).pipe(Effect.provide(NodeServices.layer)),
+  );
+
+  it.effect.each([
+    { dataHome: "absolute", dataDirs: undefined },
+    { dataHome: "relative", dataDirs: " , " },
+    { dataHome: "absent", dataDirs: undefined },
+  ])("retains the implicit host default for $dataHome XDG_DATA_HOME", ({ dataHome, dataDirs }) =>
+    Effect.gen(function* () {
+      const fileSystem = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const temp = yield* fileSystem.makeTempDirectoryScoped({ prefix: "usage-default-test-" });
+      const home = yield* fileSystem.realPath(temp);
+      const root = path.join(home, dataHome === "absolute" ? "xdg" : ".local/share", "opencode");
+      const environment = {
+        OPENCODE_DATA_DIR: dataDirs,
+        XDG_DATA_HOME:
+          dataHome === "absolute"
+            ? path.join(home, "xdg")
+            : dataHome === "relative"
+              ? "relative"
+              : undefined,
+      };
+      yield* seedHistory(root, "msg-default");
+
+      const sources = yield* scanUsage([usageInstance("opencode", environment, false)]).pipe(
+        Effect.provideService(HostProcess.Environment, environment),
+        Effect.provideService(HostProcess.HomeDirectory, home),
+      );
+      assert.deepStrictEqual(
+        sources.map((source) => source.dir),
+        [root],
+      );
+      assert.deepStrictEqual(
+        sources.flatMap(
+          (source) =>
+            source.files?.flatMap((file) => file.records.map((record) => record.dedupeKey)) ?? [],
+        ),
+        ["opencode:msg-default"],
+      );
+    }).pipe(Effect.provide(NodeServices.layer)),
+  );
+});

packages/provider-opencode/src/server/usage.ts

@@ -254,10 +254,11 @@ export const readOpenCodeUsage = Effect.fn("readOpenCodeUsage")(function* (
  * The data directories to read: `OPENCODE_DATA_DIR` (comma-separated) or the
  * XDG default, canonicalized so aliases count once.
  */
-const resolveOpenCodeDataDirs = Effect.fn("resolveOpenCodeDataDirs")(function* () {
+const resolveOpenCodeDataDirs = Effect.fn("resolveOpenCodeDataDirs")(function* (
+  environment: NodeJS.ProcessEnv,
+) {
   const fileSystem = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
-  const environment = yield* HostProcess.Environment;
   const homeDirectory = yield* HostProcess.HomeDirectory;
   const roots = environment["OPENCODE_DATA_DIR"]
     ?.split(",")
@@ -285,8 +286,11 @@ export type OpenCodeUsageReaderEnv = FileSystem.FileSystem | Path.Path;
 export const openCodeUsageReader: ProviderUsageReader<OpenCodeSettings, OpenCodeUsageReaderEnv> = {
   kind: "scan",
   provider: "opencode",
-  scan: Effect.fn("openCodeUsageReader.scan")(function* ({ windowStartMs }) {
-    const roots = yield* resolveOpenCodeDataDirs();
+  scan: Effect.fn("openCodeUsageReader.scan")(function* ({ instances, windowStartMs }) {
+    const roots = new Set<string>();
+    for (const instance of instances) {
+      for (const root of yield* resolveOpenCodeDataDirs(instance.environment)) roots.add(root);
+    }
     return yield* Effect.forEach(
       roots,
       (dir) =>