t3code-cli 0.10.0 → 0.11.0

package/src/application/service.ts

@@ -11,6 +11,10 @@ import type {
   OrchestrationThreadShell,
   ProviderUserInputAnswers,
   ServerProvider,
+  TerminalAttachStreamEvent,
+  TerminalMetadataStreamEvent,
+  TerminalSessionSnapshot,
+  TerminalSummary,
 } from "#t3tools/contracts";
 
 import type { ApplicationError } from "./error.ts";
@@ -26,6 +30,22 @@ export type StartThreadInput = {
   readonly worktreePath?: string;
 };
 
+export type CreateTerminalInput = {
+  readonly threadId: string;
+  readonly terminalId?: string;
+  readonly command?: string;
+};
+
+export type TerminalRef = {
+  readonly threadId: string;
+  readonly terminalId: string;
+};
+
+export type TerminalAttachTarget = TerminalRef & {
+  readonly cwd: string;
+  readonly worktreePath: string | null;
+};
+
 export type SendThreadInput = {
   readonly threadId: string;
   readonly message: string;
@@ -38,6 +58,18 @@ export type CallbackThreadInput = {
   readonly prompt: string;
 };
 
+export type ListThreadsInclude = "active" | "archived" | "all";
+
+export type UpdateThreadInput = {
+  readonly threadId: string;
+  readonly title?: string;
+  readonly provider?: string;
+  readonly model?: string;
+  readonly options?: NonNullable<ModelSelection["options"]>;
+  readonly branch?: string | null;
+  readonly worktreePath?: string | null;
+};
+
 export type StartThreadPolicy = {
   readonly until: "dispatch" | "visible" | "complete";
 };
@@ -48,82 +80,169 @@ export type WaitEvent =
   | { readonly type: "status"; readonly status: string; readonly threadId: string }
   | { readonly type: "done"; readonly thread: OrchestrationThread };
 
-export class T3Application extends Context.Service<
-  T3Application,
-  {
-    readonly loadShell: () => Effect.Effect<OrchestrationShellSnapshot, ApplicationError>;
-    readonly listModels: (input: {
-      readonly all?: boolean;
-      readonly provider?: string;
-    }) => Effect.Effect<ReadonlyArray<ServerProvider>, ApplicationError>;
-    readonly addProject: (input: {
-      readonly path: string;
-      readonly title?: string;
-    }) => Effect.Effect<
-      { readonly dispatch: DispatchResult; readonly project: OrchestrationProjectShell },
-      ApplicationError
-    >;
-    readonly listThreads: (projectRef: string) => Effect.Effect<
-      {
-        readonly project: OrchestrationProjectShell;
-        readonly threads: ReadonlyArray<OrchestrationThreadShell>;
-      },
-      ApplicationError
-    >;
-    readonly getThreadMessages: (
-      threadId: string,
-    ) => Effect.Effect<OrchestrationThread, ApplicationError>;
-    readonly showThread: (threadId: string) => Effect.Effect<ThreadShow, ApplicationError>;
-    readonly approveThread: (input: {
+export type T3ModelApplicationService = {
+  readonly listModels: (input: {
+    readonly all?: boolean;
+    readonly provider?: string;
+  }) => Effect.Effect<ReadonlyArray<ServerProvider>, ApplicationError>;
+};
+
+export class T3ModelApplication extends Context.Service<
+  T3ModelApplication,
+  T3ModelApplicationService
+>()("t3cli/T3ModelApplication") {}
+
+export type T3ProjectApplicationService = {
+  readonly loadShell: () => Effect.Effect<OrchestrationShellSnapshot, ApplicationError>;
+  readonly addProject: (input: {
+    readonly path: string;
+    readonly title?: string;
+  }) => Effect.Effect<
+    { readonly dispatch: DispatchResult; readonly project: OrchestrationProjectShell },
+    ApplicationError
+  >;
+  readonly resolveProject: (
+    projectRef: string,
+  ) => Effect.Effect<OrchestrationProjectShell, ApplicationError>;
+  readonly deleteProject: (input: {
+    readonly projectId: string;
+    readonly force?: boolean;
+  }) => Effect.Effect<
+    { readonly projectId: string; readonly dispatch: DispatchResult },
+    ApplicationError
+  >;
+};
+
+export class T3ProjectApplication extends Context.Service<
+  T3ProjectApplication,
+  T3ProjectApplicationService
+>()("t3cli/T3ProjectApplication") {}
+
+export type T3ThreadApplicationService = {
+  readonly listThreads: (
+    projectRef: string,
+    options?: {
+      readonly include?: ListThreadsInclude;
+    },
+  ) => Effect.Effect<
+    {
+      readonly project: OrchestrationProjectShell;
+      readonly threads: ReadonlyArray<OrchestrationThreadShell>;
+    },
+    ApplicationError
+  >;
+  readonly getThreadMessages: (
+    threadId: string,
+  ) => Effect.Effect<OrchestrationThread, ApplicationError>;
+  readonly showThread: (threadId: string) => Effect.Effect<ThreadShow, ApplicationError>;
+  readonly approveThread: (input: {
+    readonly threadId: string;
+    readonly requestId: string;
+    readonly decision: "accept" | "decline" | "cancel";
+  }) => Effect.Effect<
+    { readonly threadId: string; readonly requestId: string; readonly dispatch: DispatchResult },
+    ApplicationError
+  >;
+  readonly respondToThread: (input: {
+    readonly threadId: string;
+    readonly requestId: string;
+    readonly answers: ProviderUserInputAnswers;
+  }) => Effect.Effect<
+    { readonly threadId: string; readonly requestId: string; readonly dispatch: DispatchResult },
+    ApplicationError
+  >;
+  readonly archiveThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
+  readonly interruptThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
+  readonly unarchiveThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
+  readonly deleteThread: (
+    threadId: string,
+  ) => Effect.Effect<
+    { readonly threadId: string; readonly dispatch: DispatchResult },
+    ApplicationError
+  >;
+  readonly updateThread: (
+    input: UpdateThreadInput,
+  ) => Effect.Effect<DispatchResult, ApplicationError>;
+  readonly startThread: (
+    input: StartThreadInput,
+    policy?: StartThreadPolicy,
+  ) => Effect.Effect<
+    {
+      readonly dispatch: DispatchResult;
+      readonly project: OrchestrationProjectShell;
       readonly threadId: string;
-      readonly requestId: string;
-      readonly decision: "accept" | "decline" | "cancel";
-    }) => Effect.Effect<
-      { readonly threadId: string; readonly requestId: string; readonly dispatch: DispatchResult },
-      ApplicationError
-    >;
-    readonly respondToThread: (input: {
+      readonly thread?: OrchestrationThread;
+    },
+    ApplicationError
+  >;
+  readonly sendThread: (
+    input: SendThreadInput,
+    policy?: StartThreadPolicy,
+  ) => Effect.Effect<
+    {
+      readonly dispatch: DispatchResult;
       readonly threadId: string;
-      readonly requestId: string;
-      readonly answers: ProviderUserInputAnswers;
-    }) => Effect.Effect<
-      { readonly threadId: string; readonly requestId: string; readonly dispatch: DispatchResult },
-      ApplicationError
-    >;
-    readonly archiveThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
-    readonly startThread: (
-      input: StartThreadInput,
-      policy?: StartThreadPolicy,
-    ) => Effect.Effect<
-      {
-        readonly dispatch: DispatchResult;
-        readonly project: OrchestrationProjectShell;
-        readonly threadId: string;
-        readonly thread?: OrchestrationThread;
-      },
-      ApplicationError
-    >;
-    readonly sendThread: (
-      input: SendThreadInput,
-      policy?: StartThreadPolicy,
-    ) => Effect.Effect<
-      {
-        readonly dispatch: DispatchResult;
-        readonly threadId: string;
-        readonly thread?: OrchestrationThread;
-      },
-      ApplicationError
-    >;
-    readonly watchThread: (threadId: string) => Stream.Stream<WaitEvent, ApplicationError>;
-    readonly waitForThread: (
-      threadId: string,
-    ) => Effect.Effect<OrchestrationThread, ApplicationError>;
-    readonly callbackThread: (input: CallbackThreadInput) => Effect.Effect<
-      {
-        readonly dispatch: DispatchResult;
-        readonly targetThreadId: string;
-      },
-      ApplicationError
-    >;
-  }
->()("t3cli/T3Application") {}
+      readonly thread?: OrchestrationThread;
+    },
+    ApplicationError
+  >;
+  readonly watchThread: (threadId: string) => Stream.Stream<WaitEvent, ApplicationError>;
+  readonly waitForThread: (
+    threadId: string,
+  ) => Effect.Effect<OrchestrationThread, ApplicationError>;
+  readonly callbackThread: (input: CallbackThreadInput) => Effect.Effect<
+    {
+      readonly dispatch: DispatchResult;
+      readonly targetThreadId: string;
+    },
+    ApplicationError
+  >;
+};
+
+export class T3ThreadApplication extends Context.Service<
+  T3ThreadApplication,
+  T3ThreadApplicationService
+>()("t3cli/T3ThreadApplication") {}
+
+export type T3TerminalApplicationService = {
+  readonly listTerminals: (
+    threadId: string,
+  ) => Effect.Effect<ReadonlyArray<TerminalSummary>, ApplicationError>;
+  readonly getTerminal: (terminal: TerminalRef) => Effect.Effect<TerminalSummary, ApplicationError>;
+  readonly createTerminal: (
+    input: CreateTerminalInput,
+  ) => Effect.Effect<TerminalSessionSnapshot, ApplicationError>;
+  readonly attachTerminal: (input: {
+    readonly terminal: TerminalAttachTarget;
+    readonly cols?: number;
+    readonly rows?: number;
+  }) => Stream.Stream<TerminalAttachStreamEvent, ApplicationError>;
+  readonly watchTerminalMetadata: () => Stream.Stream<
+    TerminalMetadataStreamEvent,
+    ApplicationError
+  >;
+  readonly writeTerminal: (input: {
+    readonly terminal: TerminalRef;
+    readonly data: string;
+  }) => Effect.Effect<void, ApplicationError>;
+  readonly resizeTerminal: (input: {
+    readonly terminal: TerminalRef;
+    readonly cols: number;
+    readonly rows: number;
+  }) => Effect.Effect<void, ApplicationError>;
+  readonly destroyTerminal: (terminal: TerminalRef) => Effect.Effect<void, ApplicationError>;
+};
+
+export class T3TerminalApplication extends Context.Service<
+  T3TerminalApplication,
+  T3TerminalApplicationService
+>()("t3cli/T3TerminalApplication") {}
+
+export type T3ApplicationService = T3ModelApplicationService &
+  T3ProjectApplicationService &
+  T3ThreadApplicationService &
+  T3TerminalApplicationService;
+
+export class T3Application extends Context.Service<T3Application, T3ApplicationService>()(
+  "t3cli/T3Application",
+) {}

package/src/application/shell-sequence.ts

@@ -3,15 +3,13 @@ import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
 import { ORCHESTRATION_WS_METHODS } from "#t3tools/contracts";
 
-import type { Orchestration } from "../orchestration/service.ts";
+import { T3Orchestration } from "../orchestration/service.ts";
 import { RpcError } from "../rpc/error.ts";
 
-export function waitForShellSequence(input: {
-  readonly orchestration: Orchestration;
-  readonly sequence: number;
-}) {
+export function waitForShellSequence(input: { readonly sequence: number }) {
   return Effect.gen(function* () {
-    const sequence = yield* input.orchestration.watchShellSequence().pipe(
+    const orchestration = yield* T3Orchestration;
+    const sequence = yield* orchestration.watchShellSequence().pipe(
       Stream.filter((snapshotSequence) => snapshotSequence >= input.sequence),
       Stream.runHead,
       Effect.scoped,
@@ -24,6 +22,6 @@ export function waitForShellSequence(input: {
         }),
       );
     }
-    return yield* input.orchestration.getShellSnapshot();
+    return yield* orchestration.getShellSnapshot();
   });
 }

package/src/application/terminals.ts

@@ -0,0 +1,207 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import { WS_METHODS, type TerminalSummary } from "#t3tools/contracts";
+
+import { ProjectLookupError, TerminalLookupError, ThreadLookupError } from "../domain/error.ts";
+import { findProjectById } from "../domain/helpers.ts";
+import { T3Orchestration } from "../orchestration/service.ts";
+import { RpcError } from "../rpc/error.ts";
+import { T3RpcOperations } from "../rpc/operation.ts";
+import type { T3TerminalApplicationService, CreateTerminalInput, TerminalRef } from "./service.ts";
+
+export const makeTerminalApplication = Effect.fn("makeTerminalApplication")(function* () {
+  const crypto = yield* Crypto.Crypto;
+  const orchestration = yield* T3Orchestration;
+  const rpc = yield* T3RpcOperations;
+
+  const attachTerminal: T3TerminalApplicationService["attachTerminal"] = (input) =>
+    rpc.subscribe(WS_METHODS.terminalAttach, (client) =>
+      client[WS_METHODS.terminalAttach]({
+        threadId: input.terminal.threadId,
+        terminalId: input.terminal.terminalId,
+        cwd: input.terminal.cwd,
+        worktreePath: input.terminal.worktreePath,
+        ...(input.cols !== undefined ? { cols: input.cols } : {}),
+        ...(input.rows !== undefined ? { rows: input.rows } : {}),
+      }),
+    );
+
+  const watchTerminalMetadata: T3TerminalApplicationService["watchTerminalMetadata"] = () =>
+    rpc.subscribe(WS_METHODS.subscribeTerminalMetadata, (client) =>
+      client[WS_METHODS.subscribeTerminalMetadata]({}),
+    );
+
+  const getTerminalMetadataSnapshot = (): Effect.Effect<ReadonlyArray<TerminalSummary>, RpcError> =>
+    Effect.gen(function* () {
+      const item = yield* Stream.runHead(
+        rpc.subscribe(WS_METHODS.subscribeTerminalMetadata, (client) =>
+          client[WS_METHODS.subscribeTerminalMetadata]({}),
+        ),
+      );
+      const value = Option.getOrUndefined(item);
+      if (value === undefined || value.type !== "snapshot") {
+        return yield* Effect.fail(
+          new RpcError({
+            message: "server did not return terminal metadata snapshot",
+            method: WS_METHODS.subscribeTerminalMetadata,
+          }),
+        );
+      }
+      return value.terminals;
+    });
+
+  const listTerminals = Effect.fn("T3ApplicationLive.listTerminals")(function* (threadId: string) {
+    const snapshot = yield* orchestration.getShellSnapshot();
+    if (snapshot.threads.find((candidate) => candidate.id === threadId) === undefined) {
+      return yield* Effect.fail(
+        new ThreadLookupError({
+          message: `thread not found: ${threadId}`,
+          threadId,
+        }),
+      );
+    }
+    const terminals = yield* getTerminalMetadataSnapshot();
+    return terminals.filter((terminal) => terminal.threadId === threadId);
+  });
+
+  const getTerminal = Effect.fn("T3ApplicationLive.getTerminal")(function* (terminal: TerminalRef) {
+    const snapshot = yield* orchestration.getShellSnapshot();
+    if (snapshot.threads.find((candidate) => candidate.id === terminal.threadId) === undefined) {
+      return yield* Effect.fail(
+        new ThreadLookupError({
+          message: `thread not found: ${terminal.threadId}`,
+          threadId: terminal.threadId,
+        }),
+      );
+    }
+    const terminals = yield* getTerminalMetadataSnapshot();
+    const match = terminals.find(
+      (candidate) =>
+        candidate.threadId === terminal.threadId && candidate.terminalId === terminal.terminalId,
+    );
+    if (match !== undefined) {
+      return match;
+    }
+    return yield* Effect.fail(
+      new TerminalLookupError({
+        message: `terminal not found: ${terminal.terminalId} in thread ${terminal.threadId}`,
+        threadId: terminal.threadId,
+        terminalId: terminal.terminalId,
+      }),
+    );
+  });
+
+  const createTerminal = Effect.fn("T3ApplicationLive.createTerminal")(function* (
+    input: CreateTerminalInput,
+  ) {
+    const snapshot = yield* orchestration.getShellSnapshot();
+    const thread = snapshot.threads.find((candidate) => candidate.id === input.threadId);
+    if (thread === undefined) {
+      return yield* Effect.fail(
+        new ThreadLookupError({
+          message: `thread not found: ${input.threadId}`,
+          threadId: input.threadId,
+        }),
+      );
+    }
+    const project = findProjectById(snapshot, thread.projectId);
+    if (project === null) {
+      return yield* Effect.fail(
+        new ProjectLookupError({
+          message: `project not found for thread: ${input.threadId}`,
+          ref: thread.projectId,
+        }),
+      );
+    }
+
+    const terminalId = input.terminalId ?? `t3cli-${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`;
+    const cwd = thread.worktreePath ?? project.workspaceRoot;
+    const opened = yield* rpc.run(WS_METHODS.terminalOpen, (client) =>
+      client[WS_METHODS.terminalOpen]({
+        threadId: thread.id,
+        terminalId,
+        cwd,
+        worktreePath: thread.worktreePath ?? null,
+      }),
+    );
+
+    if (input.command !== undefined) {
+      yield* rpc.run(WS_METHODS.terminalWrite, (client) =>
+        client[WS_METHODS.terminalWrite]({
+          threadId: thread.id,
+          terminalId,
+          data: `${input.command}\r`,
+        }),
+      );
+      const refreshed = yield* Stream.runHead(
+        attachTerminal({
+          terminal: {
+            threadId: opened.threadId,
+            terminalId: opened.terminalId,
+            cwd: opened.cwd,
+            worktreePath: opened.worktreePath,
+          },
+        }),
+      );
+      const event = Option.getOrUndefined(refreshed);
+      if (event !== undefined && (event.type === "snapshot" || event.type === "restarted")) {
+        return event.snapshot;
+      }
+    }
+
+    return opened;
+  });
+
+  const writeTerminal = Effect.fn("T3ApplicationLive.writeTerminal")(function* (input: {
+    readonly terminal: TerminalRef;
+    readonly data: string;
+  }) {
+    yield* rpc.run(WS_METHODS.terminalWrite, (client) =>
+      client[WS_METHODS.terminalWrite]({
+        threadId: input.terminal.threadId,
+        terminalId: input.terminal.terminalId,
+        data: input.data,
+      }),
+    );
+  });
+
+  const resizeTerminal = Effect.fn("T3ApplicationLive.resizeTerminal")(function* (input: {
+    readonly terminal: TerminalRef;
+    readonly cols: number;
+    readonly rows: number;
+  }) {
+    yield* rpc.run(WS_METHODS.terminalResize, (client) =>
+      client[WS_METHODS.terminalResize]({
+        threadId: input.terminal.threadId,
+        terminalId: input.terminal.terminalId,
+        cols: input.cols,
+        rows: input.rows,
+      }),
+    );
+  });
+
+  const destroyTerminal = Effect.fn("T3ApplicationLive.destroyTerminal")(function* (
+    terminal: TerminalRef,
+  ) {
+    yield* rpc.run(WS_METHODS.terminalClose, (client) =>
+      client[WS_METHODS.terminalClose]({
+        threadId: terminal.threadId,
+        terminalId: terminal.terminalId,
+        deleteHistory: true,
+      }),
+    );
+  });
+
+  return {
+    attachTerminal,
+    createTerminal,
+    destroyTerminal,
+    getTerminal,
+    listTerminals,
+    resizeTerminal,
+    watchTerminalMetadata,
+    writeTerminal,
+  } satisfies T3TerminalApplicationService;
+});

package/src/application/thread-commands.test.ts

@@ -0,0 +1,43 @@
+import "vite-plus/test/config";
+
+import * as Effect from "effect/Effect";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, describe, it } from "@effect/vitest";
+
+import { makeThreadInterruptCommand, makeThreadUnarchiveCommand } from "./thread-commands.ts";
+
+describe("thread command builders", () => {
+  it.layer(NodeServices.layer)("thread command builders", (t) => {
+    t.effect("makeThreadInterruptCommand includes turnId when provided", () =>
+      Effect.gen(function* () {
+        const command = yield* makeThreadInterruptCommand({
+          threadId: "thread-1",
+          turnId: "turn-1",
+        });
+        assert.equal(command.type, "thread.turn.interrupt");
+        assert.equal(command.threadId, "thread-1");
+        assert.equal(command.turnId, "turn-1");
+        assert.equal(typeof command.createdAt, "string");
+      }),
+    );
+
+    t.effect("makeThreadInterruptCommand omits turnId when not provided", () =>
+      Effect.gen(function* () {
+        const command = yield* makeThreadInterruptCommand({
+          threadId: "thread-1",
+        });
+        assert.equal(command.type, "thread.turn.interrupt");
+        assert.equal(command.threadId, "thread-1");
+        assert.equal("turnId" in command, false);
+      }),
+    );
+
+    t.effect("makeThreadUnarchiveCommand builds thread.unarchive command", () =>
+      Effect.gen(function* () {
+        const command = yield* makeThreadUnarchiveCommand("thread-1");
+        assert.equal(command.type, "thread.unarchive");
+        assert.equal(command.threadId, "thread-1");
+      }),
+    );
+  });
+});

package/src/application/thread-commands.ts

@@ -6,6 +6,7 @@ import {
   CommandId,
   MessageId,
   ThreadId,
+  TurnId,
   type ClientOrchestrationCommand,
   type ModelSelection,
   type OrchestrationProjectShell,
@@ -101,6 +102,63 @@ export const makeThreadArchiveCommand = Effect.fn("makeThreadArchiveCommand")(fu
   } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.archive" }>;
 });
 
