t3code-cli 0.10.0 → 0.11.0

package/src/application/thread-update.ts

@@ -0,0 +1,72 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import type { ModelSelection } from "#t3tools/contracts";
+
+import { ModelSelectionError, ThreadEventError } from "../domain/error.ts";
+import { T3Orchestration } from "../orchestration/service.ts";
+import { mergeModelOptions, resolveUpdateModelSelection } from "./model-selection.ts";
+import type { UpdateThreadInput } from "./service.ts";
+import { makeThreadMetaUpdateCommand } from "./thread-commands.ts";
+
+export function makeUpdateThread() {
+  return Effect.fn("T3ApplicationLive.updateThread")(function* (input: UpdateThreadInput) {
+    const orchestration = yield* T3Orchestration;
+    const crypto = yield* Crypto.Crypto;
+    const hasProvider = input.provider !== undefined && input.provider.length > 0;
+    const hasModel = input.model !== undefined && input.model.length > 0;
+    const options = input.options;
+    const hasOptions = options !== undefined && options.length > 0;
+    const thread = yield* orchestration.getThreadSnapshot(input.threadId);
+    let modelSelection: ModelSelection | undefined;
+    if (hasProvider || hasModel) {
+      const snapshot = yield* orchestration.getShellSnapshot();
+      const project = snapshot.projects.find((entry) => entry.id === thread.projectId);
+      if (project === undefined) {
+        return yield* Effect.fail(
+          new ThreadEventError({
+            message: `project not found for thread: ${input.threadId}`,
+          }),
+        );
+      }
+      const serverConfig = yield* orchestration.getServerConfig();
+      if (hasProvider && thread.session !== null && thread.session.status !== "stopped") {
+        const sessionProviderId =
+          thread.session.providerInstanceId ?? thread.modelSelection.instanceId;
+        const sessionProvider = serverConfig.providers.find(
+          (provider) => provider.instanceId === sessionProviderId,
+        );
+        const targetProvider = serverConfig.providers.find(
+          (provider) => provider.instanceId === input.provider,
+        );
+        if (
+          sessionProvider !== undefined &&
+          targetProvider !== undefined &&
+          targetProvider.driver !== sessionProvider.driver
+        ) {
+          return yield* Effect.fail(
+            new ModelSelectionError({
+              message: `thread ${input.threadId} is bound to ${sessionProvider.driver} provider ${sessionProviderId}; cannot update provider to ${targetProvider.driver} provider ${input.provider}`,
+            }),
+          );
+        }
+      }
+      modelSelection = yield* resolveUpdateModelSelection({
+        current: thread.modelSelection,
+        ...(hasProvider ? { provider: input.provider } : {}),
+        ...(hasModel ? { model: input.model } : {}),
+        ...(hasOptions ? { options } : {}),
+        project,
+        serverConfig,
+      });
+    } else if (hasOptions) {
+      modelSelection = mergeModelOptions(thread.modelSelection, options);
+    }
+    const command = yield* makeThreadMetaUpdateCommand(input.threadId, {
+      ...(input.title !== undefined ? { title: input.title } : {}),
+      ...(modelSelection !== undefined ? { modelSelection } : {}),
+      ...(input.branch !== undefined ? { branch: input.branch } : {}),
+      ...(input.worktreePath !== undefined ? { worktreePath: input.worktreePath } : {}),
+    }).pipe(Effect.provideService(Crypto.Crypto, crypto));
+    return yield* orchestration.dispatch(command);
+  });
+}

package/src/application/thread-wait.ts

@@ -4,7 +4,7 @@ import * as Stream from "effect/Stream";
 import type { OrchestrationMessage, OrchestrationThread } from "#t3tools/contracts";
 
 import { ThreadSessionError } from "../domain/error.ts";
