Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

lots of small progress

Theo Browne1bd823cd209f
diff --git a/TODO.md b/TODO.md
index e4b6e4b62..d825f3db9 100644
--- a/TODO.md
+++ b/TODO.md
@@ -1,9 +1,9 @@
## TODO
-- [ ] Fix sort order for threads (newest first)
-- [ ] Indicate in thread list which threads are currently working
-- [ ] Logs should be per-thread, not a single events.txt
-- [ ] Audit the logs to identify which events are (and aren't) worth showing to the user, i.e. drop "preamble" and "work" events
-- [ ] Make the "end message" stand out from the work done prior (maybe just a bar between the two that says "worked for 10 minutes 31 seconds" or however long it was)
-- [ ] Better logging of "time to complete" (I want this more than the timestamps tbh)
-- [ ] Remove the left bars on messages to make UI feel "flatter"
+- [x] Fix sort order for threads (newest first)
+- [x] Indicate in thread list which threads are currently working
+- [x] Logs should be per-thread, not a single events.txt
+- [x] Audit the logs to identify which events are (and aren't) worth showing to the user, i.e. drop "preamble" and "work" events
+- [x] Make the "end message" stand out from the work done prior (maybe just a bar between the two that says "worked for 10 minutes 31 seconds" or however long it was)
+- [x] Better logging of "time to complete" (I want this more than the timestamps tbh)
+- [x] Remove the left bars on messages to make UI feel "flatter"
diff --git a/apps/desktop/src/providerManager.test.ts b/apps/desktop/src/providerManager.test.ts
index ba44e312f..3d3516c62 100644
--- a/apps/desktop/src/providerManager.test.ts
+++ b/apps/desktop/src/providerManager.test.ts
@@ -3,20 +3,43 @@ import { describe, expect, it } from "vitest";
import { ProviderManager } from "./providerManager";
describe("ProviderManager", () => {
- it("detaches provider event listener and ends log stream on dispose", () => {
+ it("detaches provider event listener and ends thread log streams on dispose", () => {
const manager = new ProviderManager();
const internals = manager as unknown as {
codex: { listenerCount: (event: string) => number };
- logStream: { writableEnded: boolean; destroyed: boolean };
+ onCodexEvent: (event: {
+ id: string;
+ kind: "notification";
+ provider: "codex";
+ sessionId: string;
+ createdAt: string;
+ method: string;
+ threadId: string;
+ }) => void;
+ threadLogStreams: Map<
+ string,
+ { writableEnded: boolean; destroyed: boolean }
+ >;
};
+ internals.onCodexEvent({
+ id: "evt-1",
+ kind: "notification",
+ provider: "codex",
+ sessionId: "sess-1",
+ createdAt: new Date().toISOString(),
+ method: "thread/started",
+ threadId: "thread-1",
+ });
+ const stream = internals.threadLogStreams.get("thread-1");
+ expect(stream).toBeDefined();
+ if (!stream) return;
expect(internals.codex.listenerCount("event")).toBe(1);
manager.dispose();
expect(internals.codex.listenerCount("event")).toBe(0);
- expect(
- internals.logStream.writableEnded || internals.logStream.destroyed,
- ).toBe(true);
+ expect(stream.writableEnded || stream.destroyed).toBe(true);
+ expect(internals.threadLogStreams.size).toBe(0);
});
it("allows multiple dispose calls", () => {
diff --git a/apps/desktop/src/providerManager.ts b/apps/desktop/src/providerManager.ts
index 68793311e..4d21b2f1f 100644
--- a/apps/desktop/src/providerManager.ts
+++ b/apps/desktop/src/providerManager.ts
@@ -23,14 +23,17 @@ export interface ProviderManagerEvents {
export class ProviderManager extends EventEmitter<ProviderManagerEvents> {
private readonly codex = new CodexAppServerManager();
- private readonly logStream: fs.WriteStream;
+ private readonly threadLogsDir: string;
+ private readonly threadLogStreams = new Map<string, fs.WriteStream>();
+ private readonly sessionThreadIds = new Map<string, string>();
+ private readonly pendingEventsBySession = new Map<string, ProviderEvent[]>();
private disposed = false;
private readonly onCodexEvent = (event: ProviderEvent) => {
if (this.disposed) {
return;
}
- this.logStream.write(`${JSON.stringify(event)}\n`);
+ this.routeEventToThreadLog(event);
this.emit("event", event);
};
@@ -38,10 +41,8 @@ export class ProviderManager extends EventEmitter<ProviderManagerEvents> {
super();
const logsDir = path.resolve(process.cwd(), ".logs");
- fs.mkdirSync(logsDir, { recursive: true });
- this.logStream = fs.createWriteStream(path.join(logsDir, "events.txt"), {
- flags: "a",
- });
+ this.threadLogsDir = path.join(logsDir, "threads");
+ fs.mkdirSync(this.threadLogsDir, { recursive: true });
this.codex.on("event", this.onCodexEvent);
}
@@ -52,7 +53,12 @@ export class ProviderManager extends EventEmitter<ProviderManagerEvents> {
throw new Error(`Provider '${input.provider}' is not implemented yet.`);
}
- return this.codex.startSession(input);
+ const session = await this.codex.startSession(input);
+ if (session.threadId) {
+ this.sessionThreadIds.set(session.sessionId, session.threadId);
+ this.flushPendingSessionEvents(session.sessionId, session.threadId);
+ }
+ return session;
}
async sendTurn(raw: ProviderSendTurnInput): Promise<ProviderTurnStartResult> {
@@ -76,6 +82,8 @@ export class ProviderManager extends EventEmitter<ProviderManagerEvents> {
stopSession(raw: ProviderStopSessionInput): void {
const input = providerStopSessionInputSchema.parse(raw);
this.codex.stopSession(input.sessionId);
+ this.sessionThreadIds.delete(input.sessionId);
+ this.pendingEventsBySession.delete(input.sessionId);
}
listSessions(): ProviderSession[] {
@@ -93,6 +101,94 @@ export class ProviderManager extends EventEmitter<ProviderManagerEvents> {
this.disposed = true;
this.codex.off("event", this.onCodexEvent);
- this.logStream.end();
+ for (const stream of this.threadLogStreams.values()) {
+ stream.end();
+ }
+ this.threadLogStreams.clear();
+ this.sessionThreadIds.clear();
+ this.pendingEventsBySession.clear();
+ }
+
+ private routeEventToThreadLog(event: ProviderEvent): void {
+ const threadId = this.resolveThreadId(event);
+ if (!threadId) {
+ const pending = this.pendingEventsBySession.get(event.sessionId) ?? [];
+ pending.push(event);
+ this.pendingEventsBySession.set(event.sessionId, pending.slice(-100));
+ return;
+ }
+
+ this.flushPendingSessionEvents(event.sessionId, threadId);
+ this.writeThreadEvent(threadId, event);
+ }
+
+ private flushPendingSessionEvents(sessionId: string, threadId: string): void {
+ const pending = this.pendingEventsBySession.get(sessionId);
+ if (!pending || pending.length === 0) {
+ return;
+ }
+
+ for (const event of pending) {
+ this.writeThreadEvent(threadId, event);
+ }
+ this.pendingEventsBySession.delete(sessionId);
+ }
+
+ private resolveThreadId(event: ProviderEvent): string | undefined {
+ const fromPayload = this.readThreadIdFromPayload(event.payload);
+ const threadId =
+ event.threadId ??
+ fromPayload ??
+ this.sessionThreadIds.get(event.sessionId);
+
+ if (threadId) {
+ this.sessionThreadIds.set(event.sessionId, threadId);
+ }
+
+ return threadId;
+ }
+
+ private readThreadIdFromPayload(payload: unknown): string | undefined {
+ if (!payload || typeof payload !== "object") {
+ return undefined;
+ }
+
+ const record = payload as Record<string, unknown>;
+ const direct = record.threadId;
+ if (typeof direct === "string" && direct.length > 0) {
+ return direct;
+ }
+
+ const thread = record.thread;
+ if (!thread || typeof thread !== "object") {
+ return undefined;
+ }
+
+ const nested = (thread as Record<string, unknown>).id;
+ if (typeof nested === "string" && nested.length > 0) {
+ return nested;
+ }
+
+ return undefined;
+ }
+
+ private writeThreadEvent(threadId: string, event: ProviderEvent): void {
+ const stream = this.getOrCreateThreadLogStream(threadId);
+ stream.write(`${JSON.stringify(event)}\n`);
+ }
+
+ private getOrCreateThreadLogStream(threadId: string): fs.WriteStream {
+ const cached = this.threadLogStreams.get(threadId);
+ if (cached) {
+ return cached;
+ }
+
+ const safeThreadId = threadId.replace(/[^a-zA-Z0-9._-]/g, "_");
+ const stream = fs.createWriteStream(
+ path.join(this.threadLogsDir, `${safeThreadId}.events.ndjson`),
+ { flags: "a" },
+ );
+ this.threadLogStreams.set(threadId, stream);
+ return stream;
}
}
diff --git a/apps/renderer/src/components/ChatView.tsx b/apps/renderer/src/components/ChatView.tsx
index 641bc5816..dd53ae851 100644
--- a/apps/renderer/src/components/ChatView.tsx
+++ b/apps/renderer/src/components/ChatView.tsx
@@ -1,5 +1,6 @@
import {
type FormEvent,
+ Fragment,
type KeyboardEvent,
useEffect,
useMemo,
@@ -18,6 +19,7 @@ import {
derivePhase,
deriveTimelineEntries,
deriveWorkLogEntries,
+ formatDuration,
formatElapsed,
formatTimestamp,
readNativeApi,
@@ -67,12 +69,13 @@ export default function ChatView() {
);
const phase = derivePhase(activeThread?.session ?? null);
const isWorking = phase === "running" || isSending || isConnecting;
- const activeTurnId = activeThread?.session?.activeTurnId;
+ const workLogTurnId =
+ activeThread?.latestTurnId ?? activeThread?.session?.activeTurnId;
const nowIso = new Date(nowTick).toISOString();
const modelOptions = MODEL_OPTIONS;
const workLogEntries = useMemo(
- () => deriveWorkLogEntries(activeThread?.events ?? [], activeTurnId),
- [activeThread?.events, activeTurnId],
+ () => deriveWorkLogEntries(activeThread?.events ?? [], workLogTurnId),
+ [activeThread?.events, workLogTurnId],
);
const assistantCompletionByItemId = useMemo(() => {
const map = new Map<string, string>();
@@ -85,13 +88,54 @@ export default function ChatView() {
return map;
}, [activeThread?.events]);
const timelineEntries = useMemo(
- () =>
- deriveTimelineEntries(
- activeThread?.messages ?? [],
- isWorking ? workLogEntries : [],
- ),
- [activeThread?.messages, isWorking, workLogEntries],
+ () => deriveTimelineEntries(activeThread?.messages ?? [], workLogEntries),
+ [activeThread?.messages, workLogEntries],
);
+ const completionSummary = useMemo(() => {
+ if (!activeThread?.latestTurnStartedAt) return null;
+ if (!activeThread.latestTurnCompletedAt) return null;
+ if (workLogEntries.length === 0) return null;
+
+ if (
+ typeof activeThread.latestTurnDurationMs === "number" &&
+ Number.isFinite(activeThread.latestTurnDurationMs) &&
+ activeThread.latestTurnDurationMs >= 0
+ ) {
+ return `Worked for ${formatDuration(activeThread.latestTurnDurationMs)}`;
+ }
+
+ const elapsed = formatElapsed(
+ activeThread.latestTurnStartedAt,
+ activeThread.latestTurnCompletedAt,
+ );
+ return elapsed ? `Worked for ${elapsed}` : null;
+ }, [
+ activeThread?.latestTurnStartedAt,
+ activeThread?.latestTurnCompletedAt,
+ activeThread?.latestTurnDurationMs,
+ workLogEntries.length,
+ ]);
+ const completionDividerBeforeEntryId = useMemo(() => {
+ if (!activeThread?.latestTurnStartedAt) return null;
+ if (!activeThread.latestTurnCompletedAt) return null;
+ if (workLogEntries.length === 0) return null;
+
+ const turnStartedAt = Date.parse(activeThread.latestTurnStartedAt);
+ if (Number.isNaN(turnStartedAt)) return null;
+
+ const entry = timelineEntries.find((timelineEntry) => {
+ if (timelineEntry.kind !== "message") return false;
+ if (timelineEntry.message.role !== "assistant") return false;
+ const messageAt = Date.parse(timelineEntry.message.createdAt);
+ return !Number.isNaN(messageAt) && messageAt >= turnStartedAt;
+ });
+ return entry?.id ?? null;
+ }, [
+ activeThread?.latestTurnStartedAt,
+ activeThread?.latestTurnCompletedAt,
+ timelineEntries,
+ workLogEntries.length,
+ ]);
// Auto-scroll on new messages
const messageCount = activeThread?.messages.length ?? 0;
@@ -349,85 +393,96 @@ export default function ChatView() {
</div>
) : (
<div className="mx-auto max-w-3xl space-y-4">
- {timelineEntries.map((timelineEntry) =>
- timelineEntry.kind === "work" ? (
- <div
- key={timelineEntry.id}
- className="border-l-2 border-white/[0.05] pl-4 py-1"
- >
- <p
- className={`py-[2px] text-[12px] leading-relaxed ${workToneClass(timelineEntry.entry.tone)}`}
- >
- {timelineEntry.entry.detail ? (
- <>
- {timelineEntry.entry.label}
- <span className="ml-1.5 font-mono text-[11px] opacity-60">
- {timelineEntry.entry.detail}
- </span>
- </>
- ) : (
- timelineEntry.entry.label
- )}
- </p>
- </div>
- ) : (
- <div key={timelineEntry.id}>
- {timelineEntry.message.role === "user" ? (
- <div className="flex justify-end">
- <div className="max-w-[80%] rounded-2xl rounded-br-sm border border-white/[0.08] bg-white/[0.05] px-4 py-3">
- <pre className="whitespace-pre-wrap break-words font-mono text-sm leading-relaxed text-[#e0e0e0]">
- {timelineEntry.message.text}
- </pre>
- <p className="mt-1.5 text-right text-[10px] text-[#a0a0a0]/30">
- {formatTimestamp(timelineEntry.message.createdAt)}
- </p>
- </div>
+ {timelineEntries.map((timelineEntry, index) => (
+ <Fragment key={timelineEntry.id}>
+ {timelineEntry.kind === "message" &&
+ timelineEntry.message.role === "assistant" &&
+ (completionDividerBeforeEntryId === timelineEntry.id ||
+ timelineEntries[index - 1]?.kind === "work") && (
+ <div className="my-3 flex items-center gap-3">
+ <span className="h-px flex-1 bg-white/[0.1]" />
+ <span className="rounded-full border border-white/[0.12] bg-[#121212] px-2.5 py-1 text-[10px] uppercase tracking-[0.14em] text-[#9a9a9a]/80">
+ {completionSummary
+ ? `Response • ${completionSummary}`
+ : "Response"}
+ </span>
+ <span className="h-px flex-1 bg-white/[0.1]" />
</div>
- ) : (
- <div className="border-l-2 border-white/[0.15] pl-4">
- <ChatMarkdown
- text={
- timelineEntry.message.text ||
- (timelineEntry.message.streaming
- ? ""
- : "(empty response)")
- }
- />
- {timelineEntry.message.streaming && (
- <div className="pt-1.5">
- <span className="inline-flex items-center gap-2 rounded-full border border-sky-400/25 bg-sky-500/[0.08] px-2 py-0.5 text-[10px] text-sky-100/90">
- <span className="inline-flex gap-1">
- <span className="h-1.5 w-1.5 animate-pulse rounded-full bg-sky-100/80" />
- <span className="h-1.5 w-1.5 animate-pulse rounded-full bg-sky-100/80 [animation-delay:150ms]" />
- <span className="h-1.5 w-1.5 animate-pulse rounded-full bg-sky-100/80 [animation-delay:300ms]" />
- </span>
- <span>Thinking</span>
+ )}
+ {timelineEntry.kind === "work" ? (
+ <div className="flex items-start gap-2 py-0.5 pl-1.5">
+ <span className="mt-[7px] h-1.5 w-1.5 shrink-0 rounded-full bg-white/[0.18]" />
+ <p
+ className={`py-[2px] text-[11px] leading-relaxed ${workToneClass(timelineEntry.entry.tone)}`}
+ >
+ {timelineEntry.entry.detail ? (
+ <>
+ {timelineEntry.entry.label}
+ <span className="ml-1.5 font-mono text-[11px] opacity-60">
+ {timelineEntry.entry.detail}
</span>
- </div>
+ </>
+ ) : (
+ timelineEntry.entry.label
)}
- <p className="mt-1.5 text-[10px] text-[#a0a0a0]/30">
- {formatMessageMeta(
- timelineEntry.message.createdAt,
- timelineEntry.message.streaming
- ? formatElapsed(
- timelineEntry.message.createdAt,
- nowIso,
- )
- : formatElapsed(
- timelineEntry.message.createdAt,
- assistantCompletionByItemId.get(
- timelineEntry.message.id,
- ),
- ),
- )}
+ </p>
+ </div>
+ ) : timelineEntry.message.role === "user" ? (
+ <div className="flex justify-end">
+ <div className="max-w-[80%] rounded-2xl rounded-br-sm border border-white/[0.08] bg-white/[0.05] px-4 py-3">
+ <pre className="whitespace-pre-wrap break-words font-mono text-sm leading-relaxed text-[#e0e0e0]">
+ {timelineEntry.message.text}
+ </pre>
+ <p className="mt-1.5 text-right text-[10px] text-[#a0a0a0]/30">
+ {formatTimestamp(timelineEntry.message.createdAt)}
</p>
</div>
- )}
- </div>
- ),
- )}
+ </div>
+ ) : (
+ <div className="px-1 py-0.5">
+ <ChatMarkdown
+ text={
+ timelineEntry.message.text ||
+ (timelineEntry.message.streaming
+ ? ""
+ : "(empty response)")
+ }
+ />
+ {timelineEntry.message.streaming && (
+ <div className="pt-1.5">
+ <span className="inline-flex items-center gap-2 rounded-full border border-sky-400/25 bg-sky-500/[0.08] px-2 py-0.5 text-[10px] text-sky-100/90">
+ <span className="inline-flex gap-1">
+ <span className="h-1.5 w-1.5 animate-pulse rounded-full bg-sky-100/80" />
+ <span className="h-1.5 w-1.5 animate-pulse rounded-full bg-sky-100/80 [animation-delay:150ms]" />
+ <span className="h-1.5 w-1.5 animate-pulse rounded-full bg-sky-100/80 [animation-delay:300ms]" />
+ </span>
+ <span>Thinking</span>
+ </span>
+ </div>
+ )}
+ <p className="mt-1.5 text-[10px] text-[#a0a0a0]/30">
+ {formatMessageMeta(
+ timelineEntry.message.createdAt,
+ timelineEntry.message.streaming
+ ? formatElapsed(
+ timelineEntry.message.createdAt,
+ nowIso,
+ )
+ : formatElapsed(
+ timelineEntry.message.createdAt,
+ assistantCompletionByItemId.get(
+ timelineEntry.message.id,
+ ),
+ ),
+ )}
+ </p>
+ </div>
+ )}
+ </Fragment>
+ ))}
{isWorking && (
- <div className="border-l-2 border-white/[0.05] pl-4 py-1">
+ <div className="flex items-center gap-2 py-0.5 pl-1.5">
+ <span className="h-1.5 w-1.5 shrink-0 rounded-full bg-white/[0.18]" />
<div className="flex items-center pt-1">
<span className="inline-flex items-center gap-[3px]">
<span className="h-1 w-1 rounded-full bg-white/20 animate-pulse" />
diff --git a/apps/renderer/src/components/Sidebar.tsx b/apps/renderer/src/components/Sidebar.tsx
index f476e0fd9..6b1453091 100644
--- a/apps/renderer/src/components/Sidebar.tsx
+++ b/apps/renderer/src/components/Sidebar.tsx
@@ -14,6 +14,14 @@ function formatRelativeTime(iso: string): string {
return `${Math.floor(hours / 24)}d ago`;
}
+function threadStatusLabel(
+ status: "connecting" | "ready" | "running" | "error" | "closed" | undefined,
+): "Working" | "Connecting" | null {
+ if (status === "running") return "Working";
+ if (status === "connecting") return "Connecting";
+ return null;
+}
+
export default function Sidebar() {
const { state, dispatch } = useStore();
const api = useMemo(() => readNativeApi(), []);
@@ -107,9 +115,15 @@ export default function Sidebar() {
{/* Project list */}
<nav className="flex-1 overflow-y-auto px-2">
{state.projects.map((project) => {
- const threads = state.threads.filter(
- (t) => t.projectId === project.id,
- );
+ const threads = state.threads
+ .filter((t) => t.projectId === project.id)
+ .sort((a, b) => {
+ const byDate =
+ new Date(b.createdAt).getTime() -
+ new Date(a.createdAt).getTime();
+ if (byDate !== 0) return byDate;
+ return b.id.localeCompare(a.id);
+ });
return (
<div key={project.id} className="mb-1">
{/* Project header */}
@@ -136,6 +150,9 @@ export default function Sidebar() {
<div className="ml-2 border-l border-white/[0.06] pl-2">
{threads.map((thread) => {
const isActive = state.activeThreadId === thread.id;
+ const threadStatus = threadStatusLabel(
+ thread.session?.status,
+ );
return (
<button
key={thread.id}
@@ -152,9 +169,19 @@ export default function Sidebar() {
})
}
>
- <span className="flex-1 truncate text-xs">
- {thread.title}
- </span>
+ <div className="flex min-w-0 flex-1 items-center gap-1.5">
+ {threadStatus && (
+ <span className="inline-flex items-center gap-1 text-[10px] text-[#7ed8ff]/80">
+ <span className="h-1.5 w-1.5 animate-pulse rounded-full bg-sky-300/80" />
+ <span className="hidden xl:inline">
+ {threadStatus}
+ </span>
+ </span>
+ )}
+ <span className="min-w-0 flex-1 truncate text-xs">
+ {thread.title}
+ </span>
+ </div>
<span className="shrink-0 text-[10px] text-[#a0a0a0]/30">
{formatRelativeTime(thread.createdAt)}
</span>
diff --git a/apps/renderer/src/session-logic.test.ts b/apps/renderer/src/session-logic.test.ts
index 565d72838..cc5d90033 100644
--- a/apps/renderer/src/session-logic.test.ts
+++ b/apps/renderer/src/session-logic.test.ts
@@ -5,6 +5,7 @@ import {
type WorkLogEntry,
applyEventToMessages,
deriveTimelineEntries,
+ deriveWorkLogEntries,
evolveSession,
} from "./session-logic";
import type { ChatMessage } from "./types";
@@ -105,6 +106,63 @@ describe("deriveTimelineEntries", () => {
});
});
+describe("deriveWorkLogEntries", () => {
+ it("drops preamble/work events from the visible work log", () => {
+ const entries = deriveWorkLogEntries(
+ [
+ makeEvent({
+ id: "evt-1",
+ method: "item/started",
+ turnId: "turn-1",
+ createdAt: "2026-02-08T10:00:00.000Z",
+ payload: { item: { type: "preamble", text: "thinking" } },
+ }),
+ makeEvent({
+ id: "evt-2",
+ method: "item/started",
+ turnId: "turn-1",
+ createdAt: "2026-02-08T10:00:01.000Z",
+ payload: { item: { type: "work", text: "planning" } },
+ }),
+ makeEvent({
+ id: "evt-3",
+ method: "item/started",
+ turnId: "turn-1",
+ createdAt: "2026-02-08T10:00:02.000Z",
+ payload: { item: { type: "tool_call", command: "ls -la" } },
+ }),
+ ],
+ "turn-1",
+ );
+
+ expect(entries).toHaveLength(1);
+ expect(entries[0]?.label).toBe("Tool call");
+ });
+
+ it("logs turn completion with elapsed time", () => {
+ const entries = deriveWorkLogEntries(
+ [
+ makeEvent({
+ id: "evt-start",
+ method: "turn/started",
+ turnId: "turn-1",
+ createdAt: "2026-02-08T10:00:00.000Z",
+ }),
+ makeEvent({
+ id: "evt-complete",
+ method: "turn/completed",
+ turnId: "turn-1",
+ createdAt: "2026-02-08T10:00:10.000Z",
+ payload: { turn: { id: "turn-1", status: "completed" } },
+ }),
+ ],
+ "turn-1",
+ );
+
+ expect(entries[0]?.label).toBe("Turn complete in 10s");
+ });
+});
+
describe("evolveSession", () => {
it("updates thread id when thread starts", () => {
const previous = makeSession();
diff --git a/apps/renderer/src/session-logic.ts b/apps/renderer/src/session-logic.ts
index ccba13b9e..191b3ea83 100644
--- a/apps/renderer/src/session-logic.ts
+++ b/apps/renderer/src/session-logic.ts
@@ -96,17 +96,26 @@ function normalizeItemType(raw: string | undefined): string {
return raw.replace(/[_-]/g, " ").replace(/\s+/g, " ").trim().toLowerCase();
}
-function itemTypeMeta(type: string): {
- label: string;
- tone: WorkLogEntry["tone"];
-} {
+function shouldDropItemType(type: string): boolean {
if (
type.includes("preamble") ||
type.includes("reasoning") ||
type.includes("thought")
) {
- return { label: "Preamble", tone: "thinking" };
+ return true;
}
+
+ return type === "work" || type.startsWith("work ");
+}
+
+function shouldDropMethod(method: string): boolean {
+ return /(^|\/)(preamble|work)(\/|$)/i.test(method);
+}
+
+function itemTypeMeta(type: string): {
+ label: string;
+ tone: WorkLogEntry["tone"];
+} {
if (
type.includes("tool") ||
type.includes("command") ||
@@ -146,6 +155,10 @@ function entryFromItemLifecycle(event: ProviderEvent): WorkLogEntry | null {
const payload = asObject(event.payload);
const item = asObject(payload?.item);
const normalizedType = normalizeItemType(asString(item?.type));
+ if (shouldDropItemType(normalizedType) || shouldDropMethod(event.method)) {
+ return null;
+ }
+
const meta = itemTypeMeta(normalizedType);
const isStarted = event.method === "item/started";
const isCompleted = event.method === "item/completed";
@@ -166,6 +179,7 @@ function entryFromItemLifecycle(event: ProviderEvent): WorkLogEntry | null {
function entryFromRequest(event: ProviderEvent): WorkLogEntry | null {
if (event.kind !== "request") return null;
+ if (shouldDropMethod(event.method)) return null;
if (event.method.includes("commandExecution")) {
return {
@@ -202,18 +216,57 @@ function entryFromRequest(event: ProviderEvent): WorkLogEntry | null {
};
}
-function entryFromNotification(event: ProviderEvent): WorkLogEntry | null {
+function entryFromNotification(
+ event: ProviderEvent,
+ turnStartedAt: number,
+): WorkLogEntry | null {
if (event.kind !== "notification") return null;
+ if (shouldDropMethod(event.method)) return null;
if (event.method === "item/agentMessage/delta") return null;
- if (event.method === "turn/started" || event.method === "turn/completed") {
+ if (event.method === "turn/started") {
return null;
}
if (event.method === "thread/started") return null;
+ if (event.method === "turn/completed") {
+ const payload = asObject(event.payload);
+ const turn = asObject(payload?.turn);
+ const status = asString(turn?.status);
+ const turnError = asObject(turn?.error);
+ const turnErrorMessage = asString(turnError?.message);
+ const eventAt = Date.parse(event.createdAt);
+ const durationMs =
+ Number.isNaN(turnStartedAt) ||
+ Number.isNaN(eventAt) ||
+ eventAt < turnStartedAt
+ ? undefined
+ : eventAt - turnStartedAt;
+
+ return {
+ id: event.id,
+ createdAt: event.createdAt,
+ label:
+ status === "failed"
+ ? "Turn failed"
+ : durationMs !== undefined
+ ? `Turn complete in ${formatDuration(durationMs)}`
+ : "Turn complete",
+ ...(turnErrorMessage ? { detail: truncateLine(turnErrorMessage) } : {}),
+ tone: status === "failed" ? "error" : "info",
+ };
+ }
+
const lifecycleEntry = entryFromItemLifecycle(event);
if (lifecycleEntry) return lifecycleEntry;
if (event.method.startsWith("item/")) {
+ const payload = asObject(event.payload);
+ const item = asObject(payload?.item);
+ const normalizedType = normalizeItemType(asString(item?.type));
+ if (shouldDropItemType(normalizedType)) {
+ return null;
+ }
+
return {
id: event.id,
createdAt: event.createdAt,
@@ -227,6 +280,7 @@ function entryFromNotification(event: ProviderEvent): WorkLogEntry | null {
function entryFromError(event: ProviderEvent): WorkLogEntry | null {
if (event.kind !== "error") return null;
+ if (shouldDropMethod(event.method)) return null;
return {
id: event.id,
@@ -237,6 +291,12 @@ function entryFromError(event: ProviderEvent): WorkLogEntry | null {
};
}
+function eventTurnId(event: ProviderEvent): string | undefined {
+ const payload = asObject(event.payload);
+ const turn = asObject(payload?.turn);
+ return event.turnId ?? asString(turn?.id);
+}
+
export function deriveWorkLogEntries(
events: ProviderEvent[],
turnId: string | undefined,
@@ -246,10 +306,7 @@ export function deriveWorkLogEntries(
const turnStartedAtIso = turnId
? ordered.find((event) => {
if (event.method !== "turn/started") return false;
- const payload = asObject(event.payload);
- const turn = asObject(payload?.turn);
- const startedTurnId = event.turnId ?? asString(turn?.id);
- return startedTurnId === turnId;
+ return eventTurnId(event) === turnId;
})?.createdAt
: undefined;
const turnStartedAt = turnStartedAtIso
@@ -258,11 +315,12 @@ export function deriveWorkLogEntries(
for (const event of ordered) {
if (turnId) {
- if (event.turnId && event.turnId !== turnId) {
+ const scopedTurnId = eventTurnId(event);
+ if (scopedTurnId && scopedTurnId !== turnId) {
continue;
}
- if (!event.turnId && !Number.isNaN(turnStartedAt)) {
+ if (!scopedTurnId && !Number.isNaN(turnStartedAt)) {
const eventAt = Date.parse(event.createdAt);
if (!Number.isNaN(eventAt) && eventAt < turnStartedAt) {
continue;
@@ -276,7 +334,7 @@ export function deriveWorkLogEntries(
continue;
}
- const fromNotification = entryFromNotification(event);
+ const fromNotification = entryFromNotification(event, turnStartedAt);
if (fromNotification) {
entries.push(fromNotification);
continue;
diff --git a/apps/renderer/src/store.ts b/apps/renderer/src/store.ts
index 5ae304f4f..4d6b168dd 100644
--- a/apps/renderer/src/store.ts
+++ b/apps/renderer/src/store.ts
@@ -11,7 +11,12 @@ import {
import type { ProviderEvent, ProviderSession } from "@acme/contracts";
import { resolveModelSlug } from "./model-logic";
import { hydratePersistedState, toPersistedState } from "./persistenceSchema";
-import { applyEventToMessages, evolveSession } from "./session-logic";
+import {
+ applyEventToMessages,
+ asObject,
+ asString,
+ evolveSession,
+} from "./session-logic";
import type { Project, Thread } from "./types";
// ── Actions ──────────────────────────────────────────────────────────
@@ -103,6 +108,57 @@ function findThreadBySessionId(
return threads.find((t) => t.session?.sessionId === sessionId);
}
+function getEventTurnId(event: ProviderEvent): string | undefined {
+ if (event.turnId) return event.turnId;
+ const payload = asObject(event.payload);
+ const turn = asObject(payload?.turn);
+ return asString(turn?.id);
+}
+
+function durationMs(startIso: string, endIso: string): number | undefined {
+ const start = Date.parse(startIso);
+ const end = Date.parse(endIso);
+ if (Number.isNaN(start) || Number.isNaN(end) || end < start) {
+ return undefined;
+ }
+
+ return end - start;
+}
+
+function updateTurnFields(
+ thread: Thread,
+ event: ProviderEvent,
+): Partial<Thread> {
+ if (event.method === "turn/started") {
+ return {
+ latestTurnId: getEventTurnId(event) ?? thread.latestTurnId,
+ latestTurnStartedAt: event.createdAt,
+ latestTurnCompletedAt: undefined,
+ latestTurnDurationMs: undefined,
+ };
+ }
+
+ if (event.method === "turn/completed") {
+ const completedTurnId = getEventTurnId(event) ?? thread.latestTurnId;
+ const startedAt =
+ completedTurnId && completedTurnId === thread.latestTurnId
+ ? thread.latestTurnStartedAt
+ : undefined;
+ const elapsed =
+ startedAt && startedAt.length > 0
+ ? durationMs(startedAt, event.createdAt)
+ : undefined;
+
+ return {
+ latestTurnId: completedTurnId ?? thread.latestTurnId,
+ latestTurnCompletedAt: event.createdAt,
+ latestTurnDurationMs: elapsed,
+ };
+ }
+
+ return {};
+}
+
// ── Reducer ──────────────────────────────────────────────────────────
function reducer(state: AppState, action: Action): AppState {
@@ -164,6 +220,7 @@ function reducer(state: AppState, action: Action): AppState {
events: [event, ...t.events].slice(0, 200),
error:
event.kind === "error" && event.message ? event.message : t.error,
+ ...updateTurnFields(t, event),
})),
};
}
@@ -176,6 +233,10 @@ function reducer(state: AppState, action: Action): AppState {
session: action.session,
events: [],
error: null,
+ latestTurnId: undefined,
+ latestTurnStartedAt: undefined,
+ latestTurnCompletedAt: undefined,
+ latestTurnDurationMs: undefined,
})),
};
diff --git a/apps/renderer/src/types.ts b/apps/renderer/src/types.ts
index bac168ae7..663179707 100644
--- a/apps/renderer/src/types.ts
+++ b/apps/renderer/src/types.ts
@@ -28,4 +28,8 @@ export interface Thread {
events: ProviderEvent[];
error: string | null;
createdAt: string;
+ latestTurnId?: string | undefined;
+ latestTurnStartedAt?: string | undefined;
+ latestTurnCompletedAt?: string | undefined;
+ latestTurnDurationMs?: number | undefined;
}