fix(agents): show recent tools and saved child history

apps/server/integration/orphanedProviderSessionStartup.integration.test.ts

@@ -123,6 +123,7 @@ const startupDependencies = Layer.mergeAll(
     assertConversationRollbackSupported: () => Effect.die("unused"),
     getInstanceInfo: () => Effect.die("unused"),
     rollbackConversation: () => Effect.die("unused"),
+    getAgentHistory: () => Effect.die("unused"),
     uploadFeedback: () => Effect.die("unused"),
     streamEvents: Stream.empty,
   }),

apps/server/src/auth/RpcAuthorization.ts

@@ -23,6 +23,7 @@ type WsRpcMethod = RpcGroup.Rpcs<typeof WsRpcGroup>["_tag"];
 export const RPC_REQUIRED_SCOPES = {
   [ORCHESTRATION_WS_METHODS.dispatchCommand]: AuthOrchestrationOperateScope,
   [ORCHESTRATION_WS_METHODS.getWorkflowScript]: AuthOrchestrationReadScope,
+  [ORCHESTRATION_WS_METHODS.getAgentHistory]: AuthOrchestrationReadScope,
   [ORCHESTRATION_WS_METHODS.getTurnDiff]: AuthOrchestrationReadScope,
   [ORCHESTRATION_WS_METHODS.getFullThreadDiff]: AuthOrchestrationReadScope,
   [ORCHESTRATION_WS_METHODS.searchThreads]: AuthOrchestrationReadScope,

apps/server/src/orchestration/Layers/CheckpointReactor.test.ts

@@ -137,6 +137,7 @@ function createProviderServiceHarness(
         },
       }),
     rollbackConversation,
+    getAgentHistory: () => unsupported(),
     uploadFeedback: () => unsupported(),
     get streamEvents() {
       return Stream.fromPubSub(runtimeEventPubSub);

apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts

@@ -390,6 +390,7 @@ describe("ProviderCommandReactor", () => {
         });
       },
       rollbackConversation: () => unsupported(),
+      getAgentHistory: () => unsupported(),
       uploadFeedback: () => unsupported(),
       get streamEvents() {
         return Stream.fromPubSub(runtimeEventPubSub);

apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts

@@ -141,6 +141,7 @@ function createProviderServiceHarness() {
       });
     },
     rollbackConversation: () => unsupported(),
+    getAgentHistory: () => unsupported(),
     uploadFeedback: () => unsupported(),
     get streamEvents() {
       return Stream.fromPubSub(runtimeEventPubSub).pipe(

apps/server/src/provider/Layers/ClaudeAdapter.test.ts

@@ -7279,3 +7279,48 @@ describe("ClaudeAdapterLive", () => {
     );
   });
 });
+
+for (const source of ["configured", "inherited"] as const) {
+  it.effect(`reads child history from the ${source} Claude home without starting a session`, () => {
+    const home = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "claude-history-adapter-"));
+    const sessionId = "0945fcd9-8a8d-450a-b8cf-4ebd0ef17468";
+    const directory = NodePath.join(home, "projects", "-workspace", sessionId, "subagents");
+    NodeFS.mkdirSync(directory, { recursive: true });
+    NodeFS.writeFileSync(
+      NodePath.join(directory, "agent-child.jsonl"),
+      JSON.stringify({
+        type: "user",
+        uuid: "9eb84969-819b-4d5b-854f-327474810b34",
+        parentUuid: null,
+        isSidechain: true,
+        sessionId,
+        agentId: "child",
+        message: { role: "user", content: "Saved task" },
+      }) + "\n",
+    );
+    const harness = makeHarness({
+      claudeConfig: { homePath: source === "configured" ? home : "" },
+      environment: {
+        ...process.env,
+        CLAUDE_CONFIG_DIR: source === "configured" ? "/unused-claude-home" : home,
+      },
+    });
+    return Effect.gen(function* () {
+      const adapter = yield* ClaudeAdapter;
+      assert.isDefined(adapter.getAgentHistory);
+      const result = yield* adapter.getAgentHistory!({
+        threadId: ThreadId.make("stopped-history-thread"),
+        agentId: "child",
+        offset: 0,
+        resumeCursor: { resume: sessionId },
+      });
+      assert.equal(result.status, "ready");
+      assert.equal(result.entries[0]?.detail, "Saved task");
+      assert.isUndefined(harness.getLastCreateQueryInput());
+      assert.deepStrictEqual(yield* adapter.listSessions(), []);
+    }).pipe(
+      Effect.provide(harness.layer),
+      Effect.ensuring(Effect.sync(() => NodeFS.rmSync(home, { recursive: true, force: true }))),
+    );
+  });
+}