-import type { Orchestration } from "../orchestration/service.ts";
+import { T3Orchestration } from "../orchestration/service.ts";
 import type { WaitEvent } from "./service.ts";
 import {
   applyThreadEvent,
@@ -15,60 +15,59 @@ import {
   threadStatus,
 } from "../domain/thread-lifecycle.ts";
 
-export function watchThread(input: {
-  readonly orchestration: Orchestration;
-  readonly threadId: string;
-}) {
+export function watchThread(input: { readonly threadId: string }) {
   let current: OrchestrationThread | undefined;
   let currentMessages: Map<string, OrchestrationMessage> | undefined;
-  return Stream.scoped(
-    input.orchestration.watchThreadItems(input.threadId).pipe(
-      Stream.flatMap((item) => {
-        if (item.kind === "snapshot") {
-          const messages = new Map<string, OrchestrationMessage>();
-          for (const message of item.snapshot.thread.messages) {
-            messages.set(messageKey(message), message);
-          }
-          current = item.snapshot.thread;
-          currentMessages = messages;
+  return Stream.unwrap(
+    Effect.gen(function* () {
+      const orchestration = yield* T3Orchestration;
+      return Stream.scoped(
+        orchestration.watchThreadItems(input.threadId).pipe(
+          Stream.flatMap((item) => {
+            if (item.kind === "snapshot") {
+              const messages = new Map<string, OrchestrationMessage>();
+              for (const message of item.snapshot.thread.messages) {
+                messages.set(messageKey(message), message);
+              }
+              current = item.snapshot.thread;
+              currentMessages = messages;
 
-          const events: Array<WaitEvent> = [
-            { type: "thread", thread: current },
-            { type: "status", status: threadStatus(current), threadId: current.id },
-          ];
-          if (!isThreadActive(current) && isThreadCompleteEnough(current)) {
-            events.push({ type: "done", thread: current });
-          }
-          return Stream.fromIterable(events);
-        }
+              const events: Array<WaitEvent> = [
+                { type: "thread", thread: current },
+                { type: "status", status: threadStatus(current), threadId: current.id },
+              ];
+              if (!isThreadActive(current) && isThreadCompleteEnough(current)) {
+                events.push({ type: "done", thread: current });
+              }
+              return Stream.fromIterable(events);
+            }
 
-        if (current === undefined || currentMessages === undefined) {
-          return Stream.fail(
-            new ThreadSessionError({
-              message: `thread stream event received before snapshot: ${input.threadId}`,
-              threadId: input.threadId,
-            }),
-          );
-        }
+            if (current === undefined || currentMessages === undefined) {
+              return Stream.fail(
+                new ThreadSessionError({
+                  message: `thread stream event received before snapshot: ${input.threadId}`,
+                  threadId: input.threadId,
+                }),
+              );
+            }
 
-        current = applyThreadEvent(current, item.event, currentMessages);
-        const message = messageFromEvent(item.event, currentMessages);
-        const events: Array<WaitEvent> = message !== null ? [{ type: "message", message }] : [];
-        events.push({ type: "status", status: threadStatus(current), threadId: current.id });
-        if (!isThreadActive(current) && isThreadCompleteEnough(current)) {
-          events.push({ type: "done", thread: current });
-        }
-        return Stream.fromIterable(events);
-      }),
-      Stream.takeUntil((event) => event.type === "done"),
-    ),
+            current = applyThreadEvent(current, item.event, currentMessages);
+            const message = messageFromEvent(item.event, currentMessages);
+            const events: Array<WaitEvent> = message !== null ? [{ type: "message", message }] : [];
+            events.push({ type: "status", status: threadStatus(current), threadId: current.id });
+            if (!isThreadActive(current) && isThreadCompleteEnough(current)) {
+              events.push({ type: "done", thread: current });
+            }
+            return Stream.fromIterable(events);
+          }),
+          Stream.takeUntil((event) => event.type === "done"),
+        ),
+      );
+    }),
   );
 }
 
-export function waitForThread(input: {
-  readonly orchestration: Orchestration;
-  readonly threadId: string;
-}) {
+export function waitForThread(input: { readonly threadId: string }) {
   return watchThread(input).pipe(
     Stream.runLast,
     Effect.flatMap((event) => {

package/src/application/threads.test.ts

@@ -0,0 +1,166 @@
+import "vite-plus/test/config";
+
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, describe, it } from "@effect/vitest";
+import { fromPartial } from "@total-typescript/shoehorn";
+import type {
+  ClientOrchestrationCommand,
+  OrchestrationShellSnapshot,
+  OrchestrationThread,
+  OrchestrationThreadShell,
+} from "#t3tools/contracts";
+
+import { NodeEnvironmentLive } from "../environment/layer.ts";
+import { T3Orchestration, type Orchestration } from "../orchestration/service.ts";
+import { makeThreadApplication } from "./threads.ts";
+
+function makeThread(
+  id: string,
+  projectId: string,
+  archivedAt: string | null,
+): OrchestrationThreadShell {
+  return fromPartial({
+    id,
+    projectId,
+    archivedAt,
+    title: `thread-${id}`,
+    updatedAt: "2026-01-01T00:00:00.000Z",
+  });
+}
+
+function makeSnapshot(threads: OrchestrationThreadShell[]): OrchestrationShellSnapshot {
+  return fromPartial({
+    projects: [{ id: "proj-1", workspaceRoot: "/workspace" }],
+    threads,
+  });
+}
+
+function makeOrchestrationLayer(input: {
+  readonly active?: OrchestrationShellSnapshot;
+  readonly archived?: OrchestrationShellSnapshot;
+  readonly threadSnapshot?: OrchestrationThread;
+  readonly onDispatch?: (command: ClientOrchestrationCommand) => void;
+}) {
+  return Layer.succeed(
+    T3Orchestration,
+    fromPartial<Orchestration>({
+      getShellSnapshot: () => Effect.succeed(input.active ?? makeSnapshot([])),
+      getArchivedShellSnapshot: () => Effect.succeed(input.archived ?? makeSnapshot([])),
+      getThreadSnapshot: () => Effect.succeed(input.threadSnapshot ?? fromPartial({})),
+      dispatch: (command: ClientOrchestrationCommand) => {
+        input.onDispatch?.(command);
+        return Effect.succeed({ sequence: 42 });
+      },
+    }),
+  );
+}
+
+const testLayer = (orchestration: Layer.Layer<T3Orchestration>) =>
+  Layer.mergeAll(orchestration, NodeServices.layer, NodeEnvironmentLive);
+
+describe("interruptThread", () => {
+  it.layer(NodeServices.layer)("interruptThread", (t) => {
+    t.effect("dispatches thread.turn.interrupt with activeTurnId from snapshot", () =>
+      Effect.gen(function* () {
+        let dispatched: ClientOrchestrationCommand | undefined;
+        const threadSnapshot = fromPartial<OrchestrationThread>({
+          id: "thread-1",
+          session: {
+            activeTurnId: "turn-1",
+          },
+        });
+        const app = yield* makeThreadApplication().pipe(
+          Effect.provide(
+            testLayer(
+              makeOrchestrationLayer({
+                threadSnapshot,
+                onDispatch: (command) => {
+                  dispatched = command;
+                },
+              }),
+            ),
+          ),
+        );
+
+        const dispatch = yield* app.interruptThread("thread-1");
+        assert.equal(dispatch.sequence, 42);
+        assert.equal(dispatched?.type, "thread.turn.interrupt");
+        if (dispatched?.type === "thread.turn.interrupt") {
+          assert.equal(dispatched.threadId, "thread-1");
+          assert.equal(dispatched.turnId, "turn-1");
+        }
+      }),
+    );
+  });
+});
+
+describe("listThreads", () => {
+  it.layer(NodeServices.layer)("listThreads", (t) => {
+    t.effect("returns active threads by default", () =>
+      Effect.gen(function* () {
+        const active = makeSnapshot([
+          makeThread("active-1", "proj-1", null),
+          makeThread("active-2", "proj-1", null),
+        ]);
+        const archived = makeSnapshot([
+          makeThread("archived-1", "proj-1", "2026-01-01T00:00:00.000Z"),
+        ]);
+        const app = yield* makeThreadApplication().pipe(
+          Effect.provide(testLayer(makeOrchestrationLayer({ active, archived }))),
+        );
+
+        const result = yield* app.listThreads("proj-1");
+        assert.deepEqual(
+          result.threads.map((thread) => thread.id),
+          ["active-1", "active-2"],
+        );
+      }),
+    );
+
+    t.effect("returns archived threads when include is archived", () =>
+      Effect.gen(function* () {
+        const active = makeSnapshot([makeThread("active-1", "proj-1", null)]);
+        const archived = makeSnapshot([
+          makeThread("archived-1", "proj-1", "2026-01-01T00:00:00.000Z"),
+          makeThread("archived-2", "proj-1", "2026-01-02T00:00:00.000Z"),
+        ]);
+        const app = yield* makeThreadApplication().pipe(
+          Effect.provide(testLayer(makeOrchestrationLayer({ active, archived }))),
+        );
+
+        const result = yield* app.listThreads("proj-1", { include: "archived" });
+        assert.deepEqual(
+          result.threads.map((thread) => thread.id),
+          ["archived-1", "archived-2"],
+        );
+        assert.isTrue(result.threads.every((thread) => thread.archivedAt !== null));
+      }),
+    );
+
+    t.effect("returns merged threads without duplicates when include is all", () =>
+      Effect.gen(function* () {
+        const active = makeSnapshot([
+          makeThread("active-1", "proj-1", null),
+          makeThread("shared", "proj-1", null),
+        ]);
+        const archived = makeSnapshot([
+          makeThread("archived-1", "proj-1", "2026-01-01T00:00:00.000Z"),
+          makeThread("shared", "proj-1", "2026-01-02T00:00:00.000Z"),
+        ]);
+        const app = yield* makeThreadApplication().pipe(
+          Effect.provide(testLayer(makeOrchestrationLayer({ active, archived }))),
+        );
+
+        const result = yield* app.listThreads("proj-1", { include: "all" });
+        assert.deepEqual(
+          result.threads.map((thread) => thread.id).toSorted(),
+          ["active-1", "archived-1", "shared"].toSorted(),
+        );
+        const shared = result.threads.find((thread) => thread.id === "shared");
+        assert.equal(shared?.archivedAt, "2026-01-02T00:00:00.000Z");
+      }),
+    );
+  });
+});

package/src/application/threads.ts

@@ -1,25 +1,36 @@
 import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
 import * as Path from "effect/Path";
-
+import * as Stream from "effect/Stream";
 import { Environment } from "../environment/service.ts";
 import { T3Orchestration } from "../orchestration/service.ts";
-import { ProjectLookupError, ThreadSessionError } from "../domain/error.ts";
+import { ProjectLookupError, ThreadLookupError, ThreadSessionError } from "../domain/error.ts";
 import { resolveProjectScope } from "../domain/helpers.ts";
-import { type StartThreadInput } from "./service.ts";
-import type { SendThreadInput, CallbackThreadInput } from "./service.ts";
+import { type ListThreadsInclude, type StartThreadInput } from "./service.ts";
+import type { CallbackThreadInput, SendThreadInput } from "./service.ts";
+import type { T3ThreadApplicationService } from "./service.ts";
+import type { OrchestrationThreadShell } from "#t3tools/contracts";
 import { mergeModelOptions } from "./model-selection.ts";
 import { derivePendingApprovals, derivePendingUserInputs } from "../domain/thread-activities.ts";
-import { threadStatus, type ThreadLifecycleStatus } from "../domain/thread-lifecycle.ts";
+import {
+  sessionNeedsStopBeforeDelete,
+  threadStatus,
+  type ThreadLifecycleStatus,
+} from "../domain/thread-lifecycle.ts";
 import type { OrchestrationThread } from "#t3tools/contracts";
 import type { ProviderApprovalDecision, ProviderUserInputAnswers } from "#t3tools/contracts";
 import {
   makeThreadApprovalRespondCommand,
   makeThreadArchiveCommand,
+  makeThreadDeleteCommand,
+  makeThreadInterruptCommand,
+  makeThreadSessionStopCommand,
   makeThreadStartCommands,
   makeThreadTurnContinueCommand,
+  makeThreadUnarchiveCommand,
   makeThreadUserInputRespondCommand,
 } from "./thread-commands.ts";
+import { makeUpdateThread } from "./thread-update.ts";
 import {
   waitForThread as waitForThreadUntilComplete,
   watchThread as watchThreadEvents,
@@ -31,8 +42,24 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
   const crypto = yield* Crypto.Crypto;
   const path = yield* Path.Path;
   const environment = yield* Environment;
-  const listThreads = Effect.fn("T3ApplicationLive.listThreads")(function* (projectRef: string) {
-    const snapshot = yield* orchestration.getShellSnapshot();
+  const awaitShellSequence = (sequence: number) =>
+    waitForShellSequence({ sequence }).pipe(Effect.provideService(T3Orchestration, orchestration));
+  const awaitThreadCompletion = (threadId: string) =>
+    waitForThreadUntilComplete({ threadId }).pipe(
+      Effect.provideService(T3Orchestration, orchestration),
+    );
+  const streamThreadEvents = (threadId: string) =>
+    watchThreadEvents({ threadId }).pipe(Stream.provideService(T3Orchestration, orchestration));
+  const listThreads = Effect.fn("T3ApplicationLive.listThreads")(function* (
+    projectRef: string,
+    options?: {
+      readonly include?: ListThreadsInclude;
+    },
+  ) {
+    const include = options?.include ?? "active";
+    const snapshot = yield* loadThreadsSnapshot(include).pipe(
+      Effect.provideService(T3Orchestration, orchestration),
+    );
     const scope = yield* resolveProjectScope(snapshot, {
       ref: projectRef,
     }).pipe(Effect.provideService(Path.Path, path));
@@ -61,6 +88,55 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
     );
     return yield* orchestration.dispatch(command);
   });
+  const unarchiveThread = Effect.fn("T3ApplicationLive.unarchiveThread")(function* (
+    threadId: string,
+  ) {
+    const command = yield* makeThreadUnarchiveCommand(threadId).pipe(
+      Effect.provideService(Crypto.Crypto, crypto),
+    );
+    return yield* orchestration.dispatch(command);
+  });
+  const interruptThread = Effect.fn("T3ApplicationLive.interruptThread")(function* (
+    threadId: string,
+  ) {
+    const snapshot = yield* orchestration.getThreadSnapshot(threadId);
+    const activeTurnId = snapshot.session?.activeTurnId ?? undefined;
+    const command = yield* makeThreadInterruptCommand({
+      threadId,
+      ...(activeTurnId !== undefined ? { turnId: activeTurnId } : {}),
+    }).pipe(Effect.provideService(Crypto.Crypto, crypto));
+    return yield* orchestration.dispatch(command);
+  });
+  const deleteThread = Effect.fn("T3ApplicationLive.deleteThread")(function* (threadId: string) {
+    const snapshot = yield* loadThreadsSnapshot("all").pipe(
+      Effect.provideService(T3Orchestration, orchestration),
+    );
+    const thread = snapshot.threads.find((item) => item.id === threadId);
+    if (thread === undefined) {
+      return yield* Effect.fail(
+        new ThreadLookupError({
+          message: `thread not found: ${threadId}`,
+          threadId,
+        }),
+      );
+    }
+    if (sessionNeedsStopBeforeDelete(thread.session)) {
+      const stopCommand = yield* makeThreadSessionStopCommand(threadId).pipe(
+        Effect.provideService(Crypto.Crypto, crypto),
+      );
+      yield* orchestration.dispatch(stopCommand);
+    }
+    const command = yield* makeThreadDeleteCommand(threadId).pipe(
+      Effect.provideService(Crypto.Crypto, crypto),
+    );
+    const dispatch = yield* orchestration.dispatch(command);
+    return { threadId, dispatch };
+  });
+  const updateThread: T3ThreadApplicationService["updateThread"] = (input) =>
+    makeUpdateThread()(input).pipe(
+      Effect.provideService(T3Orchestration, orchestration),
+      Effect.provideService(Crypto.Crypto, crypto),
+    );
   const startThread = Effect.fn("T3ApplicationLive.startThread")(function* (
     startInput: StartThreadInput,
     policy?: {
@@ -96,20 +172,14 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
       serverConfig,
     }).pipe(Effect.provideService(Crypto.Crypto, crypto));
     const createDispatch = yield* orchestration.dispatch(commands.createCommand);
-    yield* waitForShellSequence({
-      orchestration,
-      sequence: createDispatch.sequence,
-    });
+    yield* awaitShellSequence(createDispatch.sequence);
     const dispatch = yield* orchestration.dispatch(commands.turnCommand);
     const threadId = commands.threadId;
     const until = policy?.until ?? "dispatch";
     if (until === "dispatch") {
       return { dispatch, project: scope.project, threadId };
     }
-    yield* waitForShellSequence({
-      orchestration,
-      sequence: dispatch.sequence,
-    });
+    yield* awaitShellSequence(dispatch.sequence);
     if (until === "visible") {
       const thread = yield* Effect.scoped(
         Effect.gen(function* () {
@@ -119,10 +189,7 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
       );
       return { dispatch, project: scope.project, threadId, thread };
     }
-    const thread = yield* waitForThreadUntilComplete({
-      orchestration,
-      threadId,
-    });
+    const thread = yield* awaitThreadCompletion(threadId);
     yield* failIfThreadError(thread);
     return { dispatch, project: scope.project, threadId, thread };
   });
@@ -148,10 +215,7 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
     if (until === "dispatch") {
       return { dispatch, threadId: input.threadId };
     }
-    yield* waitForShellSequence({
-      orchestration,
-      sequence: dispatch.sequence,
-    });
+    yield* awaitShellSequence(dispatch.sequence);
     if (until === "visible") {
       const thread = yield* Effect.scoped(
         Effect.gen(function* () {
@@ -161,33 +225,20 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
       );
       return { dispatch, threadId: input.threadId, thread };
     }
-    const thread = yield* waitForThreadUntilComplete({
-      orchestration,
-      threadId: input.threadId,
-    });
+    const thread = yield* awaitThreadCompletion(input.threadId);
     yield* failIfThreadError(thread);
     return { dispatch, threadId: input.threadId, thread };
   });
-  const watchThread = (threadId: string) =>
-    watchThreadEvents({
-      orchestration,
-      threadId,
-    });
+  const watchThread = (threadId: string) => streamThreadEvents(threadId);
   const waitForThread = Effect.fn("T3ApplicationLive.waitForThread")(function* (threadId: string) {
-    const thread = yield* waitForThreadUntilComplete({
-      orchestration,
-      threadId,
-    });
+    const thread = yield* awaitThreadCompletion(threadId);
     yield* failIfThreadError(thread);
     return thread;
   });
   const callbackThread = Effect.fn("T3ApplicationLive.callbackThread")(function* (
     input: CallbackThreadInput,
   ) {
-    yield* waitForThreadUntilComplete({
-      orchestration,
-      threadId: input.fromThreadId,
-    });
+    yield* awaitThreadCompletion(input.fromThreadId);
     const result = yield* sendThread(
       { threadId: input.targetThreadId, message: input.prompt },
       { until: "dispatch" },
@@ -220,6 +271,10 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
   return {
     approveThread,
     archiveThread,
+    deleteThread,
+    interruptThread,
+    updateThread,
+    unarchiveThread,
     listThreads,
     getThreadMessages,
     respondToThread,
@@ -229,9 +284,37 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
     watchThread,
     waitForThread,
     callbackThread,
+  } satisfies T3ThreadApplicationService;
+});
+
+const loadThreadsSnapshot = Effect.fn("loadThreadsSnapshot")(function* (
+  include: ListThreadsInclude,
+) {
+  const orchestration = yield* T3Orchestration;
+  if (include === "active") {
+    return yield* orchestration.getShellSnapshot();
+  }
+  if (include === "archived") {
+    return yield* orchestration.getArchivedShellSnapshot();
+  }
+  const [activeSnapshot, archivedSnapshot] = yield* Effect.all([
+    orchestration.getShellSnapshot(),
+    orchestration.getArchivedShellSnapshot(),
+  ]);
+  return {
+    ...activeSnapshot,
+    threads: dedupeThreadsById([...activeSnapshot.threads, ...archivedSnapshot.threads]),
   };
 });
 
+function dedupeThreadsById(threads: ReadonlyArray<OrchestrationThreadShell>) {
+  const byId = new Map<string, OrchestrationThreadShell>();
+  for (const thread of threads) {
+    byId.set(thread.id, thread);
+  }
+  return [...byId.values()];
+}
+
 export type ThreadShow = {
   readonly id: string;
   readonly projectId: string;

package/src/bin.ts

@@ -9,6 +9,7 @@ import { createCliCommand } from "./cli/app.ts";
 import { NodeEnvironmentLive } from "./environment/layer.ts";
 import { T3InputLive } from "./cli/input/layer.ts";
 import { T3OutputLive } from "./cli/output/layer.ts";
+import { NodeTerminalIoLive } from "./cli/terminal/io-node-layer.ts";
 import { T3Output } from "./cli/output/service.ts";
 import { AppLayer } from "./runtime/layer.ts";
 import { T3VersionBundledLive, T3VersionPackageJsonLive } from "./version/layer.ts";
@@ -27,6 +28,7 @@ const CliLayer = Layer.mergeAll(
   NodeEnvironmentLive,
   T3InputLive.pipe(Layer.provide(NodeServices.layer)),
   T3OutputLive.pipe(Layer.provide(NodeServices.layer)),
+  NodeTerminalIoLive,
   VersionLive.pipe(Layer.provide(NodeServices.layer)),
 );
 

package/src/cli/app.ts

@@ -1,6 +1,7 @@
 import { Command } from "effect/unstable/cli";
 
 import { createAuthCommand } from "./auth.ts";
+import { createTerminalCommandGroup } from "./terminal.ts";
 import { createModelCommand } from "./model.ts";
 import { createProjectCommand } from "./project.ts";
 import { createThreadCommand } from "./thread.ts";
@@ -19,6 +20,7 @@ export function createCliCommand() {
       listThreadsCommand,
       createModelCommand(),
       createProjectCommand(),
+      createTerminalCommandGroup(),
       startThreadCommand,
       sendThreadCommand,
       showThreadCommand,

package/src/cli/confirm.ts

@@ -0,0 +1,31 @@
+import * as Effect from "effect/Effect";
+import * as Prompt from "effect/unstable/cli/Prompt";
+
+import { DestructiveConfirmationRequiredError } from "./error.ts";
+import { isInteractiveHumanTerminal } from "./output-format.ts";
+import type { EnvironmentShape } from "../environment/service.ts";
+
+export const requireDestructiveConfirmation = Effect.fn("requireDestructiveConfirmation")(
+  function* (input: {
+    readonly message: string;
+    readonly yes: boolean;
+    readonly environment: EnvironmentShape;
+  }) {
+    if (input.yes) {
+      return;
+    }
+    if (!isInteractiveHumanTerminal(input.environment)) {
+      yield* Effect.fail(
+        new DestructiveConfirmationRequiredError({
+          message: "destructive action requires --yes in non-interactive mode",
+        }),
+      );
+      return;
+    }
+    const confirmed = yield* Prompt.run(Prompt.confirm({ message: input.message, initial: false }));
+    if (confirmed) {
+      return;
+    }
+    yield* Effect.fail(new DestructiveConfirmationRequiredError({ message: "aborted" }));
+  },
+);