Release v0.2.14

Author: dxcodeagent

RELEASE.json

@@ -1,13 +1,13 @@
 {
-  "version": "0.2.13",
+  "version": "0.2.14",
   "license": "FSL-1.1-ALv2",
   "baselineSha256": "7847f65a9b20b366a60d52d19ca3cd6bdd1bb09b8cb506659a270f27a21d8877",
   "e2b": {
     "recipeSha256": "761809ee2efa2b6c750451ace29283cbb8e55b6ce3b5b14c2bb4509df71df801",
     "profileSha256": "414dbecee2d47de36016ea05c736e2edff3a0deb298babf923887ea184a01c10"
   },
   "dxd": {
-    "url": "https://github.com/dxcode-dev/dxcode/releases/download/v0.2.13/dxd-linux-x64",
+    "url": "https://github.com/dxcode-dev/dxcode/releases/download/v0.2.14/dxd-linux-x64",
     "sha256": "b793f9d2c7032e5fe3e233e40fc906b12648c3dd53969b5b7ef44d2d075d219b"
   },
   "toolchain": {

apps/core/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dx/core",
   "private": true,
-  "version": "0.2.13",
+  "version": "0.2.14",
   "license": "FSL-1.1-ALv2",
   "type": "module",
   "scripts": {

apps/core/src/threads/routes.ts

@@ -68,7 +68,7 @@ import {
   WorkspaceRepository,
 } from "@dx/domain";
 import { D1Client } from "@effect/sql-d1";
-import { dispatch } from "@flue/runtime";
+import { dispatch, getAgentInstance } from "@flue/runtime";
 import { Effect, Layer, Match, Option, Result, Schema } from "effect";
 import { Hono } from "hono";
 import { DxAgent } from "../agents/dx-agent.js";
@@ -341,6 +341,15 @@ type InitialThreadDispatcher = (
 const dispatchInitialThreadMessage: InitialThreadDispatcher = (request) =>
   dispatch(DxAgent, request);
 
+/**
+ * Starts the Thread's agent Durable Object without changing it, so its cold
+ * start overlaps model resolution and persistence instead of following them.
+ */
+type InitialThreadAgentWarmer = (threadId: ThreadId) => Promise<unknown>;
+
+const warmInitialThreadAgent: InitialThreadAgentWarmer = (threadId) =>
+  getAgentInstance(DxAgent, threadId);
+
 const resolveCreationResponseDetail = <
   Detail,
   DetailError,
@@ -377,6 +386,7 @@ const resolveCreationResponseDetail = <
 export const createThreadRoutes = (
   dispatchInitialMessage: InitialThreadDispatcher = dispatchInitialThreadMessage,
   titleAgent: DxTitleAgentRunner = runDxTitleAgent,
+  warmInitialAgent: InitialThreadAgentWarmer = warmInitialThreadAgent,
 ) => {
   const threadRoutes = new Hono<AppEnv>();
 
@@ -386,6 +396,18 @@ export const createThreadRoutes = (
     let requestAdmittedAt = startedAt;
     let sourceAuthorizedAt = startedAt;
     let threadPersistedAt = startedAt;
+    let agentWarmedAt: number | undefined;
+    let detailResolvedAt: number | undefined;
+    let initialMessageAdmittedAt: number | undefined;
+    // Creation outlives the request: once it reaches Core, a closed tab or a
+    // dropped connection cannot stop the Thread or its first message.
+    const execution = (() => {
+      try {
+        return context.executionCtx;
+      } catch {
+        return undefined;
+      }
+    })();
     let settleTitlePersisted: ((persisted: boolean) => void) | undefined;
     let recoveredConcurrentCreation = false;
     const operation = Effect.gen(function* () {
@@ -403,13 +425,7 @@ export const createThreadRoutes = (
       const principal = context.get("principal");
       const requestedThreadId = input.threadId;
       // DxTitleAgent needs an execution context to outlive the response.
-      const titleExecution = (() => {
-        try {
-          return context.executionCtx;
-        } catch {
-          return undefined;
-        }
-      })();
+      const titleExecution = execution;
       const existingThread =
         requestedThreadId === undefined
           ? undefined
@@ -647,6 +663,23 @@ export const createThreadRoutes = (
       threadPersistedAt = Date.now();
       settleTitlePersisted?.(!recoveredConcurrentCreation);
       const initialMessage = input.initialMessage;
+      // The Thread now exists, so its agent is real: start it while the
+      // detail and author are read, ahead of the dispatch below.
+      if (initialMessage !== undefined)
+        void warmInitialAgent(thread.id).then(
+          () => {
+            agentWarmedAt = Date.now();
+          },
+          () => undefined,
+        );
+      // The author identity is read beside the detail, not after it.
+      const ownerIdentity =
+        initialMessage === undefined
+          ? undefined
+          : userIdentity(db, thread.ownerUserId).then(
+              (identity) => ({ identity }),
+              () => ({ identity: undefined }),
+            );
       const detail = yield* resolveCreationResponseDetail(
         threadDetailData(context.env.DB, db, thread),
         initialMessage === undefined
@@ -657,13 +690,17 @@ export const createThreadRoutes = (
               ),
             ),
       );
+      detailResolvedAt = Date.now();
       let initialSubmission: { readonly submissionId: string } | undefined;
       const messageSourceThreadId = context.get("messageSourceThreadId");
-      if (initialMessage !== undefined) {
-        const owner = yield* Effect.tryPromise({
-          try: () => userIdentity(db, thread.ownerUserId),
-          catch: () => new ThreadInitialAdmissionUnavailable(),
-        });
+      if (initialMessage !== undefined && ownerIdentity !== undefined) {
+        const owner = yield* Effect.flatMap(
+          Effect.promise(() => ownerIdentity),
+          ({ identity }) =>
+            identity === undefined
+              ? Effect.fail(new ThreadInitialAdmissionUnavailable())
+              : Effect.succeed(identity),
+        );
         const receipt = yield* Effect.tryPromise({
           try: () =>
             dispatchInitialMessage({
@@ -693,6 +730,7 @@ export const createThreadRoutes = (
           catch: () => new ThreadInitialAdmissionUnavailable(),
         });
         initialSubmission = { submissionId: receipt.submissionId };
+        initialMessageAdmittedAt = Date.now();
         const observations = submissionStartupObservations(
           requestId,
           thread.id,
@@ -717,16 +755,23 @@ export const createThreadRoutes = (
       return { body, threadId: thread.id };
     });
 
-    const result = await Effect.runPromise(Effect.result(operation));
-    // A creation that failed before persisting leaves no row to title.
-    settleTitlePersisted?.(false);
+    const completion = Effect.runPromise(Effect.result(operation)).then(
+      async (result) => {
+        // A creation that failed before persisting leaves no row to title.
+        settleTitlePersisted?.(false);
+        if (Result.isSuccess(result))
+          await scheduleRealtimeInvalidation(
+            () => context.executionCtx,
+            context.env,
+            result.success.threadId,
+            "thread.invalidated",
+          );
+        return result;
+      },
+    );
+    execution?.waitUntil(completion);
+    const result = await completion;
     if (Result.isSuccess(result)) {
-      await scheduleRealtimeInvalidation(
-        () => context.executionCtx,
-        context.env,
-        result.success.threadId,
-        "thread.invalidated",
-      );
       const responseReadyAt = Date.now();
       const decodedCorrelation = Schema.decodeUnknownResult(
         StartupTraceCorrelation,
@@ -764,7 +809,21 @@ export const createThreadRoutes = (
           responseReadyAt,
         ),
       ];
-      context.header("Server-Timing", startupServerTiming(observations));
+      // Header-only marks between persistence and the response.
+      const responseMarks = [
+        ["agent_warmed", agentWarmedAt],
+        ["detail_resolved", detailResolvedAt],
+        ["initial_message_admitted", initialMessageAdmittedAt],
+      ] as const;
+      context.header(
+        "Server-Timing",
+        [
+          startupServerTiming(observations),
+          ...responseMarks.flatMap(([phase, at]) =>
+            at === undefined ? [] : [`dx_${phase};dur=${at - startedAt}`],
+          ),
+        ].join(", "),
+      );
       await scheduleStartupPersistence(
         () => context.executionCtx,
         recordStartupPhases(context.env.DB, observations),

apps/docs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dx/docs",
   "private": true,
-  "version": "0.2.13",
+  "version": "0.2.14",
   "license": "FSL-1.1-ALv2",
   "type": "module",
   "scripts": {

apps/web/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dx/web",
   "private": true,
-  "version": "0.2.13",
+  "version": "0.2.14",
   "license": "FSL-1.1-ALv2",
   "type": "module",
   "scripts": {

apps/web/src/features/navigation/app-sidebar.tsx

@@ -9,15 +9,21 @@ import { useDebouncer } from "@tanstack/react-pacer";
 import { Link, useLocation } from "@tanstack/react-router";
 import { Search, SquarePen } from "lucide-react";
 import * as React from "react";
-import { useNewThreadSurface } from "../../shared/new-thread-surface.js";
+import {
+  type PendingThreadCreation,
+  useNewThreadSurface,
+} from "../../shared/new-thread-surface.js";
 import { useThreadArchive } from "../../shared/thread-archive.js";
 import { Button } from "../../shared/ui/button.js";
 import { SidebarAccountMenu } from "./sidebar-account-menu.js";
 import { SidebarArchive } from "./sidebar-archive.js";
 import { ProjectsIcon } from "./sidebar-icons.js";
 import { SidebarPanelIcon } from "./sidebar-panel-icon.js";
 import { SidebarThreadNavigation } from "./sidebar-thread-navigation.js";
-import { buildThreadSections } from "./sidebar-thread-utils.js";
+import {
+  buildThreadSections,
+  withPendingThreads,
+} from "./sidebar-thread-utils.js";
 import {
   ThreadHoverPreview,
   type ThreadPreviewAnchor,
@@ -137,27 +143,26 @@ const useThreadPreviewIntent = () => {
   };
 };
 
-const usePendingProjectlessCreation = (
+const noPendingCreations: ReadonlyArray<PendingThreadCreation> = [];
+const readNoPendingCreations = () => noPendingCreations;
+const subscribeNothing = () => () => undefined;
+
+const usePendingCreations = (
   surface: ReturnType<typeof useNewThreadSurface>,
-  threadId: string | undefined,
 ) => {
-  const subscribe = React.useCallback(
-    (listener: () => void) =>
-      surface.subscribePendingProjectlessCreation?.(listener) ??
-      (() => undefined),
-    [surface],
+  const read = surface.pendingCreations ?? readNoPendingCreations;
+  return React.useSyncExternalStore(
+    surface.subscribePendingCreations ?? subscribeNothing,
+    read,
+    read,
   );
-  const snapshot = React.useCallback(() => {
-    if (threadId === undefined) return undefined;
-    return surface.pendingProjectlessCreation?.(threadId);
-  }, [surface, threadId]);
-  return React.useSyncExternalStore(subscribe, snapshot, snapshot);
 };
 
 export function AppSidebar({
   userId,
   archiveAvailable = userId !== undefined,
   projects,
+  projectsComplete = false,
   threads,
   sharedThreads,
   personalAccount,
@@ -179,6 +184,8 @@ export function AppSidebar({
   readonly userId?: UserId;
   readonly archiveAvailable?: boolean;
   readonly projects: ReadonlyArray<ProjectData>;
+  /** Every Project the user can see is loaded, so unnamed ones are hidden. */
+  readonly projectsComplete?: boolean;
   readonly threads: ReadonlyArray<ThreadData>;
   /** Shared Threads of other workspace members that this user follows. */
   readonly sharedThreads?: ReadonlyArray<ThreadData>;
@@ -205,10 +212,7 @@ export function AppSidebar({
   const activeThreadId = pathname.startsWith("/threads/")
     ? pathname.slice("/threads/".length)
     : undefined;
-  const pendingCreation = usePendingProjectlessCreation(
-    newThreadSurface,
-    activeThreadId,
-  );
+  const pendingCreations = usePendingCreations(newThreadSurface);
   const [collapsedGroups, setCollapsedGroups] = React.useState<
     ReadonlySet<string>
   >(() => new Set(["inactive", "archived"]));
@@ -240,9 +244,19 @@ export function AppSidebar({
     },
     [dismissPreviewForNavigation, onNavigate],
   );
+  const listedThreads = React.useMemo(
+    () =>
+      withPendingThreads(
+        threads,
+        pendingCreations,
+        projectNames,
+        projectsComplete,
+      ),
+    [threads, pendingCreations, projectNames, projectsComplete],
+  );
   const sections = buildThreadSections(
     projects,
-    threads,
+    listedThreads,
     Date.now(),
     archiveAvailable,
     sharedThreads,
@@ -329,15 +343,14 @@ export function AppSidebar({
           )
         }
         activeThreadId={activeThreadId}
-        pendingCreation={pendingCreation}
         collapsedGroups={collapsedGroups}
         hasMore={hasMore}
         loadingMore={loadingMore}
         loadMoreError={loadMoreError}
         projectNames={projectNames}
         query=""
         sections={sections}
-        visibleThreadCount={threads.length + (sharedThreads?.length ?? 0)}
+        visibleThreadCount={listedThreads.length + (sharedThreads?.length ?? 0)}
         onLoadMore={onLoadMore}
         onNavigate={onNavigate}
         onThreadNavigate={onThreadNavigate}

apps/web/src/features/navigation/product-shell.tsx

@@ -122,6 +122,7 @@ export function ProductShell() {
       userId={identity.id}
       archiveAvailable={archiveAvailable}
       projects={projects}
+      projectsComplete={projectsQuery.isSuccess && !projectsQuery.hasNextPage}
       threads={threads}
       sharedThreads={sharedThreadsQuery.data}
       onUnfollow={unfollowThread}