apps/server/src/provider/Layers/ClaudeAdapter.ts

@@ -6,6 +6,9 @@
  *
  * @module ClaudeAdapterLive
  */
+import * as NodeOS from "node:os";
+import { readClaudeAgentHistory } from "./claudeAgentHistory.ts";
+import { expandHomePath } from "../../pathExpansion.ts";
 import {
   type CanUseTool,
   query,
@@ -5028,6 +5031,39 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
     },
   );
 
+  /** Read the configured instance’s saved child transcript without creating a live SDK query. */
+  const getAgentHistory: ClaudeAdapterShape["getAgentHistory"] = Effect.fn("getAgentHistory")(
+    function* (input) {
+      const sessionId = readClaudeResumeState(input.resumeCursor)?.resume;
+      if (!sessionId)
+        return {
+          status: "unavailable",
+          entries: [],
+          nextOffset: null,
+          message: "No saved Claude session is available for this thread.",
+        };
+      return yield* Effect.tryPromise({
+        try: () =>
+          readClaudeAgentHistory({
+            sessionId,
+            agentId: input.agentId,
+            offset: input.offset,
+            view: input.view,
+            configDir: claudeEnvironment.CLAUDE_CONFIG_DIR
+              ? expandHomePath(claudeEnvironment.CLAUDE_CONFIG_DIR)
+              : path.join(NodeOS.homedir(), ".claude"),
+          }),
+        catch: (cause) =>
+          new ProviderAdapterRequestError({
+            provider: PROVIDER,
+            method: "getSubagentMessages",
+            detail: "Could not read saved Claude agent history.",
+            cause,
+          }),
+      });
+    },
+  );
+
   const readThread: ClaudeAdapterShape["readThread"] = Effect.fn("readThread")(
     function* (threadId) {
       const context = yield* requireSession(threadId);
@@ -5135,6 +5171,7 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
     sendTurn,
     interruptTurn,
     readThread,
+    getAgentHistory,
     rollbackThread,
     respondToRequest,
     respondToUserInput,

apps/server/src/provider/Layers/CodexAdapter.history.test.ts

@@ -0,0 +1,74 @@
+// @effect-diagnostics nodeBuiltinImport:off
+import * as NodeFS from "node:fs";
+import * as NodeOS from "node:os";
+import * as NodePath from "node:path";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { it, expect } from "@effect/vitest";
+import { CodexSettings, ThreadId } from "@t3tools/contracts";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { ServerConfig } from "../../config.ts";
+import { writeFakeCli } from "../../testUtils/fakeCli.ts";
+import { makeCodexAdapter } from "./CodexAdapter.ts";
+
+const decodeCodexSettings = Schema.decodeEffect(CodexSettings);
+
+it.effect(
+  "reuses one initialize-only Codex transport across concurrent and repeated history reads",
+  () =>
+    Effect.gen(function* () {
+      const dir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "codex-history-client-"));
+      yield* Effect.addFinalizer(() =>
+        Effect.sync(() => NodeFS.rmSync(dir, { recursive: true, force: true })),
+      );
+      const log = NodePath.join(dir, "methods.txt");
+      const binaryPath = writeFakeCli({
+        directory: dir,
+        name: "codex-history",
+        env: { HISTORY_TEST_LOG: log },
+        source: `
+      import { appendFileSync } from "node:fs";
+      import { createInterface } from "node:readline";
+      createInterface({ input: process.stdin }).on("line", (line) => {
+        const request = JSON.parse(line);
+        appendFileSync(process.env.HISTORY_TEST_LOG, request.method + "\\n");
+        if (request.id === undefined) return;
+        const result = request.method === "initialize" ? { userAgent: "codex/1.0", codexHome: process.cwd(), platformFamily: "unix", platformOs: "linux" }
+          : { thread: { id: request.params.threadId, cliVersion: "test", createdAt: 0, updatedAt: 0,
+              cwd: process.cwd(), ephemeral: false, modelProvider: "openai", preview: "", sessionId: "session",
+              status: { type: "idle" }, source: { subAgent: { thread_spawn: { parent_thread_id: "parent", depth: 1 } } },
+              turns: [{ id: "turn", status: "completed", error: null, items: [{ id: "message", type: "agentMessage", text: "Saved answer" }] }] } };
+        process.stdout.write(JSON.stringify({ id: request.id, result }) + "\\n");
+      });
+    `,
+      });
+      const adapter = yield* makeCodexAdapter(yield* decodeCodexSettings({ binaryPath }));
+      const input = {
+        threadId: ThreadId.make("stopped"),
+        agentId: "child",
+        cwd: dir,
+        offset: 0,
+        resumeCursor: { threadId: "parent" },
+      };
+      const results = yield* Effect.all(
+        [adapter.getAgentHistory!(input), adapter.getAgentHistory!(input)],
+        { concurrency: "unbounded" },
+      );
+      expect(results.every((result) => result.entries[0]?.detail === "Saved answer")).toBe(true);
+      yield* adapter.getAgentHistory!(input);
+      const methods = NodeFS.readFileSync(log, "utf8").trim().split("\n");
+      expect(methods.filter((method) => method === "initialize")).toHaveLength(1);
+      expect(methods.filter((method) => method === "thread/read")).toHaveLength(6);
+      expect(
+        methods.every((method) => ["initialize", "initialized", "thread/read"].includes(method)),
+      ).toBe(true);
+      expect(yield* adapter.listSessions()).toEqual([]);
+    }).pipe(
+      Effect.provide(
+        ServerConfig.layerTest(process.cwd(), process.cwd()).pipe(
+          Layer.provideMerge(NodeServices.layer),
+        ),
+      ),
+    ),
+);