+export const makeThreadUnarchiveCommand = Effect.fn("makeThreadUnarchiveCommand")(function* (
+  threadId: string,
+) {
+  const crypto = yield* Crypto.Crypto;
+  return {
+    type: "thread.unarchive",
+    commandId: CommandId.make(
+      `t3cli:thread-unarchive:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+    ),
+    threadId: ThreadId.make(threadId),
+  } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.unarchive" }>;
+});
+
+export const makeThreadSessionStopCommand = Effect.fn("makeThreadSessionStopCommand")(function* (
+  threadId: string,
+) {
+  const crypto = yield* Crypto.Crypto;
+  const createdAt = DateTime.formatIso(yield* DateTime.now);
+  return {
+    type: "thread.session.stop",
+    commandId: CommandId.make(
+      `t3cli:thread-session-stop:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+    ),
+    threadId: ThreadId.make(threadId),
+    createdAt,
+  } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.session.stop" }>;
+});
+
+export const makeThreadDeleteCommand = Effect.fn("makeThreadDeleteCommand")(function* (
+  threadId: string,
+) {
+  const crypto = yield* Crypto.Crypto;
+  return {
+    type: "thread.delete",
+    commandId: CommandId.make(
+      `t3cli:thread-delete:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+    ),
+    threadId: ThreadId.make(threadId),
+  } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.delete" }>;
+});
+
+export const makeThreadInterruptCommand = Effect.fn("makeThreadInterruptCommand")(
+  function* (input: { readonly threadId: string; readonly turnId?: string }) {
+    const crypto = yield* Crypto.Crypto;
+    const createdAt = DateTime.formatIso(yield* DateTime.now);
+    return {
+      type: "thread.turn.interrupt",
+      commandId: CommandId.make(
+        `t3cli:thread-interrupt:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+      ),
+      threadId: ThreadId.make(input.threadId),
+      ...(input.turnId !== undefined ? { turnId: TurnId.make(input.turnId) } : {}),
+      createdAt,
+    } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.turn.interrupt" }>;
+  },
+);
+
 export const makeThreadApprovalRespondCommand = Effect.fn("makeThreadApprovalRespondCommand")(
   function* (input: {
     readonly threadId: string;
@@ -142,3 +200,26 @@ export const makeThreadUserInputRespondCommand = Effect.fn("makeThreadUserInputR
     } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.user-input.respond" }>;
   },
 );
+
+export const makeThreadMetaUpdateCommand = Effect.fn("makeThreadMetaUpdateCommand")(function* (
+  threadId: string,
+  input: {
+    readonly title?: string;
+    readonly modelSelection?: ModelSelection;
+    readonly branch?: string | null;
+    readonly worktreePath?: string | null;
+  },
+) {
+  const crypto = yield* Crypto.Crypto;
+  return {
+    type: "thread.meta.update",
+    commandId: CommandId.make(
+      `t3cli:thread-meta-update:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+    ),
+    threadId: ThreadId.make(threadId),
+    ...(input.title !== undefined ? { title: input.title } : {}),
+    ...(input.modelSelection !== undefined ? { modelSelection: input.modelSelection } : {}),
+    ...(input.branch !== undefined ? { branch: input.branch } : {}),
+    ...(input.worktreePath !== undefined ? { worktreePath: input.worktreePath } : {}),
+  } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.meta.update" }>;
+});