ade code: per-provider Chat/CLI choice + TUI/remote/sync hardening pass

apps/ade-cli/README.md

@@ -192,6 +192,8 @@ sync.getPin   sync.setPin   sync.clearPin
 sync.setActiveLanePresence
 ```
 
+`runtimeEvents.subscribe` returns `eventEpoch`, `nextCursor`, `hasMore`, `gap`, and `oldestCursor`; when `gap` is true, the caller's cursor predates the retained buffer and it should refresh state before resuming from `oldestCursor` / `nextCursor`.
+
 **Project-scoped** — every other request must carry `params.projectId`. `ade/actions/call` (and the legacy ADE action / tool catalog underneath it) is dispatched into the per-project `ProjectScope` returned by `ProjectScopeRegistry.get(projectId)`.
 
 `ade/initialize` advertises `runtimeInfo.multiProject: true` and `capabilities.projects: true`. Clients use that to switch between sending `projectId` per request (multi-project runtime) and the legacy per-process binding (embedded runtime). Sync is owned by the sync service for the most-recently-opened registered project; `ProjectScopeRegistry.ensureSyncHost` refreshes the active sync project when projects are added or removed.
@@ -217,7 +219,7 @@ ade code --print-state             # smoke-test the connection and exit
 ade code remote --target mac --project ADE
                                    # attach to a saved desktop remote machine
 ade code remote session --target mac --project ADE --session chat-1
-                                   # open a remote chat or Claude terminal session
+                                   # open a remote chat or provider CLI terminal session
 ade --socket /path/to/ade.sock code   # attach to a specific local endpoint
 ade --project-root /repo code      # bind to a specific project root
 ```
@@ -291,6 +293,8 @@ ade prs comments pr-id --text
 ade run defs --text
 ade run start web --lane lane-id
 ade shell start --lane lane-id -- npm test
+ade terminal list --lane lane-id --text
+ade terminal resume --terminal session-id --text
 ade new chat --mode chat --lane lane-id --provider codex --model openai/gpt-5.5 --reasoning-effort xhigh --no-fast --permissions full-auto --prompt "fix failing tests"
 ade new chat --mode cli --lane lane-id --provider codex --model openai/gpt-5.5 --reasoning-effort xhigh --no-fast --permissions full-auto --prompt "fix failing tests"
 ade new chat --mode chat --lane auto --lane-name fix-checkout-flow --prompt "fix failing tests"

apps/ade-cli/package.json

@@ -48,6 +48,7 @@
     "opencode-ai": "^1.15.5",
     "react": "^19.2.7",
     "sql.js": "^1.13.0",
+    "string-width": "^4.2.3",
     "ws": "^8.20.0",
     "yaml": "^2.8.2",
     "zod": "^4.3.6"

apps/ade-cli/src/adeRpcServer.ts

@@ -4844,7 +4844,9 @@ async function runTool(args: {
         events: sliced,
         nextCursor: result.nextCursor,
         hasMore: filtered.length > limit || result.hasMore,
-        eventEpoch: result.eventEpoch
+        eventEpoch: result.eventEpoch,
+        gap: result.gap === true,
+        oldestCursor: result.oldestCursor ?? null
       };
     }
     return runtime.eventBuffer.drain(cursor, limit);

apps/ade-cli/src/bootstrap.test.ts

@@ -35,9 +35,73 @@ describe("createEventBuffer", () => {
     const result = buffer.drain(0);
     // Should have IDs 3, 4, 5 (the oldest 1, 2 were evicted)
     expect(result.events.map((e) => e.id)).toEqual([3, 4, 5]);
+    expect(result.gap).toBe(true);
+    expect(result.oldestCursor).toBe(3);
     expect(result.events[0]!.payload).toEqual({ i: 2 });
   });
 
+  it("reports no gap when the next retained event is contiguous with the cursor", () => {
+    const buffer = createEventBuffer(3);
+
+    for (let i = 0; i < 5; i++) {
+      buffer.push({ timestamp: `2026-03-01T00:0${i}:00Z`, category: "runtime", payload: { i } });
+    }
+
+    const result = buffer.drain(2);
+    expect(result.events.map((event) => event.id)).toEqual([3, 4, 5]);
+    expect(result.gap).toBe(false);
+    expect(result.oldestCursor).toBe(3);
+  });
+
+  it("evicts by retained byte budget and reports the replay gap", () => {
+    const buffer = createEventBuffer(10, { maxBytes: 260, maxEventBytes: 260 });
+
+    for (let i = 0; i < 4; i++) {
+      buffer.push({
+        timestamp: `2026-03-01T00:0${i}:00Z`,
+        category: "pty",
+        payload: { data: "x".repeat(90), i },
+      });
+    }
+
+    const result = buffer.drain(0);
+    expect(result.events.length).toBeLessThan(4);
+    expect(result.events.at(-1)?.id).toBe(4);
+    expect(result.gap).toBe(true);
+    expect(result.oldestCursor).toBeGreaterThan(1);
+  });
+
+  it("does not retain events larger than the per-event cap but still notifies live subscribers", () => {
+    const buffer = createEventBuffer(10, { maxBytes: 1024, maxEventBytes: 64 });
+    const seen: BufferedEvent[] = [];
+    buffer.subscribe((event) => seen.push(event));
+
+    buffer.push({
+      timestamp: "2026-03-01T00:00:00Z",
+      category: "pty",
+      payload: { data: "x".repeat(200) },
+    });
+
+    expect(seen).toHaveLength(1);
+    const result = buffer.drain(0);
+    expect(result.events).toEqual([]);
+    expect(result.gap).toBe(true);
+    expect(result.nextCursor).toBe(1);
+  });
+
+  it("reports a replay gap when an oversized event is skipped between retained events", () => {
+    const buffer = createEventBuffer(10, { maxBytes: 4096, maxEventBytes: 180 });
+
+    buffer.push({ timestamp: "2026-03-01T00:00:00Z", category: "runtime", payload: { data: "small-1" } });
+    buffer.push({ timestamp: "2026-03-01T00:00:01Z", category: "runtime", payload: { data: "x".repeat(500) } });
+    buffer.push({ timestamp: "2026-03-01T00:00:02Z", category: "runtime", payload: { data: "small-2" } });
+
+    const result = buffer.drain(1);
+    expect(result.events.map((event) => event.id)).toEqual([3]);
+    expect(result.gap).toBe(true);
+    expect(result.oldestCursor).toBe(3);
+  });
+
   it("drains events after cursor", () => {
     const buffer = createEventBuffer();