t3code-cli 0.10.0 → 0.12.0

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

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect";
-import { ModelSelection } from "#t3tools/contracts";
-import type { OrchestrationProjectShell } from "#t3tools/contracts";
+import { ModelSelection } from "@t3tools/contracts";
+import type { OrchestrationProjectShell } from "@t3tools/contracts";
 import { ModelSelectionError } from "../domain/error.ts";
 import type { ServerConfigForCli } from "../orchestration/service.ts";
 import type { StartThreadInput } from "./service.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

@@ -1,10 +1,11 @@
 import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
 import * as Path from "effect/Path";
-import { Environment } from "../environment/service.ts";
+import { type ClientOrchestrationCommand } from "@t3tools/contracts";
 export declare const makeProjectCreateCommand: (input: {
     readonly path: string;
     readonly title?: string;
+    readonly cwd: string;
 }) => Effect.Effect<{
     type: "project.create";
     commandId: string & import("effect/Brand").Brand<"CommandId">;
@@ -12,4 +13,32 @@ export declare const makeProjectCreateCommand: (input: {
     title: string;
     workspaceRoot: string;
     createdAt: string;
-}, never, Environment | Path.Path | Crypto.Crypto>;
+}, never, 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>;
+export declare const makeProjectMetaUpdateCommand: (input: {
+    readonly projectId: string;
+    readonly scripts: Extract<ClientOrchestrationCommand, {
+        readonly type: "project.meta.update";
+    }>["scripts"];
+}) => Effect.Effect<{
+    type: "project.meta.update";
+    commandId: string & import("effect/Brand").Brand<"CommandId">;
+    projectId: string & import("effect/Brand").Brand<"ProjectId">;
+    scripts: readonly {
+        readonly id: string;
+        readonly name: string;
+        readonly command: string;
+        readonly icon: "play" | "test" | "lint" | "configure" | "build" | "debug";
+        readonly runOnWorktreeCreate: boolean;
+        readonly previewUrl?: string | undefined;
+        readonly autoOpenPreview?: boolean | undefined;
+    }[] | undefined;
+}, never, Crypto.Crypto>;

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

@@ -1,145 +1,23 @@
 import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
 import * as Path from "effect/Path";
-import { Environment } from "../environment/service.ts";
+import { CliRuntime } from "../cli/runtime/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>;
-}, never, Environment | T3Orchestration | Path.Path | Crypto.Crypto>;
+        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, CliRuntime | 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, ProjectScript, ProjectScriptIcon, 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,20 @@ export type StartThreadInput = {
     readonly options?: NonNullable<ModelSelection["options"]>;
     readonly worktreePath?: string;
 };
+export type CreateTerminalInput = {
+    readonly threadId: string;
+    readonly terminalId?: string;
+    readonly command?: string;
+    readonly env?: Readonly<Record<string, 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 +37,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 +64,79 @@ 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 ProjectActionSelector = {
+    readonly id: string;
+    readonly name?: never;
+} | {
+    readonly id?: never;
+    readonly name: string;
+};
+export type AddProjectActionInput = {
+    readonly projectRef: string;
+    readonly id?: string;
+    readonly name: string;
+    readonly command: string;
+    readonly icon?: ProjectScriptIcon;
+    readonly setup?: boolean;
+    readonly previewUrl?: string;
+    readonly autoOpenPreview?: boolean;
+};
+export type UpdateProjectActionInput = {
+    readonly projectRef: string;
+    readonly selector: ProjectActionSelector;
+    readonly name?: string;
+    readonly command?: string;
+    readonly icon?: ProjectScriptIcon;
+    readonly setup?: boolean;
+    readonly previewUrl?: string | null;
+    readonly autoOpenPreview?: boolean | null;
+};
+export type ProjectActionMutationResult = {
+    readonly dispatch: DispatchResult;
+    readonly project: OrchestrationProjectShell;
+    readonly action: ProjectScript;
+};
+export type ProjectActionDeleteResult = {
+    readonly dispatch: DispatchResult;
+    readonly project: OrchestrationProjectShell;
+    readonly action: ProjectScript;
+};
+export type ProjectActionRunResult = {
+    readonly project: OrchestrationProjectShell;
+    readonly action: ProjectScript;
+    readonly terminal: TerminalSessionSnapshot;
+};
+export type T3ActionApplicationService = {
+    readonly listActions: (projectRef: string) => Effect.Effect<{
+        readonly project: OrchestrationProjectShell;
+        readonly actions: ReadonlyArray<ProjectScript>;
+    }, ApplicationError>;
+    readonly addAction: (input: AddProjectActionInput) => Effect.Effect<ProjectActionMutationResult, ApplicationError>;
+    readonly updateAction: (input: UpdateProjectActionInput) => Effect.Effect<ProjectActionMutationResult, ApplicationError>;
+    readonly deleteAction: (input: {
+        readonly projectRef: string;
+        readonly selector: ProjectActionSelector;
+    }) => Effect.Effect<ProjectActionDeleteResult, ApplicationError>;
+    readonly runAction: (input: {
+        readonly threadId: string;
+        readonly selector: ProjectActionSelector;
+        readonly terminalId?: string;
+    }) => Effect.Effect<ProjectActionRunResult, ApplicationError>;
+};
+declare const T3ActionApplication_base: Context.ServiceClass<T3ActionApplication, "t3cli/T3ActionApplication", T3ActionApplicationService>;
+export declare class T3ActionApplication extends T3ActionApplication_base {
+}
+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 +144,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 +184,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 +208,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 & T3ActionApplicationService & 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;
@@ -24,6 +23,8 @@ export declare function waitForShellSequence(input: {
             readonly command: string;
             readonly icon: "play" | "test" | "lint" | "configure" | "build" | "debug";
             readonly runOnWorktreeCreate: boolean;
+            readonly previewUrl?: string | undefined;
+            readonly autoOpenPreview?: boolean | undefined;
         }[];
         readonly createdAt: string;
         readonly updatedAt: string;
@@ -84,7 +85,7 @@ export declare function waitForShellSequence(input: {
         } | null;
         readonly goal: {
             readonly objective: string;
-            readonly status: "active" | "paused" | "budgetLimited" | "complete";
+            readonly status: "active" | "paused" | "blocked" | "usageLimited" | "budgetLimited" | "complete";
             readonly tokensUsed: number;
             readonly tokenBudget: number | null;
             readonly timeUsedSeconds: number;
@@ -97,4 +98,4 @@ export declare function waitForShellSequence(input: {
         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>;