Merge remote-tracking branch 'refs/remotes/origin/t3code/codex-turn-mapping' into landing/pr-9903

Author: saphid

apps/mobile/src/features/home/useThreadListActions.ts

@@ -1,4 +1,3 @@
-import { threadRuntimeIsActive } from "@t3tools/client-runtime/state/shell";
 import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell";
 import { canSnooze } from "@t3tools/client-runtime/state/thread-settled";
 import * as Cause from "effect/Cause";
@@ -122,7 +121,7 @@ function useThreadActionExecutor(
         }
         // Archive keeps its original, narrower guard: never interrupt a
         // thread mid-turn.
-        if (action === "archive" && threadRuntimeIsActive(thread.runtime)) {
+        if (action === "archive" && !threadCanArchive(thread.runtime)) {
           Alert.alert(
             actionFailureTitle(action),
             "This thread is working. Interrupt it first, then try again.",

apps/mobile/src/features/threads/ThreadFeed.tsx

@@ -1517,9 +1517,7 @@ function renderFeedEntry(
     const renderedText = renderAssistantCitationsAsText(message.text);
     const styles = isUser ? markdownStyles.user : markdownStyles.assistant;
     const timestampLabel = formatMessageTime(isUser ? message.createdAt : message.updatedAt);
-    const attachments = (message.attachments ?? []).filter(
-      (attachment) => attachment.type === "image",
-    );
+    const attachments = message.attachments ?? [];
     const hasReviewCommentContext = message.text.includes("<review_comment");
     // A bubble that sizes itself from its content cannot lay out a block whose
     // intrinsic width overflows `maxWidth`: Android positions the bubble's

apps/server/src/cli/project.test.ts

@@ -5,17 +5,33 @@ import * as NodePath from "node:path";
 
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { assert, it } from "@effect/vitest";
-import { EnvironmentInternalError } from "@t3tools/contracts";
+import {
+  CommandId,
+  EnvironmentInternalError,
+  EventId,
+  ProviderInstanceId,
+  ThreadId,
+  type OrchestrationV2AppThread,
+  type ProjectId,
+} from "@t3tools/contracts";
 import * as NetService from "@t3tools/shared/Net";
+import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as References from "effect/References";
+import * as Stream from "effect/Stream";
 import { Command } from "effect/unstable/cli";
 
 import { cli } from "../bin.ts";
 import * as ServerConfig from "../config.ts";
-import { ProjectServiceLayerLive } from "../orchestration-v2/runtimeLayer.ts";
+import { EventSinkV2 } from "../orchestration-v2/EventSink.ts";
+import * as EventStore from "../orchestration-v2/EventStore.ts";
+import * as ProjectionStore from "../orchestration-v2/ProjectionStore.ts";
+import {
+  OrchestrationV2EventSinkLayerLive,
+  ProjectServiceLayerLive,
+} from "../orchestration-v2/runtimeLayer.ts";
 import { layerConfig as SqlitePersistenceLayerLive } from "../persistence/Layers/Sqlite.ts";
 import * as ProjectEnrichmentService from "../project/ProjectEnrichmentService.ts";
 import * as ProjectFaviconResolver from "../project/ProjectFaviconResolver.ts";
@@ -146,6 +162,189 @@ const makeProjectLookupFixture = Effect.fn("ProjectCliTest.makeProjectLookupFixt
   return { baseDir, workspaceRoot, project: project! };
 });
 
+const makeThreadPersistenceLayer = Effect.fn("ProjectCliTest.makeThreadPersistenceLayer")(
+  function* (baseDir: string) {
+    const config = yield* makeConfig(baseDir);
+    return Layer.mergeAll(
+      OrchestrationV2EventSinkLayerLive,
+      ProjectionStore.layer,
+      EventStore.layer,
+    ).pipe(
+      Layer.provideMerge(SqlitePersistenceLayerLive),
+      Layer.provideMerge(NodeServices.layer),
+      Layer.provide(ServerConfig.layer(config)),
+      Layer.provide(Layer.succeed(References.MinimumLogLevel, config.logLevel)),
+    );
+  },
+);
+
+const seedNativeThreads = Effect.fn("ProjectCliTest.seedNativeThreads")(function* (
+  baseDir: string,
+  threads: ReadonlyArray<{
+    readonly id: ThreadId;
+    readonly projectId: ProjectId;
+    readonly archived: boolean;
+  }>,
+) {
+  const layer = yield* makeThreadPersistenceLayer(baseDir);
+  const createdAt = DateTime.makeUnsafe("2026-09-04T12:00:00.000Z");
+  const providerInstanceId = ProviderInstanceId.make("codex");
+  yield* Effect.gen(function* () {
+    const eventSink = yield* EventSinkV2;
+    yield* eventSink.write({
+      commandId: CommandId.make("project-cli-seed-threads"),
+      events: threads.map(({ id, projectId, archived }) => {
+        const payload: OrchestrationV2AppThread = {
+          createdBy: "user",
+          creationSource: "web",
+          id,
+          projectId,
+          title: id,
+          providerInstanceId,
+          modelSelection: { instanceId: providerInstanceId, model: "gpt-5" },
+          runtimeMode: "full-access",
+          interactionMode: "default",
+          branch: null,
+          worktreePath: null,
+          activeProviderThreadId: null,
+          lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: id },
+          forkedFrom: null,
+          createdAt,
+          updatedAt: createdAt,
+          archivedAt: archived ? createdAt : null,
+          settledOverride: null,
+          settledAt: null,
+          lastVisitedAt: null,
+          deletedAt: null,
+        };
+        return {
+          id: EventId.make(`project-cli-create-${id}`),
+          type: "thread.created" as const,
+          threadId: id,
+          providerInstanceId,
+          occurredAt: createdAt,
+          payload,
+        };
+      }),
+    });
+  }).pipe(Effect.provide(layer));
+});
+
+const readNativeThreadState = Effect.fn("ProjectCliTest.readNativeThreadState")(function* (
+  baseDir: string,
+  threadId: ThreadId,
+) {
+  const layer = yield* makeThreadPersistenceLayer(baseDir);
+  return yield* Effect.gen(function* () {
+    const projections = yield* ProjectionStore.ProjectionStoreV2;
+    const events = yield* EventStore.EventStoreV2;
+    return {
+      thread: yield* projections.getThread(threadId),
+      events: yield* events.read({ threadId }).pipe(Stream.runCollect),
+    };
+  }).pipe(Effect.provide(layer));
+});
+
+it.layer(NodeServices.layer)("project deletion with native V2 threads", (it) => {
+  it.effect.each([
+    { label: "an active thread", archived: false, missing: false },
+    { label: "an archived thread", archived: true, missing: false },
+    {
+      label: "an active thread after its workspace disappears",
+      archived: false,
+      missing: true,
+    },
+    {
+      label: "an archived thread after its workspace disappears",
+      archived: true,
+      missing: true,
+    },
+  ])("rejects unforced removal of a project with $label", ({ archived, missing }) =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const { baseDir, workspaceRoot, project } = yield* makeProjectLookupFixture();
+      const threadId = ThreadId.make("project-cli-preserved-thread");
+      yield* seedNativeThreads(baseDir, [{ id: threadId, projectId: project.id, archived }]);
+      const before = yield* readNativeThreadState(baseDir, threadId);
+      if (missing) yield* fs.rename(workspaceRoot, `${workspaceRoot}-removed`);
+
+      const error = yield* runCli([
+        "project",
+        "remove",
+        missing ? workspaceRoot : project.id,
+        "--base-dir",
+        baseDir,
+      ]).pipe(
+        Effect.match({
+          onFailure: (error) => error,
+          onSuccess: () => assert.fail("Removing a nonempty project must require --force."),
+        }),
+      );
+
+      assert.include(error.message, "not empty");
+      assert.deepEqual(
+        (yield* readProjects(baseDir)).projects.map((entry) => entry.id),
+        [project.id],
+      );
+      assert.deepEqual(yield* readNativeThreadState(baseDir, threadId), before);
+      assert.equal(yield* fs.exists(workspaceRoot), !missing);
+    }),
+  );
+
+  it.effect.each(["present", "missing"] as const)(
+    "force-removes active and archived V2 threads with the workspace %s, preserving unrelated projects",
+    (workspace) =>
+      Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const { baseDir, workspaceRoot, project } = yield* makeProjectLookupFixture();
+        const otherWorkspace = `${workspaceRoot}-other`;
+        yield* fs.makeDirectory(otherWorkspace);
+        yield* runCli(["project", "add", otherWorkspace, "--base-dir", baseDir]);
+        const otherProject = (yield* readProjects(baseDir)).projects.find(
+          (entry) => entry.workspaceRoot === otherWorkspace,
+        );
+        assert.isDefined(otherProject);
+        const activeId = ThreadId.make("project-cli-deleted-active");
+        const archivedId = ThreadId.make("project-cli-deleted-archived");
+        const unrelatedId = ThreadId.make("project-cli-unrelated-thread");
+        yield* seedNativeThreads(baseDir, [
+          { id: activeId, projectId: project.id, archived: false },
+          { id: archivedId, projectId: project.id, archived: true },
+          { id: unrelatedId, projectId: otherProject!.id, archived: false },
+        ]);
+        const unrelatedBefore = yield* readNativeThreadState(baseDir, unrelatedId);
+        if (workspace === "missing") {
+          yield* fs.rename(workspaceRoot, `${workspaceRoot}-removed`);
+        }
+
+        yield* runCli([
+          "project",
+          "remove",
+          workspace === "missing" ? workspaceRoot : project.id,
+          "--force",
+          "--base-dir",
+          baseDir,
+        ]);
+
+        assert.deepEqual(
+          (yield* readProjects(baseDir)).projects.map((entry) => entry.id),
+          [otherProject!.id],
+        );
+        for (const threadId of [activeId, archivedId]) {
+          const state = yield* readNativeThreadState(baseDir, threadId);
+          assert.isNotNull(state.thread.deletedAt);
+          assert.lengthOf(
+            state.events.filter((record) => record.event.type === "thread.deleted"),
+            1,
+          );
+        }
+        assert.deepEqual(yield* readNativeThreadState(baseDir, unrelatedId), unrelatedBefore);
+        assert.equal(yield* fs.exists(workspaceRoot), workspace === "present");
+        assert.isTrue(yield* fs.exists(otherWorkspace));
+      }),
+  );
+});
+
 it.layer(NodeServices.layer)("project lookup with unavailable workspaces", (it) => {
   it.effect.each(["id", "stored path"] as const)(
     "removes an empty project by %s after its directory is gone",

apps/server/src/cli/project.ts

@@ -455,7 +455,11 @@ const runProjectMutation = Effect.fn("runProjectMutation")(function* (
                   })
                   .pipe(Effect.asVoid)
               : projects
-                  .delete({ commandId: command.commandId, projectId: command.projectId })
+                  .delete({
+                    commandId: command.commandId,
+                    projectId: command.projectId,
+                    ...(command.force === undefined ? {} : { force: command.force }),
+                  })
                   .pipe(Effect.asVoid),
         mode: "offline",
       });

apps/server/src/mcp/McpHttpServer.ts

@@ -12,6 +12,7 @@ import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/unstab
 import packageJson from "../../package.json" with { type: "json" };
 import * as McpInvocationContext from "./McpInvocationContext.ts";
 import * as OrchestratorMcpService from "./OrchestratorMcpService.ts";
+import * as ThreadMetadataMcpService from "./ThreadMetadataMcpService.ts";
 import * as McpSessionRegistry from "./McpSessionRegistry.ts";
 import * as PreviewAutomationBroker from "./PreviewAutomationBroker.ts";
 import { OrchestratorToolkitHandlersLive } from "./toolkits/orchestrator/handlers.ts";
@@ -224,6 +225,7 @@ export const PreviewToolkitRegistrationLive = Layer.mergeAll(
 export const OrchestratorToolkitRegistrationLive = McpServer.toolkit(OrchestratorToolkit).pipe(
   Layer.provide(OrchestratorToolkitHandlersLive),
   Layer.provide(OrchestratorMcpService.layer),
+  Layer.provide(ThreadMetadataMcpService.layer),
 );
 
 export const WorktreeToolkitRegistrationLive = McpServer.toolkit(WorktreeToolkit).pipe(

apps/server/src/mcp/OrchestratorMcpService.ts

@@ -549,6 +549,7 @@ function listItemFromShell(shell: OrchestrationV2ThreadShell): OrchestratorMcpTh
     model: shell.modelSelection.model,
     runtimeMode: shell.runtimeMode,
     interactionMode: shell.interactionMode,
+    linkedPullRequest: shell.linkedPullRequest ?? null,
     parentThreadId: shell.lineage.parentThreadId,
     relationshipToParent: shell.lineage.relationshipToParent,
     itemCount: shell.visibleItemCount,
@@ -573,6 +574,15 @@ function threadDetail(projection: OrchestrationV2ThreadProjection): Orchestrator
     model: projection.thread.modelSelection.model,
     runtimeMode: projection.thread.runtimeMode,
     interactionMode: projection.thread.interactionMode,
+    linkedPullRequest: projection.thread.linkedPullRequest ?? null,
+    titleRegeneration:
+      projection.thread.titleRegeneration === undefined ||
+      projection.thread.titleRegeneration === null
+        ? null
+        : {
+            requestId: projection.thread.titleRegeneration.requestId,
+            startedAt: DateTime.formatIso(projection.thread.titleRegeneration.startedAt),
+          },
     branch: projection.thread.branch,
     worktreePath: projection.thread.worktreePath,
     parentThreadId: projection.thread.lineage.parentThreadId,