t3code-cli 0.11.0 → 0.13.0

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

@@ -0,0 +1,25 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Path from "effect/Path";
+import { type OrchestrationProjectShell, type ProjectScript } from "@t3tools/contracts";
+import { T3Orchestration } from "../orchestration/service.ts";
+import { T3TerminalApplication, type AddProjectActionInput, type ProjectActionSelector, type UpdateProjectActionInput } from "./service.ts";
+export declare const makeActionApplication: () => Effect.Effect<{
+    addAction: (input: AddProjectActionInput) => Effect.Effect<import("./service.ts").ProjectActionMutationResult, import("./error.ts").ApplicationError>;
+    deleteAction: (input: {
+        readonly projectRef: string;
+        readonly selector: ProjectActionSelector;
+    }) => Effect.Effect<import("./service.ts").ProjectActionDeleteResult, import("./error.ts").ApplicationError>;
+    listActions: (projectRef: string) => Effect.Effect<{
+        readonly project: OrchestrationProjectShell;
+        readonly actions: ReadonlyArray<ProjectScript>;
+    }, import("./error.ts").ApplicationError>;
+    runAction: (input: {
+        readonly threadId: string;
+        readonly selector: ProjectActionSelector;
+        readonly terminalId?: string;
+    }) => Effect.Effect<import("./service.ts").ProjectActionRunResult, import("./error.ts").ApplicationError>;
+    updateAction: (input: UpdateProjectActionInput) => Effect.Effect<import("./service.ts").ProjectActionMutationResult, import("./error.ts").ApplicationError>;
+}, never, Crypto.Crypto | Path.Path | T3Orchestration | T3TerminalApplication>;
+export declare function nextProjectScriptId(name: string, existingIds: Iterable<string>): string;
+export declare function resolveActionBySelector(scripts: ReadonlyArray<ProjectScript>, selector: ProjectActionSelector, projectId: string): ProjectScript;

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

@@ -1,4 +1,4 @@
-export { T3Application, T3ModelApplication, T3ProjectApplication, T3TerminalApplication, T3ThreadApplication, } from "./service.ts";
-export { makeT3Application, T3ApplicationLive, T3ApplicationSlicesLive, T3ModelApplicationLive, T3ProjectApplicationLive, T3TerminalApplicationLive, T3ThreadApplicationLive, } from "./layer.ts";
-export type { SendThreadInput, StartThreadInput, StartThreadPolicy, T3ApplicationService, T3ModelApplicationService, T3ProjectApplicationService, T3TerminalApplicationService, T3ThreadApplicationService, UpdateThreadInput, WaitEvent, } from "./service.ts";
+export { T3ActionApplication, T3Application, T3ModelApplication, T3ProjectApplication, T3TerminalApplication, T3ThreadApplication, } from "./service.ts";
+export { makeT3Application, T3ActionApplicationLive, T3ApplicationLive, T3ApplicationSlicesLive, T3ModelApplicationLive, T3ProjectApplicationLive, T3TerminalApplicationLive, T3ThreadApplicationLive, } from "./layer.ts";
+export type { AddProjectActionInput, ProjectActionDeleteResult, ProjectActionMutationResult, ProjectActionRunResult, ProjectActionSelector, SendThreadInput, StartThreadInput, StartThreadPolicy, T3ActionApplicationService, UpdateProjectActionInput, UpdateThreadInput, WaitEvent, } from "./service.ts";
 export type { ApplicationError } from "./error.ts";

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

