t3code-cli 0.10.0 → 0.11.0

package/dist/src/application/model-selection.d.ts

@@ -17,3 +17,18 @@ export declare function resolveModelSelection(input: {
     }[];
 }, ModelSelectionError, never>;
 export declare function mergeModelOptions(selection: ModelSelection, options: NonNullable<ModelSelection["options"]>): ModelSelection;
+export declare function resolveUpdateModelSelection(input: {
+    readonly current: ModelSelection;
+    readonly provider?: string;
+    readonly model?: string;
+    readonly options?: NonNullable<ModelSelection["options"]>;
+    readonly project: OrchestrationProjectShell;
+    readonly serverConfig: ServerConfigForCli;
+}): Effect.Effect<{
+    readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+    readonly model: string;
+    readonly options?: readonly {
+        readonly id: string;
+        readonly value: string | boolean;
+    }[];
+}, ModelSelectionError, never>;

package/dist/src/application/models.d.ts

@@ -4,91 +4,5 @@ export declare const makeModelsApplication: () => Effect.Effect<{
     listModels: (input: {
         readonly all?: boolean;
         readonly provider?: string;
-    }) => Effect.Effect<{
-        readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
-        readonly driver: string & import("effect/Brand").Brand<"ProviderDriverKind">;
-        readonly enabled: boolean;
-        readonly installed: boolean;
-        readonly version: string | null;
-        readonly status: "error" | "ready" | "warning" | "disabled";
-        readonly auth: {
-            readonly status: "authenticated" | "unknown" | "unauthenticated";
-            readonly type?: string | undefined;
-            readonly label?: string | undefined;
-            readonly email?: string | undefined;
-        };
-        readonly checkedAt: string;
-        readonly models: readonly {
-            readonly slug: string;
-            readonly name: string;
-            readonly isCustom: boolean;
-            readonly capabilities: {
-                readonly optionDescriptors?: readonly ({
-                    readonly type: "select";
-                    readonly options: readonly {
-                        readonly id: string;
-                        readonly label: string;
-                        readonly description?: string | undefined;
-                        readonly isDefault?: boolean | undefined;
-                    }[];
-                    readonly id: string;
-                    readonly label: string;
-                    readonly currentValue?: string | undefined;
-                    readonly promptInjectedValues?: readonly string[] | undefined;
-                    readonly description?: string | undefined;
-                } | {
-                    readonly type: "boolean";
-                    readonly id: string;
-                    readonly label: string;
-                    readonly currentValue?: boolean | undefined;
-                    readonly description?: string | undefined;
-                })[] | undefined;
-            } | null;
-            readonly shortName?: string | undefined;
-            readonly subProvider?: string | undefined;
-        }[];
-        readonly slashCommands: readonly {
-            readonly name: string;
-            readonly description?: string | undefined;
-            readonly input?: {
-                readonly hint: string;
-            } | undefined;
-        }[];
-        readonly skills: readonly {
-            readonly name: string;
-            readonly path: string;
-            readonly enabled: boolean;
-            readonly description?: string | undefined;
-            readonly scope?: string | undefined;
-            readonly displayName?: string | undefined;
-            readonly shortDescription?: string | undefined;
-        }[];
-        readonly displayName?: string | undefined;
-        readonly accentColor?: string | undefined;
-        readonly badgeLabel?: string | undefined;
-        readonly continuation?: {
-            readonly groupKey: string;
-        } | undefined;
-        readonly showInteractionModeToggle?: boolean | undefined;
-        readonly requiresNewThreadForModelChange?: boolean | undefined;
-        readonly message?: string | undefined;
-        readonly availability?: "available" | "unavailable" | undefined;
-        readonly unavailableReason?: string | undefined;
-        readonly versionAdvisory?: {
-            readonly status: "unknown" | "current" | "behind_latest";
-            readonly currentVersion: string | null;
-            readonly latestVersion: string | null;
-            readonly updateCommand: string | null;
-            readonly canUpdate: boolean;
-            readonly checkedAt: string | null;
-            readonly message: string | null;
-        };
-        readonly updateState?: {
-            readonly status: "idle" | "running" | "failed" | "queued" | "succeeded" | "unchanged";
-            readonly startedAt: string | null;
-            readonly finishedAt: string | null;
-            readonly message: string | null;
-            readonly output: string | null;
-        };
-    }[], import("../rpc/error.ts").RpcError, never>;
+    }) => Effect.Effect<ReadonlyArray<import("#t3tools/contracts").ServerProvider>, import("./error.ts").ApplicationError>;
 }, never, T3Orchestration>;

