t3code-cli 0.11.0 → 0.12.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, T3Orchestration | Path.Path | Crypto.Crypto | 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,14 @@
 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<{
     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 +17,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 +72,46 @@ 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>;
+    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>;
     listModels: (input: {
         readonly all?: boolean;
         readonly provider?: string;
-    }) => Effect.Effect<ReadonlyArray<import("#t3tools/contracts").ServerProvider>, import("./error.ts").ApplicationError>;
-}, never, T3ModelApplication | T3ProjectApplication | T3ThreadApplication | T3TerminalApplication>;
+    }) => Effect.Effect<ReadonlyArray<import("@t3tools/contracts").ServerProvider>, import("./error.ts").ApplicationError>;
+    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>;
+}, never, T3ActionApplication | T3ModelApplication | T3ProjectApplication | T3ThreadApplication | T3TerminalApplication>;
 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 T3ProjectApplicationLive: Layer.Layer<T3ProjectApplication, never, import("../cli/runtime/service.ts").CliRuntime | 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 T3ActionApplicationLive: Layer.Layer<T3ActionApplication, never, import("../orchestration/service.ts").T3Orchestration | import("effect/Path").Path | import("effect/Crypto").Crypto | import("../rpc/operation.ts").T3RpcOperations>;
+export declare const T3ThreadApplicationLive: Layer.Layer<T3ThreadApplication, never, import("../cli/runtime/service.ts").CliRuntime | import("../orchestration/service.ts").T3Orchestration | import("effect/Path").Path | import("effect/Crypto").Crypto>;
+export declare const T3ApplicationSlicesLive: Layer.Layer<T3ActionApplication | T3ModelApplication | T3ProjectApplication | T3ThreadApplication | T3TerminalApplication, never, import("../cli/runtime/service.ts").CliRuntime | 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("../cli/runtime/service.ts").CliRuntime | import("../orchestration/service.ts").T3Orchestration | import("effect/Path").Path | import("effect/Crypto").Crypto | 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,7 +13,7 @@ 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;
@@ -22,3 +23,22 @@ export declare const makeProjectDeleteCommand: (input: {
     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,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 | 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, 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

@@ -23,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;
@@ -81,6 +83,15 @@ 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" | "blocked" | "usageLimited" | "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;

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

@@ -11,7 +11,7 @@ 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;
@@ -58,7 +58,7 @@ export declare const makeTerminalApplication: () => Effect.Effect<{
         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;

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

@@ -1,6 +1,6 @@
 import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
-import { type ModelSelection, type OrchestrationProjectShell, type ProviderApprovalDecision, type ProviderUserInputAnswers } from "#t3tools/contracts";
+import { type ModelSelection, type OrchestrationProjectShell, type ProviderApprovalDecision, type ProviderUserInputAnswers } from "@t3tools/contracts";
 import type { ServerConfigForCli } from "../orchestration/service.ts";
 import type { SendThreadInput, StartThreadInput } from "./service.ts";
 export declare const makeThreadStartCommands: (input: {

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

@@ -40,6 +40,15 @@ 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" | "blocked" | "usageLimited" | "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";

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

@@ -2,15 +2,15 @@ import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
 import * as Path from "effect/Path";
 import * as Stream from "effect/Stream";
-import { Environment } from "../environment/service.ts";
+import { CliRuntime } from "../cli/runtime/service.ts";
 import { T3Orchestration } from "../orchestration/service.ts";
 import { ProjectLookupError, ThreadLookupError, ThreadSessionError } from "../domain/error.ts";
 import { type ListThreadsInclude, type StartThreadInput } from "./service.ts";
 import type { CallbackThreadInput, SendThreadInput } from "./service.ts";
 import { derivePendingApprovals, derivePendingUserInputs } from "../domain/thread-activities.ts";
 import { type ThreadLifecycleStatus } from "../domain/thread-lifecycle.ts";
-import type { OrchestrationThread } from "#t3tools/contracts";
-import type { ProviderApprovalDecision, ProviderUserInputAnswers } from "#t3tools/contracts";
+import type { OrchestrationThread } from "@t3tools/contracts";
+import type { ProviderApprovalDecision, ProviderUserInputAnswers } from "@t3tools/contracts";
 export declare const makeThreadApplication: () => Effect.Effect<{
     approveThread: (input: {
         readonly threadId: string;
@@ -35,7 +35,7 @@ export declare const makeThreadApplication: () => Effect.Effect<{
     interruptThread: (threadId: string) => Effect.Effect<{
         readonly sequence: number;
     }, import("../rpc/error.ts").RpcError, never>;
-    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>;
     unarchiveThread: (threadId: string) => Effect.Effect<{
         readonly sequence: number;
     }, import("../rpc/error.ts").RpcError, never>;
@@ -60,6 +60,8 @@ export declare const makeThreadApplication: () => Effect.Effect<{
                 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;
@@ -118,6 +120,15 @@ export declare const makeThreadApplication: () => Effect.Effect<{
                 readonly updatedAt: string;
                 readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
             } | null;
+            readonly goal: {
+                readonly objective: string;
+                readonly status: "active" | "paused" | "blocked" | "usageLimited" | "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;
@@ -156,6 +167,15 @@ export declare const makeThreadApplication: () => Effect.Effect<{
         readonly updatedAt: string;
         readonly archivedAt: string | null;
         readonly deletedAt: string | null;
+        readonly goal: {
+            readonly objective: string;
+            readonly status: "active" | "paused" | "blocked" | "usageLimited" | "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";
@@ -272,6 +292,15 @@ export declare const makeThreadApplication: () => Effect.Effect<{
             readonly updatedAt: string;
             readonly archivedAt: string | null;
             readonly deletedAt: string | null;
+            readonly goal: {
+                readonly objective: string;
+                readonly status: "active" | "paused" | "blocked" | "usageLimited" | "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";
@@ -358,6 +387,8 @@ export declare const makeThreadApplication: () => Effect.Effect<{
                 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;
@@ -399,6 +430,8 @@ export declare const makeThreadApplication: () => Effect.Effect<{
                 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;
@@ -449,6 +482,15 @@ export declare const makeThreadApplication: () => Effect.Effect<{
             readonly updatedAt: string;
             readonly archivedAt: string | null;
             readonly deletedAt: string | null;
+            readonly goal: {
+                readonly objective: string;
+                readonly status: "active" | "paused" | "blocked" | "usageLimited" | "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";
@@ -543,6 +585,15 @@ export declare const makeThreadApplication: () => Effect.Effect<{
         readonly updatedAt: string;
         readonly archivedAt: string | null;
         readonly deletedAt: string | null;
+        readonly goal: {
+            readonly objective: string;
+            readonly status: "active" | "paused" | "blocked" | "usageLimited" | "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";
@@ -609,7 +660,7 @@ export declare const makeThreadApplication: () => Effect.Effect<{
         };
         targetThreadId: string;
     }, ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
-}, never, Environment | T3Orchestration | Path.Path | Crypto.Crypto>;
+}, never, CliRuntime | T3Orchestration | Path.Path | Crypto.Crypto>;
 export type ThreadShow = {
     readonly id: string;
     readonly projectId: string;

package/dist/src/auth/error.d.ts

@@ -2,7 +2,8 @@ import * as Cause from "effect/Cause";
 import * as Schema from "effect/Schema";
 import { PlatformError } from "effect/PlatformError";
 import { HttpClientError } from "effect/unstable/http";
-import { ConfigError, UrlError } from "../config/error.ts";
+import { ConfigError } from "../config/error.ts";
+import { UrlError } from "../config/url/error.ts";
 declare const AuthPairingUrlError_base: Schema.Class<AuthPairingUrlError, Schema.TaggedStruct<"AuthPairingUrlError", {
     readonly message: Schema.String;
     readonly cause: Schema.optionalKey<Schema.instanceOf<Cause.IllegalArgumentError, Cause.IllegalArgumentError>>;

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

@@ -7,4 +7,4 @@ export { T3AuthPairing, T3AuthPairingLive, makeT3AuthPairing, parsePairingUrl }
 export { AuthConfigError, AuthLocalDatabaseError, AuthLocalError, AuthLocalSecretError, AuthLocalSigningError, AuthPairingUrlError, AuthTransportError, } from "./error.ts";
 export type { AuthError } from "./error.ts";
 export type { AuthSessionState, AuthWebSocketTicketResult } from "./schema.ts";
-export type { AuthConfigInput, AuthSessionRole, LocalAuthInput, LocalAuthOriginInput, LocalAuthResult, LocalAuthTokenInput, LocalAuthTokenResult, PairingUrl, PairResult, } from "./type.ts";
+export type { AuthConfigInput, AuthEnvironmentListItem, AuthEnvironmentSummary, AuthResolvedConfig, AuthSessionRole, AuthStatusResult, AuthUnpairResult, AuthUseResult, LocalAuthInput, LocalAuthOriginInput, LocalAuthResult, LocalAuthTokenInput, LocalAuthTokenResult, PairingUrl, PairResult, PersistEnvironmentInput, } from "./type.ts";