t3code-cli 0.10.0 → 0.12.0

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

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

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

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

@@ -1,14 +1,12 @@
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import { ThreadSessionError } from "../domain/error.ts";
-import type { Orchestration } from "../orchestration/service.ts";
+import { T3Orchestration } from "../orchestration/service.ts";
 import type { WaitEvent } from "./service.ts";
 export declare function watchThread(input: {
-    readonly orchestration: Orchestration;
     readonly threadId: string;
-}): Stream.Stream<WaitEvent, ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
+}): Stream.Stream<WaitEvent, ThreadSessionError | import("../rpc/error.ts").RpcError, T3Orchestration>;
 export declare function waitForThread(input: {
-    readonly orchestration: Orchestration;
     readonly threadId: string;
 }): Effect.Effect<{
     readonly id: string & import("effect/Brand").Brand<"ThreadId">;
@@ -44,7 +42,7 @@ export declare function waitForThread(input: {
     readonly deletedAt: string | 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;
@@ -110,4 +108,4 @@ export declare function waitForThread(input: {
         readonly updatedAt: string;
         readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
     } | null;
-}, ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
+}, ThreadSessionError | import("../rpc/error.ts").RpcError, T3Orchestration>;

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

@@ -1,15 +1,16 @@
 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 * as Stream from "effect/Stream";
+import { CliRuntime } from "../cli/runtime/service.ts";
 import { T3Orchestration } from "../orchestration/service.ts";
-import { ProjectLookupError, ThreadSessionError } from "../domain/error.ts";
-import { type StartThreadInput } from "./service.ts";
-import type { SendThreadInput, CallbackThreadInput } from "./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;
@@ -25,7 +26,22 @@ export declare const makeThreadApplication: () => Effect.Effect<{
     archiveThread: (threadId: string) => Effect.Effect<{
         readonly sequence: number;
     }, import("../rpc/error.ts").RpcError, never>;
-    listThreads: (projectRef: string) => Effect.Effect<{
+    deleteThread: (threadId: string) => Effect.Effect<{
+        threadId: string;
+        dispatch: {
+            readonly sequence: number;
+        };
+    }, ThreadLookupError | import("../rpc/error.ts").RpcError, never>;
+    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>;
+    unarchiveThread: (threadId: string) => Effect.Effect<{
+        readonly sequence: number;
+    }, import("../rpc/error.ts").RpcError, never>;
+    listThreads: (projectRef: string, options?: {
+        readonly include?: ListThreadsInclude;
+    } | undefined) => Effect.Effect<{
         project: {
             readonly id: string & import("effect/Brand").Brand<"ProjectId">;
             readonly title: string;
@@ -44,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;
@@ -104,7 +122,7 @@ export declare const makeThreadApplication: () => Effect.Effect<{
             } | 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;
@@ -151,7 +169,7 @@ export declare const makeThreadApplication: () => Effect.Effect<{
         readonly deletedAt: string | 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;
@@ -276,7 +294,7 @@ export declare const makeThreadApplication: () => Effect.Effect<{
             readonly deletedAt: string | 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;
@@ -369,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;
@@ -410,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;
@@ -462,7 +484,7 @@ export declare const makeThreadApplication: () => Effect.Effect<{
             readonly deletedAt: string | 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;
@@ -530,7 +552,7 @@ export declare const makeThreadApplication: () => Effect.Effect<{
             } | null;
         };
     }, ProjectLookupError | import("../domain/error.ts").ModelSelectionError | ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
-    watchThread: (threadId: string) => import("effect/Stream").Stream<import("./service.ts").WaitEvent, ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
+    watchThread: (threadId: string) => Stream.Stream<import("./service.ts").WaitEvent, ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
     waitForThread: (threadId: string) => Effect.Effect<{
         readonly id: string & import("effect/Brand").Brand<"ThreadId">;
         readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
@@ -565,7 +587,7 @@ export declare const makeThreadApplication: () => Effect.Effect<{
         readonly deletedAt: string | 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;
@@ -638,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";

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

@@ -1,21 +1,49 @@
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import { T3Config } from "../config/service.ts";
+import { T3Config } from "../config/config.ts";
 import { AuthConfigError } from "./error.ts";
 import { T3LocalAuth } from "./local.ts";
 import { T3AuthPairing } from "./pairing.ts";
 import { T3Auth } from "./service.ts";
 import { T3AuthTransport } from "./transport.ts";
-import type { AuthConfigInput } from "./type.ts";
+import type { AuthConfigInput, AuthEnvironmentListItem, AuthResolvedConfig } from "./type.ts";
 export declare const makeT3Auth: () => Effect.Effect<{
     pair: (pairingUrl: string) => Effect.Effect<import("./type.ts").PairResult, import("./error.ts").AuthPairingUrlError | import("./error.ts").AuthTransportError>;
     local: (input: import("./type.ts").LocalAuthInput) => Effect.Effect<import("./type.ts").LocalAuthResult, import("./error.ts").AuthLocalError>;
     writeConfig: (input: AuthConfigInput) => Effect.Effect<void, AuthConfigError, never>;
+    persistEnvironment: (input: {
+        readonly name: string;
+        readonly url: string;
+        readonly token: string;
+        readonly local: boolean;
+        readonly replace?: boolean;
+        readonly allowReplace: boolean;
+    }) => Effect.Effect<string, AuthConfigError, never>;
+    environmentExists: (name: string) => Effect.Effect<boolean, AuthConfigError, never>;
+    defaultNameFromUrl: (url: string) => Effect.Effect<string, AuthConfigError, never>;
+    defaultNameForLocal: () => Effect.Effect<"local", never, never>;
+    listEnvironments: () => Effect.Effect<AuthEnvironmentListItem[], AuthConfigError, never>;
+    useEnvironment: (name: string) => Effect.Effect<{
+        name: string;
+        default: true;
+    }, AuthConfigError, never>;
+    resolveUnpairTarget: (input: {
+        readonly name?: string;
+    }) => Effect.Effect<string, AuthConfigError, never>;
+    unpairEnvironment: (input: {
+        readonly name: string;
+    }) => Effect.Effect<{
+        name: string;
+        removed: true;
+    }, AuthConfigError, never>;
     status: () => Effect.Effect<{
-        readonly authenticated: boolean;
-        readonly role?: "client" | "owner";
-        readonly sessionMethod?: string;
-        readonly expiresAt?: string;
+        readonly config: AuthResolvedConfig;
+        readonly session: {
+            readonly authenticated: boolean;
+            readonly role?: "client" | "owner";
+            readonly sessionMethod?: string;
+            readonly expiresAt?: string;
+        };
     }, AuthConfigError | import("./error.ts").AuthTransportError, never>;
     issueWebSocketTicket: () => Effect.Effect<{
         readonly ticket: string;

package/dist/src/auth/local-base-dir.d.ts

@@ -1,5 +1,8 @@
 import * as Effect from "effect/Effect";
-import { Environment } from "../environment/service.ts";
+import type { CliRuntime } from "../cli/runtime/service.ts";
+import type { T3CliEnvShape } from "../config/env/env.ts";
 export declare const resolveLocalBaseDir: (input: {
     readonly baseDir?: string | undefined;
-}) => Effect.Effect<string, never, Environment | import("effect/Path").Path>;
+    readonly cliRuntime: CliRuntime["Service"];
+    readonly t3CliEnv: T3CliEnvShape;
+}) => Effect.Effect<string, never, import("effect/Path").Path>;

package/dist/src/auth/local-origin.d.ts

@@ -3,7 +3,7 @@ import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";
-import { Environment } from "../environment/service.ts";
+import { CliRuntime } from "../cli/runtime/service.ts";
 import { AuthLocalError } from "./error.ts";
 import type { LocalAuthOriginInput } from "./type.ts";
 declare const T3LocalAuthOrigin_base: Context.ServiceClass<T3LocalAuthOrigin, "t3cli/T3LocalAuthOrigin", {
@@ -13,6 +13,6 @@ export declare class T3LocalAuthOrigin extends T3LocalAuthOrigin_base {
 }
 export declare const makeT3LocalAuthOrigin: () => Effect.Effect<{
     resolve: (input?: LocalAuthOriginInput | undefined) => Effect.Effect<string, AuthLocalError, never>;
-}, never, Environment | Path.Path | FileSystem.FileSystem>;
-export declare const T3LocalAuthOriginLive: Layer.Layer<T3LocalAuthOrigin, never, Environment | Path.Path | FileSystem.FileSystem>;
+}, import("effect/Config").ConfigError, CliRuntime | Path.Path | FileSystem.FileSystem>;
+export declare const T3LocalAuthOriginLive: Layer.Layer<T3LocalAuthOrigin, import("effect/Config").ConfigError, CliRuntime | Path.Path | FileSystem.FileSystem>;
 export {};

package/dist/src/auth/local-token.d.ts

@@ -4,7 +4,7 @@ import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";
-import { Environment } from "../environment/service.ts";
+import { CliRuntime } from "../cli/runtime/service.ts";
 import { SqlClientFactory } from "../sql/service.ts";
 import { AuthLocalError } from "./error.ts";
 import type { LocalAuthTokenInput, LocalAuthTokenResult } from "./type.ts";
@@ -21,6 +21,6 @@ export declare const makeT3LocalAuthToken: () => Effect.Effect<{
         source: "local";
         baseDir: string;
     }, AuthLocalError, never>;
-}, never, Environment | Path.Path | Crypto.Crypto | FileSystem.FileSystem | SqlClientFactory>;
-export declare const T3LocalAuthTokenLive: Layer.Layer<T3LocalAuthToken, never, Environment | Path.Path | Crypto.Crypto | FileSystem.FileSystem | SqlClientFactory>;
+}, import("effect/Config").ConfigError, CliRuntime | Path.Path | Crypto.Crypto | FileSystem.FileSystem | SqlClientFactory>;
+export declare const T3LocalAuthTokenLive: Layer.Layer<T3LocalAuthToken, import("effect/Config").ConfigError, CliRuntime | Path.Path | Crypto.Crypto | FileSystem.FileSystem | SqlClientFactory>;
 export {};

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

@@ -1,13 +1,25 @@
 import * as Context from "effect/Context";
 import type * as Effect from "effect/Effect";
-import type { AuthSessionState, AuthWebSocketTicketResult } from "./schema.ts";
+import type { AuthWebSocketTicketResult } from "./schema.ts";
 import type { AuthError } from "./error.ts";
-import type { AuthConfigInput, LocalAuthInput, LocalAuthResult, PairResult } from "./type.ts";
+import type { AuthConfigInput, AuthEnvironmentListItem, AuthStatusResult, AuthUnpairResult, AuthUseResult, LocalAuthInput, LocalAuthResult, PairResult, PersistEnvironmentInput } from "./type.ts";
 declare const T3Auth_base: Context.ServiceClass<T3Auth, "t3cli/T3Auth", {
     readonly pair: (value: string) => Effect.Effect<PairResult, AuthError>;
     readonly local: (input: LocalAuthInput) => Effect.Effect<LocalAuthResult, AuthError>;
     readonly writeConfig: (input: AuthConfigInput) => Effect.Effect<void, AuthError>;
-    readonly status: () => Effect.Effect<AuthSessionState, AuthError>;
+    readonly persistEnvironment: (input: PersistEnvironmentInput) => Effect.Effect<string, AuthError>;
+    readonly environmentExists: (name: string) => Effect.Effect<boolean, AuthError>;
+    readonly defaultNameFromUrl: (url: string) => Effect.Effect<string, AuthError>;
+    readonly defaultNameForLocal: () => Effect.Effect<string, AuthError>;
+    readonly listEnvironments: () => Effect.Effect<readonly AuthEnvironmentListItem[], AuthError>;
+    readonly useEnvironment: (name: string) => Effect.Effect<AuthUseResult, AuthError>;
+    readonly unpairEnvironment: (input: {
+        readonly name: string;
+    }) => Effect.Effect<AuthUnpairResult, AuthError>;
+    readonly resolveUnpairTarget: (input: {
+        readonly name?: string;
+    }) => Effect.Effect<string, AuthError>;
+    readonly status: () => Effect.Effect<AuthStatusResult, AuthError>;
     readonly issueWebSocketTicket: () => Effect.Effect<AuthWebSocketTicketResult, AuthError>;
 }>;
 export declare class T3Auth extends T3Auth_base {

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

@@ -1,13 +1,44 @@
 import type { AuthBearerBootstrapResult } from "./schema.ts";
+import type { AuthSessionState } from "./schema.ts";
 export type AuthSessionRole = AuthBearerBootstrapResult["role"];
 export type PairingUrl = {
     readonly baseUrl: string;
     readonly credential: string;
 };
 export type AuthConfigInput = {
+    readonly name: string;
     readonly url: string;
     readonly token: string;
-    readonly local?: boolean;
+    readonly local: boolean;
+    readonly makeDefault?: boolean;
+};
+export type PersistEnvironmentInput = {
+    readonly name: string;
+    readonly url: string;
+    readonly token: string;
+    readonly local: boolean;
+    readonly replace?: boolean;
+    readonly allowReplace: boolean;
+};
+export type AuthResolvedConfig = {
+    readonly url: string;
+    readonly token: string;
+    readonly source: "env" | "config";
+    readonly local: boolean;
+    readonly environment?: string;
+};
+export type AuthEnvironmentSummary = {
+    readonly name: string;
+    readonly url: string;
+    readonly local: boolean;
+    readonly default: boolean;
+};
+export type AuthStatusResult = {
+    readonly config: AuthResolvedConfig;
+    readonly session: AuthSessionState;
+};
+export type AuthEnvironmentListItem = AuthEnvironmentSummary & {
+    readonly active: boolean;
 };
 export type PairResult = {
     readonly url: string;
@@ -42,3 +73,11 @@ export type LocalAuthResult = {
     readonly source: "local";
     readonly baseDir: string;
 };
+export type AuthUseResult = {
+    readonly name: string;
+    readonly default: true;
+};
+export type AuthUnpairResult = {
+    readonly name: string;
+    readonly removed: true;
+};

package/dist/src/cli/env/flag.d.ts

@@ -0,0 +1,2 @@
+import { GlobalFlag } from "effect/unstable/cli";
+export declare const cliEnvironmentSetting: GlobalFlag.Setting<"environment", import("effect/Option").Option<string>>;

package/dist/src/cli/env/index.d.ts

@@ -0,0 +1,2 @@
+export { cliEnvironmentSetting } from "./flag.ts";
+export * as Selection from "./selection-layer.ts";

package/dist/src/cli/env/selection-layer.d.ts

@@ -0,0 +1,3 @@
+import * as Layer from "effect/Layer";
+import { T3ConfigSelection } from "../../config/selection/service.ts";
+export declare const layer: Layer.Layer<T3ConfigSelection, import("effect/Config").ConfigError, never>;

package/dist/src/cli/flags.d.ts

@@ -3,6 +3,11 @@ export declare const projectFlag: Flag.Flag<import("effect/Option").Option<strin
 export declare const threadFlag: Flag.Flag<import("effect/Option").Option<string>>;
 export declare const worktreeFlag: Flag.Flag<import("effect/Option").Option<string>>;
 export declare const projectPathFlag: Flag.Flag<string>;
+export declare const yesFlag: Flag.Flag<boolean>;
+export declare const replaceFlag: Flag.Flag<boolean>;
+export declare const envNameFlag: Flag.Flag<import("effect/Option").Option<string>>;
+export declare const forceFlag: Flag.Flag<boolean>;
+export declare const selfActionForceFlag: Flag.Flag<boolean>;
 export declare const formatFlag: Flag.Flag<"auto" | "human" | "json">;
 export declare const threadFormatFlag: Flag.Flag<"auto" | "human" | "json" | "ndjson">;
 export declare const waitFormatFlag: Flag.Flag<"auto" | "human" | "ndjson">;

package/dist/src/cli/format/index.d.ts

@@ -0,0 +1 @@
+export { resolveOutputFormat, canRenderLiveTerminal, isInteractiveHumanTerminal, isAgentEnvironment, humanJsonFormatChoices, humanNdjsonFormatChoices, humanJsonNdjsonFormatChoices, type HumanJsonFormat, type HumanNdjsonFormat, type HumanJsonNdjsonFormat, } from "./output.ts";

package/dist/src/cli/format/output.d.ts

@@ -0,0 +1,12 @@
+import type { T3CliEnvShape } from "../../config/env/env.ts";
+import type { CliRuntime } from "../runtime/service.ts";
+export declare const humanJsonFormatChoices: readonly ["auto", "human", "json"];
+export declare const humanNdjsonFormatChoices: readonly ["auto", "human", "ndjson"];
+export declare const humanJsonNdjsonFormatChoices: readonly ["auto", "human", "json", "ndjson"];
+export type HumanJsonFormat = (typeof humanJsonFormatChoices)[number];
+export type HumanNdjsonFormat = (typeof humanNdjsonFormatChoices)[number];
+export type HumanJsonNdjsonFormat = (typeof humanJsonNdjsonFormatChoices)[number];
+export declare function resolveOutputFormat<T extends "json" | "ndjson">(format: "auto" | "human" | T, cliRuntime: CliRuntime["Service"], t3CliEnv: T3CliEnvShape, nonHumanFormat: T): "human" | T;
+export declare function canRenderLiveTerminal(cliRuntime: CliRuntime["Service"], t3CliEnv: T3CliEnvShape): boolean;
+export declare function isInteractiveHumanTerminal(cliRuntime: CliRuntime["Service"], t3CliEnv: T3CliEnvShape): boolean;
+export declare function isAgentEnvironment(t3CliEnv: T3CliEnvShape): boolean;

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

@@ -1 +1,5 @@
 export { formatFlag, modelFlags, projectFlag, projectPathFlag, threadFlag, threadFormatFlag, waitFormatFlag, worktreeFlag, } from "./flags.ts";
+export * as Env from "./env/index.ts";
+export * as Runtime from "./runtime/index.ts";
+export { resolveCommandProjectRef, resolveProjectRef, resolveThreadId, resolveWorktreePath, } from "./scope/index.ts";
+export { resolveOutputFormat, canRenderLiveTerminal, isInteractiveHumanTerminal, isAgentEnvironment, humanJsonFormatChoices, humanNdjsonFormatChoices, humanJsonNdjsonFormatChoices, type HumanJsonFormat, type HumanNdjsonFormat, type HumanJsonNdjsonFormat, } from "./format/index.ts";

package/dist/src/cli/runtime/index.d.ts

@@ -0,0 +1 @@
+export { CliRuntime, layer } from "./service.ts";

package/dist/src/cli/runtime/service.d.ts

@@ -0,0 +1,16 @@
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+declare const CliRuntime_base: Context.ServiceClass<CliRuntime, "t3cli/CliRuntime", {
+    readonly cwd: string;
+    readonly stdoutIsTTY: boolean;
+    readonly stderrIsTTY: boolean;
+}>;
+export declare class CliRuntime extends CliRuntime_base {
+    static layerTest: (input?: {
+        readonly cwd?: string;
+        readonly stdoutIsTTY?: boolean;
+        readonly stderrIsTTY?: boolean;
+    }) => Layer.Layer<CliRuntime, never, never>;
+}
+export declare const layer: Layer.Layer<CliRuntime, never, never>;
+export {};

package/dist/src/{scope → cli/scope}/resolve.d.ts

@@ -1,19 +1,20 @@
+import type { T3CliEnvScope } from "../../config/env/env.ts";
 export declare function resolveProjectRef(input: {
     readonly value: string | undefined;
-    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly scope: T3CliEnvScope;
 }): string | undefined;
 export declare function resolveCommandProjectRef(input: {
     readonly value: string | undefined;
-    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly scope: T3CliEnvScope;
     readonly cwd: string;
     readonly isLocal?: boolean;
 }): string | undefined;
 export declare function resolveWorktreePath(input: {
     readonly value: string | undefined;
-    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly scope: T3CliEnvScope;
     readonly inferred?: string;
 }): string | undefined;
 export declare function resolveThreadId(input: {
     readonly value: string | undefined;
-    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly scope: T3CliEnvScope;
 }): string | undefined;

package/dist/src/config/config.d.ts

@@ -0,0 +1,49 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import { T3CredentialCrypto } from "./credential/service.ts";
+import { ConfigError } from "./error.ts";
+import { T3ConfigSelection } from "./selection/service.ts";
+import type { EnvironmentSummary, ResolvedConfig, UpsertEnvironmentInput } from "./types.ts";
+declare const T3Config_base: Context.ServiceClass<T3Config, "t3cli/T3Config", {
+    readonly resolve: () => Effect.Effect<ResolvedConfig, ConfigError>;
+    readonly resolveActiveEnvironmentName: () => Effect.Effect<string | undefined, ConfigError>;
+    readonly listEnvironments: () => Effect.Effect<readonly EnvironmentSummary[], ConfigError>;
+    readonly upsertEnvironment: (input: UpsertEnvironmentInput) => Effect.Effect<void, ConfigError>;
+    readonly setDefaultEnvironment: (name: string) => Effect.Effect<void, ConfigError>;
+    readonly removeEnvironment: (name: string) => Effect.Effect<void, ConfigError>;
+    readonly hasEnvironment: (name: string) => Effect.Effect<boolean, ConfigError>;
+    readonly getDefaultEnvironmentName: () => Effect.Effect<string | undefined, ConfigError>;
+}>;
+export declare class T3Config extends T3Config_base {
+}
+export declare const make: () => Effect.Effect<{
+    readonly resolve: () => Effect.Effect<{
+        url: string;
+        token: string;
+        source: "env";
+        local: false;
+    } | {
+        url: string;
+        token: string;
+        source: "config";
+        local: boolean;
+        environment: string;
+    }, ConfigError, never>;
+    readonly resolveActiveEnvironmentName: () => Effect.Effect<string | undefined, ConfigError, never>;
+    readonly listEnvironments: () => Effect.Effect<{
+        name: string;
+        url: string;
+        local: boolean;
+        default: boolean;
+    }[], ConfigError, never>;
+    readonly upsertEnvironment: (input: UpsertEnvironmentInput) => Effect.Effect<void, ConfigError, never>;
+    readonly setDefaultEnvironment: (name: string) => Effect.Effect<void, ConfigError, never>;
+    readonly removeEnvironment: (name: string) => Effect.Effect<void, ConfigError, never>;
+    readonly hasEnvironment: (name: string) => Effect.Effect<boolean, ConfigError, never>;
+    readonly getDefaultEnvironmentName: () => Effect.Effect<string | undefined, ConfigError, never>;
+}, import("effect/Config").ConfigError, Path.Path | FileSystem.FileSystem | T3CredentialCrypto | T3ConfigSelection>;
+export declare const layer: Layer.Layer<T3Config, import("effect/Config").ConfigError, Path.Path | FileSystem.FileSystem | T3CredentialCrypto | T3ConfigSelection>;
+export {};

package/dist/src/config/credential/cipher-node.d.ts

@@ -0,0 +1,3 @@
+import * as Layer from "effect/Layer";
+import { T3CredentialCipher } from "./cipher.ts";
+export declare const layerNode: Layer.Layer<T3CredentialCipher, never, never>;

package/dist/src/config/credential/cipher-web.d.ts

@@ -0,0 +1,3 @@
+import * as Layer from "effect/Layer";
+import { T3CredentialCipher } from "./cipher.ts";
+export declare const layerWeb: Layer.Layer<T3CredentialCipher, never, never>;