package/dist/src/application/project-commands.d.ts

@@ -13,3 +13,12 @@ export declare const makeProjectCreateCommand: (input: {
     workspaceRoot: string;
     createdAt: string;
 }, never, Environment | Path.Path | Crypto.Crypto>;
+export declare const makeProjectDeleteCommand: (input: {
+    readonly projectId: string;
+    readonly force?: boolean;
+}) => Effect.Effect<{
+    force?: true;
+    type: "project.delete";
+    commandId: string & import("effect/Brand").Brand<"CommandId">;
+    projectId: string & import("effect/Brand").Brand<"ProjectId">;
+}, never, Crypto.Crypto>;

package/dist/src/application/projects.d.ts

@@ -3,143 +3,21 @@ import * as Effect from "effect/Effect";
 import * as Path from "effect/Path";
 import { Environment } from "../environment/service.ts";
 import { T3Orchestration } from "../orchestration/service.ts";
-import { ProjectCreateVisibilityError } from "../domain/error.ts";
 export declare const makeProjectApplication: () => Effect.Effect<{
-    loadShell: () => Effect.Effect<{
-        readonly snapshotSequence: number;
-        readonly projects: readonly {
-            readonly id: string & import("effect/Brand").Brand<"ProjectId">;
-            readonly title: string;
-            readonly workspaceRoot: string;
-            readonly defaultModelSelection: {
-                readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
-                readonly model: string;
-                readonly options?: readonly {
-                    readonly id: string;
-                    readonly value: string | boolean;
-                }[];
-            } | null;
-            readonly scripts: readonly {
-                readonly id: string;
-                readonly name: string;
-                readonly command: string;
-                readonly icon: "play" | "test" | "lint" | "configure" | "build" | "debug";
-                readonly runOnWorktreeCreate: boolean;
-            }[];
-            readonly createdAt: string;
-            readonly updatedAt: string;
-            readonly repositoryIdentity?: {
-                readonly canonicalKey: string;
-                readonly locator: {
-                    readonly source: "git-remote";
-                    readonly remoteName: string;
-                    readonly remoteUrl: string;
-                };
-                readonly rootPath?: string;
-                readonly displayName?: string;
-                readonly provider?: string;
-                readonly owner?: string;
-                readonly name?: string;
-            } | null | undefined;
-        }[];
-        readonly threads: readonly {
-            readonly id: string & import("effect/Brand").Brand<"ThreadId">;
-            readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
-            readonly title: string;
-            readonly modelSelection: {
-                readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
-                readonly model: string;
-                readonly options?: readonly {
-                    readonly id: string;
-                    readonly value: string | boolean;
-                }[];
-            };
-            readonly runtimeMode: "approval-required" | "auto-accept-edits" | "full-access";
-            readonly interactionMode: "default" | "plan";
-            readonly branch: string | null;
-            readonly worktreePath: string | null;
-            readonly latestTurn: {
-                readonly turnId: string & import("effect/Brand").Brand<"TurnId">;
-                readonly state: "error" | "running" | "interrupted" | "completed";
-                readonly requestedAt: string;
-                readonly startedAt: string | null;
-                readonly completedAt: string | null;
-                readonly assistantMessageId: (string & import("effect/Brand").Brand<"MessageId">) | null;
-                readonly sourceProposedPlan?: {
-                    readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
-                    readonly planId: string;
-                } | undefined;
-            } | null;
-            readonly createdAt: string;
-            readonly updatedAt: string;
-            readonly archivedAt: string | null;
-            readonly session: {
-                readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
-                readonly status: "error" | "idle" | "starting" | "running" | "ready" | "interrupted" | "stopped";
-                readonly providerName: string | null;
-                readonly runtimeMode: "approval-required" | "auto-accept-edits" | "full-access";
-                readonly activeTurnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
-                readonly lastError: string | null;
-                readonly updatedAt: string;
-                readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
-            } | null;
-            readonly goal: {
-                readonly objective: string;
-                readonly status: "active" | "paused" | "budgetLimited" | "complete";
-                readonly tokensUsed: number;
-                readonly tokenBudget: number | null;
-                readonly timeUsedSeconds: number;
-                readonly createdAt: string;
-                readonly updatedAt: string;
-            } | null;
-            readonly latestUserMessageAt: string | null;
-            readonly hasPendingApprovals: boolean;
-            readonly hasPendingUserInput: boolean;
-            readonly hasActionableProposedPlan: boolean;
-        }[];
-        readonly updatedAt: string;
-    }, import("../rpc/error.ts").RpcError, never>;
-    addProject: (projectInput: {
+    loadShell: () => Effect.Effect<import("#t3tools/contracts").OrchestrationShellSnapshot, import("./error.ts").ApplicationError>;
+    addProject: (input: {
         readonly path: string;
         readonly title?: string;
     }) => Effect.Effect<{
-        dispatch: {
-            readonly sequence: number;
-        };
-        project: {
-            readonly id: string & import("effect/Brand").Brand<"ProjectId">;
-            readonly title: string;
-            readonly workspaceRoot: string;
-            readonly defaultModelSelection: {
-                readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
-                readonly model: string;
-                readonly options?: readonly {
-                    readonly id: string;
-                    readonly value: string | boolean;
-                }[];
-            } | null;
-            readonly scripts: readonly {
-                readonly id: string;
-                readonly name: string;
-                readonly command: string;
-                readonly icon: "play" | "test" | "lint" | "configure" | "build" | "debug";
-                readonly runOnWorktreeCreate: boolean;
-            }[];
-            readonly createdAt: string;
-            readonly updatedAt: string;
-            readonly repositoryIdentity?: {
-                readonly canonicalKey: string;
-                readonly locator: {
-                    readonly source: "git-remote";
-                    readonly remoteName: string;
-                    readonly remoteUrl: string;
-                };
-                readonly rootPath?: string;
-                readonly displayName?: string;
-                readonly provider?: string;
-                readonly owner?: string;
-                readonly name?: string;
-            } | null | undefined;
-        };
-    }, ProjectCreateVisibilityError | import("../rpc/error.ts").RpcError, never>;
+        readonly dispatch: import("#t3tools/contracts").DispatchResult;
+        readonly project: import("#t3tools/contracts").OrchestrationProjectShell;
+    }, import("./error.ts").ApplicationError>;
+    resolveProject: (projectRef: string) => Effect.Effect<import("#t3tools/contracts").OrchestrationProjectShell, import("./error.ts").ApplicationError>;
+    deleteProject: (input: {
+        readonly projectId: string;
+        readonly force?: boolean;
+    }) => Effect.Effect<{
+        readonly projectId: string;
+        readonly dispatch: import("#t3tools/contracts").DispatchResult;
+    }, import("./error.ts").ApplicationError>;
 }, never, Environment | T3Orchestration | Path.Path | Crypto.Crypto>;

package/dist/src/application/service.d.ts

@@ -1,7 +1,7 @@
 import * as Context from "effect/Context";
 import type * as Effect from "effect/Effect";
 import type * as Stream from "effect/Stream";
-import type { DispatchResult, ModelSelection, OrchestrationMessage, OrchestrationProjectShell, OrchestrationShellSnapshot, OrchestrationThread, OrchestrationThreadShell, ProviderUserInputAnswers, ServerProvider } from "#t3tools/contracts";
+import type { DispatchResult, ModelSelection, OrchestrationMessage, OrchestrationProjectShell, OrchestrationShellSnapshot, OrchestrationThread, OrchestrationThreadShell, ProviderUserInputAnswers, ServerProvider, TerminalAttachStreamEvent, TerminalMetadataStreamEvent, TerminalSessionSnapshot, TerminalSummary } from "#t3tools/contracts";
 import type { ApplicationError } from "./error.ts";
 import type { ThreadShow } from "./threads.ts";
 export type StartThreadInput = {
@@ -13,6 +13,19 @@ export type StartThreadInput = {
     readonly options?: NonNullable<ModelSelection["options"]>;
     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;
@@ -23,6 +36,16 @@ export type CallbackThreadInput = {
     readonly targetThreadId: string;
     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";
 };
@@ -40,12 +63,17 @@ export type WaitEvent = {
     readonly type: "done";
     readonly thread: OrchestrationThread;
 };
-declare const T3Application_base: Context.ServiceClass<T3Application, "t3cli/T3Application", {
-    readonly loadShell: () => Effect.Effect<OrchestrationShellSnapshot, ApplicationError>;
+export type T3ModelApplicationService = {
     readonly listModels: (input: {
         readonly all?: boolean;
         readonly provider?: string;
     }) => Effect.Effect<ReadonlyArray<ServerProvider>, ApplicationError>;
+};
+declare const T3ModelApplication_base: Context.ServiceClass<T3ModelApplication, "t3cli/T3ModelApplication", T3ModelApplicationService>;
+export declare class T3ModelApplication extends T3ModelApplication_base {
+}
+export type T3ProjectApplicationService = {
+    readonly loadShell: () => Effect.Effect<OrchestrationShellSnapshot, ApplicationError>;
     readonly addProject: (input: {
         readonly path: string;
         readonly title?: string;
@@ -53,7 +81,22 @@ declare const T3Application_base: Context.ServiceClass<T3Application, "t3cli/T3A
         readonly dispatch: DispatchResult;
         readonly project: OrchestrationProjectShell;
     }, ApplicationError>;
-    readonly listThreads: (projectRef: string) => Effect.Effect<{
+    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>;
+};
+declare const T3ProjectApplication_base: Context.ServiceClass<T3ProjectApplication, "t3cli/T3ProjectApplication", T3ProjectApplicationService>;
+export declare class T3ProjectApplication extends T3ProjectApplication_base {
+}
+export type T3ThreadApplicationService = {
+    readonly listThreads: (projectRef: string, options?: {
+        readonly include?: ListThreadsInclude;
+    }) => Effect.Effect<{
         readonly project: OrchestrationProjectShell;
         readonly threads: ReadonlyArray<OrchestrationThreadShell>;
     }, ApplicationError>;
@@ -78,6 +121,13 @@ declare const T3Application_base: Context.ServiceClass<T3Application, "t3cli/T3A
         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;
@@ -95,7 +145,36 @@ declare const T3Application_base: Context.ServiceClass<T3Application, "t3cli/T3A
         readonly dispatch: DispatchResult;
         readonly targetThreadId: string;
     }, ApplicationError>;
-}>;
+};
+declare const T3ThreadApplication_base: Context.ServiceClass<T3ThreadApplication, "t3cli/T3ThreadApplication", T3ThreadApplicationService>;
+export declare class T3ThreadApplication extends T3ThreadApplication_base {
+}
+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>;
+};
+declare const T3TerminalApplication_base: Context.ServiceClass<T3TerminalApplication, "t3cli/T3TerminalApplication", T3TerminalApplicationService>;
+export declare class T3TerminalApplication extends T3TerminalApplication_base {
+}
+export type T3ApplicationService = T3ModelApplicationService & T3ProjectApplicationService & T3ThreadApplicationService & T3TerminalApplicationService;
+declare const T3Application_base: Context.ServiceClass<T3Application, "t3cli/T3Application", T3ApplicationService>;
 export declare class T3Application extends T3Application_base {
 }
 export {};

package/dist/src/application/shell-sequence.d.ts

@@ -1,8 +1,7 @@
 import * as Effect from "effect/Effect";
-import type { Orchestration } from "../orchestration/service.ts";
+import { T3Orchestration } from "../orchestration/service.ts";
 import { RpcError } from "../rpc/error.ts";
 export declare function waitForShellSequence(input: {
-    readonly orchestration: Orchestration;
     readonly sequence: number;
 }): Effect.Effect<{
     readonly snapshotSequence: number;
@@ -82,19 +81,10 @@ export declare function waitForShellSequence(input: {
             readonly updatedAt: string;
             readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
         } | null;
-        readonly goal: {
-            readonly objective: string;
-            readonly status: "active" | "paused" | "budgetLimited" | "complete";
-            readonly tokensUsed: number;
-            readonly tokenBudget: number | null;
-            readonly timeUsedSeconds: number;
-            readonly createdAt: string;
-            readonly updatedAt: string;
-        } | null;
         readonly latestUserMessageAt: string | null;
         readonly hasPendingApprovals: boolean;
         readonly hasPendingUserInput: boolean;
         readonly hasActionableProposedPlan: boolean;
     }[];
     readonly updatedAt: string;
-}, RpcError, never>;
+}, RpcError, T3Orchestration>;

package/dist/src/application/terminals.d.ts

@@ -0,0 +1,66 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import { TerminalLookupError, ThreadLookupError } from "../domain/error.ts";
+import { T3Orchestration } from "../orchestration/service.ts";
+import { RpcError } from "../rpc/error.ts";
+import { T3RpcOperations } from "../rpc/operation.ts";
+import type { CreateTerminalInput, TerminalRef } from "./service.ts";
+export declare const makeTerminalApplication: () => Effect.Effect<{
+    attachTerminal: (input: {
+        readonly terminal: import("./service.ts").TerminalAttachTarget;
+        readonly cols?: number;
+        readonly rows?: number;
+    }) => Stream.Stream<import("#t3tools/contracts").TerminalAttachStreamEvent, import("./error.ts").ApplicationError>;
+    createTerminal: (input: CreateTerminalInput) => Effect.Effect<{
+        readonly threadId: string;
+        readonly terminalId: string;
+        readonly cwd: string;
+        readonly worktreePath: string | null;
+        readonly status: "error" | "starting" | "running" | "exited";
+        readonly pid: number | null;
+        readonly history: string;
+        readonly exitCode: number | null;
+        readonly exitSignal: number | null;
+        readonly label: string;
+        readonly updatedAt: string;
+        readonly sequence?: number | undefined;
+    }, import("./error.ts").ApplicationError, never>;
+    destroyTerminal: (terminal: TerminalRef) => Effect.Effect<void, RpcError, never>;
+    getTerminal: (terminal: TerminalRef) => Effect.Effect<{
+        readonly threadId: string;
+        readonly terminalId: string;
+        readonly cwd: string;
+        readonly worktreePath: string | null;
+        readonly status: "error" | "starting" | "running" | "exited";
+        readonly pid: number | null;
+        readonly exitCode: number | null;
+        readonly exitSignal: number | null;
+        readonly hasRunningSubprocess: boolean;
+        readonly label: string;
+        readonly updatedAt: string;
+    }, ThreadLookupError | TerminalLookupError | RpcError, never>;
+    listTerminals: (threadId: string) => Effect.Effect<{
+        readonly threadId: string;
+        readonly terminalId: string;
+        readonly cwd: string;
+        readonly worktreePath: string | null;
+        readonly status: "error" | "starting" | "running" | "exited";
+        readonly pid: number | null;
+        readonly exitCode: number | null;
+        readonly exitSignal: number | null;
+        readonly hasRunningSubprocess: boolean;
+        readonly label: string;
+        readonly updatedAt: string;
+    }[], ThreadLookupError | RpcError, never>;
+    resizeTerminal: (input: {
+        readonly terminal: TerminalRef;
+        readonly cols: number;
+        readonly rows: number;
+    }) => Effect.Effect<void, RpcError, never>;
+    watchTerminalMetadata: () => Stream.Stream<import("#t3tools/contracts").TerminalMetadataStreamEvent, import("./error.ts").ApplicationError>;
+    writeTerminal: (input: {
+        readonly terminal: TerminalRef;
+        readonly data: string;
+    }) => Effect.Effect<void, RpcError, never>;
+}, never, T3Orchestration | Crypto.Crypto | T3RpcOperations>;

package/dist/src/application/thread-commands.d.ts

@@ -82,6 +82,32 @@ export declare const makeThreadArchiveCommand: (threadId: string) => Effect.Effe
     commandId: string & import("effect/Brand").Brand<"CommandId">;
     threadId: string & import("effect/Brand").Brand<"ThreadId">;
 }, never, Crypto.Crypto>;
+export declare const makeThreadUnarchiveCommand: (threadId: string) => Effect.Effect<{
+    type: "thread.unarchive";
+    commandId: string & import("effect/Brand").Brand<"CommandId">;
+    threadId: string & import("effect/Brand").Brand<"ThreadId">;
+}, never, Crypto.Crypto>;
+export declare const makeThreadSessionStopCommand: (threadId: string) => Effect.Effect<{
+    type: "thread.session.stop";
+    commandId: string & import("effect/Brand").Brand<"CommandId">;
+    threadId: string & import("effect/Brand").Brand<"ThreadId">;
+    createdAt: string;
+}, never, Crypto.Crypto>;
+export declare const makeThreadDeleteCommand: (threadId: string) => Effect.Effect<{
+    type: "thread.delete";
+    commandId: string & import("effect/Brand").Brand<"CommandId">;
+    threadId: string & import("effect/Brand").Brand<"ThreadId">;
+}, never, Crypto.Crypto>;
+export declare const makeThreadInterruptCommand: (input: {
+    readonly threadId: string;
+    readonly turnId?: string;
+}) => Effect.Effect<{
+    createdAt: string;
+    turnId?: string & import("effect/Brand").Brand<"TurnId">;
+    type: "thread.turn.interrupt";
+    commandId: string & import("effect/Brand").Brand<"CommandId">;
+    threadId: string & import("effect/Brand").Brand<"ThreadId">;
+}, never, Crypto.Crypto>;
 export declare const makeThreadApprovalRespondCommand: (input: {
     readonly threadId: string;
     readonly requestId: string;
@@ -108,3 +134,24 @@ export declare const makeThreadUserInputRespondCommand: (input: {
     };
     createdAt: string;
 }, never, Crypto.Crypto>;
+export declare const makeThreadMetaUpdateCommand: (threadId: string, input: {
+    readonly title?: string;
+    readonly modelSelection?: ModelSelection;
+    readonly branch?: string | null;
+    readonly worktreePath?: string | null;
+}) => Effect.Effect<{
+    worktreePath?: string | null;
+    branch?: string | null;
+    modelSelection?: {
+        readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+        readonly model: string;
+        readonly options?: readonly {
+            readonly id: string;
+            readonly value: string | boolean;
+        }[];
+    };
+    title?: string;
+    type: "thread.meta.update";
+    commandId: string & import("effect/Brand").Brand<"CommandId">;
+    threadId: string & import("effect/Brand").Brand<"ThreadId">;
+}, never, Crypto.Crypto>;

package/dist/src/application/thread-update.d.ts

@@ -0,0 +1,8 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import { ModelSelectionError, ThreadEventError } from "../domain/error.ts";
+import { T3Orchestration } from "../orchestration/service.ts";
+import type { UpdateThreadInput } from "./service.ts";
+export declare function makeUpdateThread(): (input: UpdateThreadInput) => Effect.Effect<{
+    readonly sequence: number;
+}, ModelSelectionError | ThreadEventError | import("../rpc/error.ts").RpcError, T3Orchestration | Crypto.Crypto>;

package/dist/src/application/thread-wait.d.ts

@@ -1,14 +1,12 @@
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 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";
 export declare function watchThread(input: {
-    readonly orchestration: Orchestration;
     readonly threadId: string;
-}): Stream.Stream<WaitEvent, ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
+}): Stream.Stream<WaitEvent, ThreadSessionError | import("../rpc/error.ts").RpcError, T3Orchestration>;
 export declare function waitForThread(input: {
-    readonly orchestration: Orchestration;
     readonly threadId: string;
 }): Effect.Effect<{
     readonly id: string & import("effect/Brand").Brand<"ThreadId">;
@@ -42,15 +40,6 @@ export declare function waitForThread(input: {
     readonly updatedAt: string;
     readonly archivedAt: string | null;
     readonly deletedAt: string | null;
-    readonly goal: {
-        readonly objective: string;
-        readonly status: "active" | "paused" | "budgetLimited" | "complete";
-        readonly tokensUsed: number;
-        readonly tokenBudget: number | null;
-        readonly timeUsedSeconds: number;
-        readonly createdAt: string;
-        readonly updatedAt: string;
-    } | null;
     readonly messages: readonly {
         readonly id: string & import("effect/Brand").Brand<"MessageId">;
         readonly role: "user" | "assistant" | "system";
@@ -110,4 +99,4 @@ export declare function waitForThread(input: {
         readonly updatedAt: string;
         readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
     } | null;
-}, ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
+}, ThreadSessionError | import("../rpc/error.ts").RpcError, T3Orchestration>;