arul28 · arul28 · Jun 5, 2026 · Jun 4, 2026 · Jun 4, 2026 · Jun 4, 2026
@@ -268,6 +268,7 @@ ade run start web --lane lane-id
 ade shell start --lane lane-id -- npm test
 ade shell start-cli codex --lane lane-id --permission-mode edit --message "fix failing tests"
 ade shell start-cli --provider claude --lane lane-id --permission-mode default
+ade chat list --lane lane-id --include-automation --no-archived --text
 ade chat create --lane lane-id --model gpt-5.5
 ade code
 ade code --embedded

@@ -6,6 +6,9 @@ import { promisify } from "node:util";
 
 const execFileAsync = promisify(execFile);
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const repoRoot = path.resolve(packageRoot, "..", "..");
+const desktopPackageJsonPath = path.join(repoRoot, "apps", "desktop", "package.json");
+const cliPackageJsonPath = path.join(packageRoot, "package.json");
 const defaultOutDir = path.join(packageRoot, "dist-static");
 const fuse = "NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2";
 
@@ -89,6 +92,27 @@ async function run(command, args, options = {}) {
   if (stderr) process.stderr.write(stderr);
 }
 
+async function readPackageVersion(packageJsonPath) {
+  try {
+    const raw = await fs.readFile(packageJsonPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed.version === "string" ? parsed.version.trim() : "";
+  } catch {
+    return "";
+  }
+}
+
+async function resolveRuntimeVersion() {
+  const explicit = process.env.ADE_CLI_VERSION?.trim();
+  if (explicit) return explicit;
+
+  const cliVersion = await readPackageVersion(cliPackageJsonPath);
+  if (cliVersion && cliVersion !== "0.0.0") return cliVersion;
+
+  const desktopVersion = await readPackageVersion(desktopPackageJsonPath);
+  return desktopVersion || cliVersion || "0.0.0";
+}
+
 async function assertSeaCapableNodeBinary(binaryPath) {
   const contents = await fs.readFile(binaryPath);
   if (contents.includes(Buffer.from(fuse))) return;
@@ -112,6 +136,21 @@ async function adHocSignIfNeeded(binaryPath) {
   await run("codesign", ["--sign", "-", binaryPath]);
 }
 
+async function assertStaticRuntimeVersion(binaryPath, expectedVersion, target) {
+  if (target !== currentTarget()) return;
+  const { stdout } = await execFileAsync(binaryPath, ["--version"], {
+    cwd: packageRoot,
+    env: {
+      ...process.env,
+      ADE_CLI_VERSION: "",
+    },
+  });
+  const actual = stdout.trim().replace(/^ade\s+/i, "");
+  if (actual !== expectedVersion) {
+    throw new Error(`Static ADE runtime version mismatch: expected ${expectedVersion}, got ${actual || "<empty>"}.`);
+  }
+}
+
 async function writeSeaEntry(workDir) {
   const cliPath = path.join(packageRoot, "dist", "cli.cjs");
   const seaEntryPath = path.join(workDir, "cli-sea.cjs");
@@ -221,6 +260,8 @@ async function main() {
   const args = parseArgs(process.argv.slice(2));
   await assertHostOrExplicitBinary(args.target);
   await fs.mkdir(args.outDir, { recursive: true });
+  const runtimeVersion = await resolveRuntimeVersion();
+  process.env.ADE_CLI_VERSION = runtimeVersion;
 
   if (!args.skipBuild) {
     await run(process.platform === "win32" ? "npm.cmd" : "npm", ["run", "build"]);
@@ -263,6 +304,7 @@ async function main() {
   }
   await run(path.join(packageRoot, "node_modules", ".bin", process.platform === "win32" ? "postject.cmd" : "postject"), postjectArgs);
   await adHocSignIfNeeded(binaryPath);
+  await assertStaticRuntimeVersion(binaryPath, runtimeVersion, args.target);
 
   let nativeArchivePath = null;
   if (!args.skipNativeDeps) {

@@ -275,6 +275,12 @@ describe("ADE CLI", () => {
     });
   });
 
+  it("recognizes the hidden PTY host worker entrypoint", () => {
+    expect(buildCliPlan(["__ade-pty-host-worker"])).toEqual({
+      kind: "pty-host-worker",
+    });
+  });
+
   it("classifies only ADE temp runtime sockets as ephemeral", () => {
     const tempSocket = path.join(os.tmpdir(), "ade-stdio-rpc-test", "sock", "ade.sock");
 
@@ -869,6 +875,37 @@ describe("ADE CLI", () => {
     });
   });
 
+  it("maps chat list filters to the listSessions action", () => {
+    const plan = buildCliPlan([
+      "chat",
+      "list",
+      "--lane",
+      "lane-1",
+      "--include-automation",
+      "--include-identity",
+      "--no-archived",
+    ]);
+    expect(plan.kind).toBe("execute");
+    if (plan.kind !== "execute") return;
+    expect(plan.steps[0]?.params).toEqual({
+      name: "run_ade_action",
+      arguments: {
+        domain: "chat",
+        action: "listSessions",
+        args: {
+          laneId: "lane-1",
+          includeAutomation: true,
+          includeIdentity: true,
+          includeArchived: false,
+        },
+      },
+    });
+
+    expect(() =>
+      buildCliPlan(["chat", "list", "--include-archived", "--no-archived"]),
+    ).toThrow(/Use either --include-archived or --no-archived/);
+  });
+
   it("requires a chat session id for chat show", () => {
     expect(() => buildCliPlan(["chat", "show"])).toThrow(
       /sessionId is required/,

@@ -163,6 +163,7 @@ type CliPlan =
   | { kind: "runtime"; rest: string[] }
   | { kind: "serve"; rest: string[] }
   | { kind: "rpc-stdio"; rest: string[] }
+  | { kind: "pty-host-worker" }
   | { kind: "init"; targetPath: string | null }
   | { kind: "cursor-cloud"; rest: string[] }
   | { kind: "deeplink"; rest: string[] };
@@ -1243,7 +1244,8 @@ const HELP_BY_COMMAND: Record<string, string> = {
   Chat commands use ADE agent chat sessions. Live provider-backed chat normally
   requires an attached runtime because the daemon owns provider/session state.
 
-    $ ade chat list --text                          List chat sessions
+    $ ade chat list --lane <lane> --text            List chat sessions
+    $ ade chat list --include-automation --no-archived --text
     $ ade chat create --lane <lane> --provider codex --model <model> [--fast]
     $ ade chat create --from-linear-issue ENG-431   Start a chat with an attached issue + kickoff (alias: --linear-issue-json)
     $ ade chat send <session> --text "next step"    Send a message
@@ -5759,7 +5761,30 @@ function buildChatPlan(args: string[]): CliPlan {
       ...base,
       ...(sessionId ? { sessionId } : {}),
     });
-  if (sub === "list" || sub === "ls")
+  if (sub === "list" || sub === "ls") {
+    const includeArchived = readFlag(args, ["--archived", "--include-archived"]);
+    const excludeArchived = readFlag(args, [
+      "--active",
+      "--no-archived",
+      "--exclude-archived",
+    ]);
+    if (includeArchived && excludeArchived) {
+      throw new CliUsageError(
+        "Use either --include-archived or --no-archived, not both.",
+      );
+    }
+    const laneId = readLaneId(args);
+    const input = collectGenericObjectArgs(args, {
+      ...(laneId ? { laneId } : {}),
+      ...(includeArchived ? { includeArchived: true } : {}),
+      ...(excludeArchived ? { includeArchived: false } : {}),
+      ...(readFlag(args, ["--automation", "--include-automation"])
+        ? { includeAutomation: true }
+        : {}),
+      ...(readFlag(args, ["--identity", "--include-identity"])
+        ? { includeIdentity: true }
+        : {}),
+    });
     return {
       kind: "execute",
       label: "chat list",
@@ -5768,10 +5793,11 @@ function buildChatPlan(args: string[]): CliPlan {
           "result",
           "chat",
           "listSessions",
-          collectGenericObjectArgs(args),
+          input,
         ),
       ],
     };
+  }
   if (sub === "show" || sub === "status")
     return {
       kind: "execute",
@@ -10422,6 +10448,9 @@ function buildCliPlan(command: string[]): CliPlan {
   if (primary === "version" || primary === "--version" || primary === "-v") {
     return { kind: "help", text: `ade ${VERSION}\n` };
   }
+  if (primary === "__ade-pty-host-worker") {
+    return { kind: "pty-host-worker" };
+  }
   if (primary === "code") {
     const rest = args;
     return { kind: "ade-code", rest };
@@ -15374,6 +15403,17 @@ async function runCli(
       await runNativeRpcStdio(parsed.options);
       return { output: "", exitCode: 0 };
     }
+    if (plan.kind === "pty-host-worker") {
+      await import("../../desktop/src/main/services/pty/ptyHostWorker");
+      await new Promise<void>((resolve) => {
+        if (typeof process.send !== "function") {
+          resolve();
+          return;
+        }
+        process.once("disconnect", resolve);
+      });
+      return { output: "", exitCode: 0 };
+    }
     if (plan.kind === "desktop") {
       const result = await runDesktopCommand(plan.rest);
       return {

@@ -58,10 +58,10 @@ describe("listLaneDiffStats", () => {
 
 describe("chat session archive helpers", () => {
   it("lists chats with archived sessions hidden by default", async () => {
-    const calls: Array<{ domain: string; action: string; argsList: unknown[] }> = [];
+    const calls: Array<{ domain: string; action: string; args: Record<string, unknown> | undefined }> = [];
     const connection = {
-      actionList: async (domain: string, action: string, argsList: unknown[]) => {
-        calls.push({ domain, action, argsList });
+      action: async (domain: string, action: string, args?: Record<string, unknown>) => {
+        calls.push({ domain, action, args });
         return [];
       },
     } as unknown as AdeCodeConnection;
@@ -70,8 +70,8 @@ describe("chat session archive helpers", () => {
     await listChatSessions(connection, "lane-1", { includeArchived: true });
 
     expect(calls).toEqual([
-      { domain: "chat", action: "listSessions", argsList: [null, { includeArchived: false }] },
-      { domain: "chat", action: "listSessions", argsList: ["lane-1", { includeArchived: true }] },
+      { domain: "chat", action: "listSessions", args: { includeArchived: false } },
+      { domain: "chat", action: "listSessions", args: { laneId: "lane-1", includeArchived: true } },
     ]);
   });
 

@@ -74,9 +74,10 @@ export async function listChatSessions(
   laneId?: string | null,
   options: { includeArchived?: boolean } = {},
 ): Promise<AgentChatSessionSummary[]> {
-  const listOptions = { includeArchived: options.includeArchived ?? false };
-  const argsList = laneId ? [laneId, listOptions] : [null, listOptions];
-  return await connection.actionList<AgentChatSessionSummary[]>("chat", "listSessions", argsList);
+  return await connection.action<AgentChatSessionSummary[]>("chat", "listSessions", {
+    ...(laneId ? { laneId } : {}),
+    includeArchived: options.includeArchived ?? false,
+  });
 }
 
 export async function archiveChatSession(

@@ -1446,6 +1446,8 @@ app.whenReady().then(async () => {
     options: { emit?: boolean; foreground?: boolean } = {},
   ): void => {
     const normalizedRoot = projectRoot ? normalizeProjectRoot(projectRoot) : null;
+    const previousRemoteBinding =
+      windowId != null ? (windowProjectBindings.get(windowId) ?? null) : null;
     if (windowId != null) {
       windowProjectRoots.set(windowId, normalizedRoot);
       windowProjectBindings.delete(windowId);
@@ -1477,6 +1479,15 @@ app.whenReady().then(async () => {
         });
       }
     }
+    if (previousRemoteBinding) {
+      const remainingRemoteBinding =
+        Array.from(windowProjectBindings.values()).at(-1) ?? null;
+      if (remainingRemoteBinding) {
+        persistLastRemoteProjectBinding(remainingRemoteBinding);
+      } else {
+        clearLastRemoteProjectBinding();
+      }
+    }
     if (options.emit !== false) {
       const project = projectForRoot(normalizedRoot);
       emitProjectChangedToWindow(windowId, project);

@@ -72,6 +72,11 @@ describe("isAllowedAdeAction", () => {
     expect(isCtoOnlyAdeAction("ios_simulator", "ensurePreviewWorkspace")).toBe(false);
   });
 
+  it("exposes subagent transcript reads through the chat runtime action surface", () => {
+    expect(isAllowedAdeAction("chat", "getSubagentTranscript")).toBe(true);
+    expect(isCtoOnlyAdeAction("chat", "getSubagentTranscript")).toBe(false);
+  });
+
   it("rejects an unknown action on a known domain", () => {
     expect(isAllowedAdeAction("git", "rmRf")).toBe(false);
     expect(isAllowedAdeAction("issue", "deleteAllIssues")).toBe(false);
@@ -343,6 +348,26 @@ describe("ADE_ACTION_ALLOWLIST shape", () => {
     expect(getModelCatalog).toHaveBeenCalledWith({ mode: "cached" });
   });
 
+  it("unwraps chat.listSessions action args before calling the positional chat service API", async () => {
+    const listSessions = vi.fn(async () => []);
+    const runtime = {
+      agentChatService: {
+        listSessions,
+      },
+    } as unknown as Parameters<typeof getAdeActionDomainServices>[0];
+
+    const chat = getAdeActionDomainServices(runtime).chat as {
+      listSessions?: (args?: unknown) => Promise<unknown>;
+    };
+
+    await expect(chat.listSessions?.({
+      laneId: " lane-1 ",
+      includeAutomation: true,
+    })).resolves.toEqual([]);
+    expect(listAllowedAdeActionNames("chat", chat as Record<string, unknown>)).toContain("listSessions");
+    expect(listSessions).toHaveBeenCalledWith("lane-1", { includeAutomation: true });
+  });
+
   it("exposes the browser panel and tab control surface", () => {
     const actions = ADE_ACTION_ALLOWLIST.built_in_browser ?? [];
     for (const name of ["claim", "startSession", "listSessions", "endSession", "showPanel", "navigate", "createTab", "switchTab", "closeTab", "observe", "getTrace", "click", "typeText", "dispatchKey", "scroll", "fill", "clear", "wait"]) {
@@ -640,6 +665,32 @@ describe("runtime session actions", () => {
     });
   });
 
+  it("forwards remote subagent transcript reads through chat actions", async () => {
+    const transcript = [{ role: "assistant", content: "subagent output" }];
+    const getSubagentTranscript = vi.fn(async () => transcript);
+    const runtime = {
+      agentChatService: {
+        getSubagentTranscript,
+      },
+    } as unknown as Parameters<typeof getAdeActionDomainServices>[0];
+    const chatService = getAdeActionDomainServices(runtime).chat as {
+      getSubagentTranscript: (args: {
+        sessionId: string;
+        subagentId: string;
+      }) => Promise<Array<{ role: string; content: string }>>;
+    } & Record<string, unknown>;
+
+    expect(listAllowedAdeActionNames("chat", chatService)).toContain("getSubagentTranscript");
+    await expect(chatService.getSubagentTranscript({
+      sessionId: "chat-1",
+      subagentId: "subagent-1",
+    })).resolves.toEqual(transcript);
+    expect(getSubagentTranscript).toHaveBeenCalledWith({
+      sessionId: "chat-1",
+      subagentId: "subagent-1",
+    });
+  });
+
   it("adds getDelta from the runtime session delta service", () => {
     const delta = { sessionId: "session-1", filesChanged: 2 };
     const runtime = {

@@ -449,6 +449,7 @@ export const ADE_ACTION_ALLOWLIST: Partial<Record<AdeActionDomain, readonly stri
     "getSessionCapabilities",
     "getSessionSummary",
     "getSlashCommands",
+    "getSubagentTranscript",
     "getTurnFileDiff",
     "getParallelLaunchState",
     "interrupt",
@@ -1022,6 +1023,21 @@ function buildChatDomainService(runtime: AdeRuntime): OpaqueService | null {
           "Terminal service not available.",
         ),
       }),
+    listSessions: (args?: unknown) => {
+      const record = asActionRecord(args);
+      const laneId = typeof record.laneId === "string" && record.laneId.trim()
+        ? record.laneId.trim()
+        : undefined;
+      const options = {
+        ...(typeof record.includeArchived === "boolean" ? { includeArchived: record.includeArchived } : {}),
+        ...(typeof record.includeAutomation === "boolean" ? { includeAutomation: record.includeAutomation } : {}),
+        ...(typeof record.includeIdentity === "boolean" ? { includeIdentity: record.includeIdentity } : {}),
+      };
+      return agentChatService.listSessions(
+        laneId,
+        Object.keys(options).length ? options : undefined,
+      );
+    },
     modelCatalog: (args?: unknown) =>
       agentChatService.getModelCatalog(args && typeof args === "object" ? args as never : undefined),
     codexOpenInCli: async (