apps/server/src/provider/Layers/CodexAdapter.ts

@@ -1,3 +1,6 @@
+import { makeAgentHistoryClient } from "./agentHistoryClient.ts";
+import { withCodexAppServerClient } from "./CodexProvider.ts";
+import { readCodexAgentHistory } from "./codexAgentHistory.ts";
 /**
  * CodexAdapterLive - Scoped live implementation for the Codex provider adapter.
  *
@@ -2234,6 +2237,16 @@ export const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* (
   const runtimeEventQueue = yield* Queue.unbounded<ProviderRuntimeEvent>();
   const sessions = new Map<ThreadId, CodexAdapterSessionContext>();
 
+  const withHistoryClient = yield* makeAgentHistoryClient((cwd) =>
+    withCodexAppServerClient({
+      binaryPath: codexConfig.binaryPath,
+      homePath: codexConfig.homePath,
+      launchArgs: resolveCodexLaunchArgs(codexConfig.launchArgs, options?.environment),
+      environment: options?.environment,
+      cwd,
+    }).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, childProcessSpawner)),
+  );
+
   const startSession: CodexAdapterShape["startSession"] = (input) =>
     Effect.scoped(
       Effect.gen(function* () {
@@ -2569,6 +2582,41 @@ export const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* (
     );
   });
 
+  /** Read saved descendants through the shared read-only transport without resuming a coding session. */
+  const getAgentHistory: CodexAdapterShape["getAgentHistory"] = Effect.fn("getAgentHistory")(
+    function* (input) {
+      if (!isCodexResumeCursorSchema(input.resumeCursor)) {
+        return {
+          status: "unavailable",
+          entries: [],
+          nextOffset: null,
+          message: "No saved Codex session is available for this thread.",
+        };
+      }
+      const parentThreadId = input.resumeCursor.threadId;
+      return yield* withHistoryClient(input.cwd ?? process.cwd(), ({ client }) =>
+        readCodexAgentHistory({
+          parentThreadId,
+          agentId: input.agentId,
+          offset: input.offset,
+          view: input.view,
+          readThread: (threadId, includeTurns) =>
+            client.request("thread/read", { threadId, includeTurns }),
+        }),
+      ).pipe(
+        Effect.mapError(
+          (cause) =>
+            new ProviderAdapterRequestError({
+              provider: PROVIDER,
+              method: "thread/read",
+              detail: "Could not read saved agent history.",
+              cause,
+            }),
+        ),
+      );
+    },
+  );
+
   const readThread: CodexAdapterShape["readThread"] = (threadId) =>
     requireSession(threadId).pipe(
       Effect.flatMap((session) => session.runtime.readThread),
@@ -2717,6 +2765,7 @@ export const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* (
     compaction: { type: "native", start: compactThread },
     interruptTurn,
     readThread,
+    getAgentHistory,
     rollbackThread,
     uploadFeedback,
     respondToRequest,