@@ -1,14 +1,49 @@
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import { T3Application, T3ModelApplication, T3ProjectApplication, T3TerminalApplication, T3ThreadApplication } from "./service.ts";
+import { T3ActionApplication, T3Application, T3ModelApplication, T3ProjectApplication, T3TerminalApplication, T3ThreadApplication } from "./service.ts";
 export declare const makeT3Application: () => Effect.Effect<{
+    listActions: (projectRef: string) => Effect.Effect<{
+        readonly project: import("@t3tools/contracts").OrchestrationProjectShell;
+        readonly actions: ReadonlyArray<import("@t3tools/contracts").ProjectScript>;
+    }, import("./error.ts").ApplicationError>;
+    addAction: (input: import("./service.ts").AddProjectActionInput) => Effect.Effect<import("./service.ts").ProjectActionMutationResult, import("./error.ts").ApplicationError>;
+    updateAction: (input: import("./service.ts").UpdateProjectActionInput) => Effect.Effect<import("./service.ts").ProjectActionMutationResult, import("./error.ts").ApplicationError>;
+    deleteAction: (input: {
+        readonly projectRef: string;
+        readonly selector: import("./service.ts").ProjectActionSelector;
+    }) => Effect.Effect<import("./service.ts").ProjectActionDeleteResult, import("./error.ts").ApplicationError>;
+    runAction: (input: {
+        readonly threadId: string;
+        readonly selector: import("./service.ts").ProjectActionSelector;
+        readonly terminalId?: string;
+    }) => Effect.Effect<import("./service.ts").ProjectActionRunResult, import("./error.ts").ApplicationError>;
+    listModels: (input: {
+        readonly all?: boolean;
+        readonly provider?: string;
+    }) => Effect.Effect<ReadonlyArray<import("@t3tools/contracts").ServerProvider>, import("./error.ts").ApplicationError>;
+    loadShell: () => Effect.Effect<import("@t3tools/contracts").OrchestrationShellSnapshot, import("./error.ts").ApplicationError>;
+    addProject: (input: {
+        readonly path: string;
+        readonly title?: string;
+    }) => Effect.Effect<{
+        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>;
     listThreads: (projectRef: string, options?: {
         readonly include?: import("./service.ts").ListThreadsInclude;
     }) => Effect.Effect<{
-        readonly project: import("#t3tools/contracts").OrchestrationProjectShell;
-        readonly threads: ReadonlyArray<import("#t3tools/contracts").OrchestrationThreadShell>;
+        readonly project: import("@t3tools/contracts").OrchestrationProjectShell;
+        readonly threads: ReadonlyArray<import("@t3tools/contracts").OrchestrationThreadShell>;
     }, import("./error.ts").ApplicationError>;
-    getThreadMessages: (threadId: string) => Effect.Effect<import("#t3tools/contracts").OrchestrationThread, import("./error.ts").ApplicationError>;
+    getThreadMessages: (threadId: string) => Effect.Effect<import("@t3tools/contracts").OrchestrationThread, import("./error.ts").ApplicationError>;
     showThread: (threadId: string) => Effect.Effect<import("./threads.ts").ThreadShow, import("./error.ts").ApplicationError>;
     approveThread: (input: {
         readonly threadId: string;
@@ -17,51 +52,51 @@ export declare const makeT3Application: () => Effect.Effect<{
     }) => Effect.Effect<{
         readonly threadId: string;
         readonly requestId: string;
-        readonly dispatch: import("#t3tools/contracts").DispatchResult;
+        readonly dispatch: import("@t3tools/contracts").DispatchResult;
     }, import("./error.ts").ApplicationError>;
     respondToThread: (input: {
         readonly threadId: string;
         readonly requestId: string;
-        readonly answers: import("#t3tools/contracts").ProviderUserInputAnswers;
+        readonly answers: import("@t3tools/contracts").ProviderUserInputAnswers;
     }) => Effect.Effect<{
         readonly threadId: string;
         readonly requestId: string;
-        readonly dispatch: import("#t3tools/contracts").DispatchResult;
+        readonly dispatch: import("@t3tools/contracts").DispatchResult;
     }, import("./error.ts").ApplicationError>;
-    archiveThread: (threadId: string) => Effect.Effect<import("#t3tools/contracts").DispatchResult, import("./error.ts").ApplicationError>;
-    interruptThread: (threadId: string) => Effect.Effect<import("#t3tools/contracts").DispatchResult, import("./error.ts").ApplicationError>;
-    unarchiveThread: (threadId: string) => Effect.Effect<import("#t3tools/contracts").DispatchResult, import("./error.ts").ApplicationError>;
+    archiveThread: (threadId: string) => Effect.Effect<import("@t3tools/contracts").DispatchResult, import("./error.ts").ApplicationError>;
+    interruptThread: (threadId: string) => Effect.Effect<import("@t3tools/contracts").DispatchResult, import("./error.ts").ApplicationError>;
+    unarchiveThread: (threadId: string) => Effect.Effect<import("@t3tools/contracts").DispatchResult, import("./error.ts").ApplicationError>;
     deleteThread: (threadId: string) => Effect.Effect<{
         readonly threadId: string;
-        readonly dispatch: import("#t3tools/contracts").DispatchResult;
+        readonly dispatch: import("@t3tools/contracts").DispatchResult;
     }, import("./error.ts").ApplicationError>;
-    updateThread: (input: import("./service.ts").UpdateThreadInput) => Effect.Effect<import("#t3tools/contracts").DispatchResult, import("./error.ts").ApplicationError>;
+    updateThread: (input: import("./service.ts").UpdateThreadInput) => Effect.Effect<import("@t3tools/contracts").DispatchResult, import("./error.ts").ApplicationError>;
     startThread: (input: import("./service.ts").StartThreadInput, policy?: import("./service.ts").StartThreadPolicy) => Effect.Effect<{
-        readonly dispatch: import("#t3tools/contracts").DispatchResult;
-        readonly project: import("#t3tools/contracts").OrchestrationProjectShell;
+        readonly dispatch: import("@t3tools/contracts").DispatchResult;
+        readonly project: import("@t3tools/contracts").OrchestrationProjectShell;
         readonly threadId: string;
-        readonly thread?: import("#t3tools/contracts").OrchestrationThread;
+        readonly thread?: import("@t3tools/contracts").OrchestrationThread;
     }, import("./error.ts").ApplicationError>;
     sendThread: (input: import("./service.ts").SendThreadInput, policy?: import("./service.ts").StartThreadPolicy) => Effect.Effect<{
-        readonly dispatch: import("#t3tools/contracts").DispatchResult;
+        readonly dispatch: import("@t3tools/contracts").DispatchResult;
         readonly threadId: string;
-        readonly thread?: import("#t3tools/contracts").OrchestrationThread;
+        readonly thread?: import("@t3tools/contracts").OrchestrationThread;
     }, import("./error.ts").ApplicationError>;
     watchThread: (threadId: string) => import("effect/Stream").Stream<import("./service.ts").WaitEvent, import("./error.ts").ApplicationError>;
-    waitForThread: (threadId: string) => Effect.Effect<import("#t3tools/contracts").OrchestrationThread, import("./error.ts").ApplicationError>;
+    waitForThread: (threadId: string) => Effect.Effect<import("@t3tools/contracts").OrchestrationThread, import("./error.ts").ApplicationError>;
     callbackThread: (input: import("./service.ts").CallbackThreadInput) => Effect.Effect<{
-        readonly dispatch: import("#t3tools/contracts").DispatchResult;
+        readonly dispatch: import("@t3tools/contracts").DispatchResult;
         readonly targetThreadId: string;
     }, import("./error.ts").ApplicationError>;
-    listTerminals: (threadId: string) => Effect.Effect<ReadonlyArray<import("#t3tools/contracts").TerminalSummary>, import("./error.ts").ApplicationError>;
-    getTerminal: (terminal: import("./service.ts").TerminalRef) => Effect.Effect<import("#t3tools/contracts").TerminalSummary, import("./error.ts").ApplicationError>;
-    createTerminal: (input: import("./service.ts").CreateTerminalInput) => Effect.Effect<import("#t3tools/contracts").TerminalSessionSnapshot, import("./error.ts").ApplicationError>;
+    listTerminals: (threadId: string) => Effect.Effect<ReadonlyArray<import("@t3tools/contracts").TerminalSummary>, import("./error.ts").ApplicationError>;
+    getTerminal: (terminal: import("./service.ts").TerminalRef) => Effect.Effect<import("@t3tools/contracts").TerminalSummary, import("./error.ts").ApplicationError>;
+    createTerminal: (input: import("./service.ts").CreateTerminalInput) => Effect.Effect<import("@t3tools/contracts").TerminalSessionSnapshot, import("./error.ts").ApplicationError>;
     attachTerminal: (input: {
         readonly terminal: import("./service.ts").TerminalAttachTarget;
         readonly cols?: number;
         readonly rows?: number;
-    }) => import("effect/Stream").Stream<import("#t3tools/contracts").TerminalAttachStreamEvent, import("./error.ts").ApplicationError>;
-    watchTerminalMetadata: () => import("effect/Stream").Stream<import("#t3tools/contracts").TerminalMetadataStreamEvent, import("./error.ts").ApplicationError>;
+    }) => import("effect/Stream").Stream<import("@t3tools/contracts").TerminalAttachStreamEvent, import("./error.ts").ApplicationError>;
+    watchTerminalMetadata: () => import("effect/Stream").Stream<import("@t3tools/contracts").TerminalMetadataStreamEvent, import("./error.ts").ApplicationError>;
     writeTerminal: (input: {
         readonly terminal: import("./service.ts").TerminalRef;
         readonly data: string;
@@ -72,30 +107,11 @@ export declare const makeT3Application: () => Effect.Effect<{
         readonly rows: number;
     }) => Effect.Effect<void, import("./error.ts").ApplicationError>;
     destroyTerminal: (terminal: import("./service.ts").TerminalRef) => Effect.Effect<void, import("./error.ts").ApplicationError>;
-    loadShell: () => Effect.Effect<import("#t3tools/contracts").OrchestrationShellSnapshot, import("./error.ts").ApplicationError>;
-    addProject: (input: {
-        readonly path: string;
-        readonly title?: string;
-    }) => Effect.Effect<{
-        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>;
-    listModels: (input: {
-        readonly all?: boolean;
-        readonly provider?: string;
-    }) => Effect.Effect<ReadonlyArray<import("#t3tools/contracts").ServerProvider>, import("./error.ts").ApplicationError>;
-}, never, T3ModelApplication | T3ProjectApplication | T3ThreadApplication | T3TerminalApplication>;
+}, never, T3ActionApplication | T3ModelApplication | T3ProjectApplication | T3TerminalApplication | T3ThreadApplication>;
 export declare const T3ModelApplicationLive: Layer.Layer<T3ModelApplication, never, import("../orchestration/service.ts").T3Orchestration>;
-export declare const T3ProjectApplicationLive: Layer.Layer<T3ProjectApplication, never, import("../environment/service.ts").Environment | import("../orchestration/service.ts").T3Orchestration | import("effect/Path").Path | import("effect/Crypto").Crypto>;
-export declare const T3TerminalApplicationLive: Layer.Layer<T3TerminalApplication, never, import("../orchestration/service.ts").T3Orchestration | import("effect/Crypto").Crypto | import("../rpc/operation.ts").T3RpcOperations>;
-export declare const T3ThreadApplicationLive: Layer.Layer<T3ThreadApplication, never, import("../environment/service.ts").Environment | import("../orchestration/service.ts").T3Orchestration | import("effect/Path").Path | import("effect/Crypto").Crypto>;
-export declare const T3ApplicationSlicesLive: Layer.Layer<T3ModelApplication | T3ProjectApplication | T3ThreadApplication | T3TerminalApplication, never, import("../environment/service.ts").Environment | import("../orchestration/service.ts").T3Orchestration | import("effect/Path").Path | import("effect/Crypto").Crypto | import("../rpc/operation.ts").T3RpcOperations>;
-export declare const T3ApplicationLive: Layer.Layer<T3Application, never, import("../environment/service.ts").Environment | import("../orchestration/service.ts").T3Orchestration | import("effect/Path").Path | import("effect/Crypto").Crypto | import("../rpc/operation.ts").T3RpcOperations>;
+export declare const T3ProjectApplicationLive: Layer.Layer<T3ProjectApplication, never, import("../cli/runtime/service.ts").CliRuntime | import("effect/Crypto").Crypto | import("effect/Path").Path | import("../orchestration/service.ts").T3Orchestration>;
+export declare const T3TerminalApplicationLive: Layer.Layer<T3TerminalApplication, never, import("effect/Crypto").Crypto | import("../orchestration/service.ts").T3Orchestration | import("../rpc/operation.ts").T3RpcOperations>;
+export declare const T3ActionApplicationLive: Layer.Layer<T3ActionApplication, never, import("effect/Crypto").Crypto | import("effect/Path").Path | import("../orchestration/service.ts").T3Orchestration | import("../rpc/operation.ts").T3RpcOperations>;
+export declare const T3ThreadApplicationLive: Layer.Layer<T3ThreadApplication, never, import("../cli/runtime/service.ts").CliRuntime | import("effect/Crypto").Crypto | import("effect/Path").Path | import("../orchestration/service.ts").T3Orchestration>;
+export declare const T3ApplicationSlicesLive: Layer.Layer<T3ActionApplication | T3ModelApplication | T3ProjectApplication | T3TerminalApplication | T3ThreadApplication, never, import("../cli/runtime/service.ts").CliRuntime | import("effect/Crypto").Crypto | import("effect/Path").Path | import("../orchestration/service.ts").T3Orchestration | import("../rpc/operation.ts").T3RpcOperations>;
+export declare const T3ApplicationLive: Layer.Layer<T3Application, never, import("../cli/runtime/service.ts").CliRuntime | import("effect/Crypto").Crypto | import("effect/Path").Path | import("../orchestration/service.ts").T3Orchestration | import("../rpc/operation.ts").T3RpcOperations>;

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";

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

@@ -4,5 +4,5 @@ export declare const makeModelsApplication: () => Effect.Effect<{
     listModels: (input: {
         readonly all?: boolean;
         readonly provider?: string;
-    }) => Effect.Effect<ReadonlyArray<import("#t3tools/contracts").ServerProvider>, import("./error.ts").ApplicationError>;
+    }) => 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,13 +13,32 @@ export declare const makeProjectCreateCommand: (input: {
     title: string;
     workspaceRoot: string;
     createdAt: string;
-}, never, Environment | Path.Path | Crypto.Crypto>;
+}, never, Crypto.Crypto | Path.Path>;
 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">;
+    force?: true;
+}, 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: "build" | "configure" | "debug" | "lint" | "play" | "test";
+        readonly runOnWorktreeCreate: boolean;
+        readonly previewUrl?: string | undefined;
+        readonly autoOpenPreview?: boolean | undefined;
+    }[] | undefined;
 }, never, Crypto.Crypto>;

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

@@ -1,23 +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";
 export declare const makeProjectApplication: () => Effect.Effect<{
-    loadShell: () => Effect.Effect<import("#t3tools/contracts").OrchestrationShellSnapshot, import("./error.ts").ApplicationError>;
+    loadShell: () => Effect.Effect<import("@t3tools/contracts").OrchestrationShellSnapshot, import("./error.ts").ApplicationError>;
     addProject: (input: {
         readonly path: string;
         readonly title?: string;
     }) => Effect.Effect<{
-        readonly dispatch: import("#t3tools/contracts").DispatchResult;
-        readonly project: import("#t3tools/contracts").OrchestrationProjectShell;
+        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>;
+    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;
+        readonly dispatch: import("@t3tools/contracts").DispatchResult;
     }, import("./error.ts").ApplicationError>;
-}, never, Environment | T3Orchestration | Path.Path | Crypto.Crypto>;
+}, never, CliRuntime | Crypto.Crypto | Path.Path | T3Orchestration>;

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, TerminalAttachStreamEvent, TerminalMetadataStreamEvent, TerminalSessionSnapshot, TerminalSummary } 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 = {
@@ -17,6 +17,7 @@ export type CreateTerminalInput = {
     readonly threadId: string;
     readonly terminalId?: string;
     readonly command?: string;
+    readonly env?: Readonly<Record<string, string>>;
 };
 export type TerminalRef = {
     readonly threadId: string;
@@ -63,6 +64,68 @@ export type WaitEvent = {
     readonly type: "done";
     readonly thread: OrchestrationThread;
 };
+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;
@@ -173,7 +236,7 @@ export type T3TerminalApplicationService = {
 declare const T3TerminalApplication_base: Context.ServiceClass<T3TerminalApplication, "t3cli/T3TerminalApplication", T3TerminalApplicationService>;
 export declare class T3TerminalApplication extends T3TerminalApplication_base {
 }
-export type T3ApplicationService = T3ModelApplicationService & T3ProjectApplicationService & T3ThreadApplicationService & T3TerminalApplicationService;
+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 {
 }

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

@@ -9,6 +9,19 @@ export declare function waitForShellSequence(input: {
         readonly id: string & import("effect/Brand").Brand<"ProjectId">;
         readonly title: string;
         readonly workspaceRoot: 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 defaultModelSelection: {
             readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
             readonly model: string;
@@ -21,24 +34,13 @@ export declare function waitForShellSequence(input: {
             readonly id: string;
             readonly name: string;
             readonly command: string;
-            readonly icon: "play" | "test" | "lint" | "configure" | "build" | "debug";
+            readonly icon: "build" | "configure" | "debug" | "lint" | "play" | "test";
             readonly runOnWorktreeCreate: boolean;
+            readonly previewUrl?: string | undefined;
+            readonly autoOpenPreview?: boolean | undefined;
         }[];
         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">;
@@ -52,13 +54,13 @@ export declare function waitForShellSequence(input: {
                 readonly value: string | boolean;
             }[];
         };
-        readonly runtimeMode: "approval-required" | "auto-accept-edits" | "full-access";
+        readonly runtimeMode: "approval-required" | "auto" | "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 state: "completed" | "error" | "interrupted" | "running";
             readonly requestedAt: string;
             readonly startedAt: string | null;
             readonly completedAt: string | null;
@@ -71,15 +73,19 @@ export declare function waitForShellSequence(input: {
         readonly createdAt: string;
         readonly updatedAt: string;
         readonly archivedAt: string | null;
+        readonly settledOverride: "active" | "settled" | null;
+        readonly settledAt: string | null;
+        readonly snoozedUntil?: string | null | undefined;
+        readonly snoozedAt?: string | null | undefined;
         readonly session: {
             readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
-            readonly status: "error" | "idle" | "starting" | "running" | "ready" | "interrupted" | "stopped";
+            readonly status: "error" | "idle" | "interrupted" | "ready" | "running" | "starting" | "stopped";
             readonly providerName: string | null;
-            readonly runtimeMode: "approval-required" | "auto-accept-edits" | "full-access";
+            readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
+            readonly runtimeMode: "approval-required" | "auto" | "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 latestUserMessageAt: string | null;
         readonly hasPendingApprovals: boolean;

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

@@ -11,13 +11,13 @@ export declare const makeTerminalApplication: () => Effect.Effect<{
         readonly terminal: import("./service.ts").TerminalAttachTarget;
         readonly cols?: number;
         readonly rows?: number;
-    }) => Stream.Stream<import("#t3tools/contracts").TerminalAttachStreamEvent, import("./error.ts").ApplicationError>;
+    }) => 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 status: "error" | "exited" | "running" | "starting";
         readonly pid: number | null;
         readonly history: string;
         readonly exitCode: number | null;
@@ -32,35 +32,35 @@ export declare const makeTerminalApplication: () => Effect.Effect<{
         readonly terminalId: string;
         readonly cwd: string;
         readonly worktreePath: string | null;
-        readonly status: "error" | "starting" | "running" | "exited";
+        readonly status: "error" | "exited" | "running" | "starting";
         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>;
+    }, RpcError | TerminalLookupError | ThreadLookupError, 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 status: "error" | "exited" | "running" | "starting";
         readonly pid: number | null;
         readonly exitCode: number | null;
         readonly exitSignal: number | null;
         readonly hasRunningSubprocess: boolean;
         readonly label: string;
         readonly updatedAt: string;
-    }[], ThreadLookupError | RpcError, never>;
+    }[], RpcError | ThreadLookupError, 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>;
+    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>;
+}, never, Crypto.Crypto | T3Orchestration | T3RpcOperations>;