t3code-cli 0.5.1 → 0.6.0

package/dist/layout.js

@@ -0,0 +1,2 @@
+import { n as resolveT3BaseDir, t as readT3LayoutFromNodeProcess } from "./base-dir-R12OMDso.js";
+export { readT3LayoutFromNodeProcess, resolveT3BaseDir };

package/dist/orchestration.js

@@ -0,0 +1,2 @@
+import { l as T3OrchestrationLayer, u as T3Orchestration } from "./layer-DIg0RxSO.js";
+export { T3Orchestration, T3OrchestrationLayer };

package/dist/rpc.js

@@ -0,0 +1,2 @@
+import { t as RpcError } from "./error-B2t1bAP9.js";
+export { RpcError };

package/dist/runtime.js

@@ -0,0 +1,3 @@
+import { a as T3AuthTransportLayer, c as T3LocalAuthTokenLayer, i as T3AuthPairingLayer, l as T3OrchestrationLayer, n as AuthAppLayer, o as T3LocalAuthLayer, r as T3AuthLayer, s as T3LocalAuthOriginLayer, t as AppLayer } from "./layer-DIg0RxSO.js";
+import { t as NodeEnvironmentLive } from "./layer-DHhKS5jd.js";
+export { AppLayer, AuthAppLayer, NodeEnvironmentLive, T3AuthLayer, T3AuthPairingLayer, T3AuthTransportLayer, T3LocalAuthLayer, T3LocalAuthOriginLayer, T3LocalAuthTokenLayer, T3OrchestrationLayer };

package/dist/scope-GycYiJ54.js

@@ -0,0 +1,29 @@
+//#region src/scope/resolve.ts
+function resolveProjectRef(input) {
+	if (input.value !== void 0 && input.value.length > 0) return input.value;
+	const fromRoot = input.env.T3CODE_PROJECT_ROOT;
+	if (fromRoot !== void 0 && fromRoot.length > 0) return fromRoot;
+	const fromId = input.env.T3CODE_PROJECT_ID;
+	if (fromId !== void 0 && fromId.length > 0) return fromId;
+}
+function resolveCommandProjectRef(input) {
+	const explicit = resolveProjectRef({
+		value: input.value,
+		env: input.env
+	});
+	if (explicit !== void 0) return explicit;
+	if (input.isLocal ?? false) return input.cwd;
+}
+function resolveWorktreePath(input) {
+	if (input.value !== void 0 && input.value.length > 0) return input.value;
+	const fromEnv = input.env.T3CODE_WORKTREE_PATH;
+	if (fromEnv !== void 0 && fromEnv.length > 0) return fromEnv;
+	return input.inferred;
+}
+function resolveThreadId(input) {
+	if (input.value !== void 0 && input.value.length > 0) return input.value;
+	const fromEnv = input.env.T3CODE_THREAD_ID;
+	if (fromEnv !== void 0 && fromEnv.length > 0) return fromEnv;
+}
+//#endregion
+export { resolveWorktreePath as i, resolveProjectRef as n, resolveThreadId as r, resolveCommandProjectRef as t };

package/dist/scope.js

@@ -0,0 +1,2 @@
+import { i as resolveWorktreePath, n as resolveProjectRef, r as resolveThreadId, t as resolveCommandProjectRef } from "./scope-GycYiJ54.js";
+export { resolveCommandProjectRef, resolveProjectRef, resolveThreadId, resolveWorktreePath };

package/dist/service-CLmRO2Dp.js

@@ -0,0 +1,8 @@
+import { n as Service } from "./Context-DueQ9iMH.js";
+//#region src/config/service.ts
+var T3Config = class extends Service()("t3cli/T3Config") {};
+//#endregion
+//#region src/environment/service.ts
+var Environment = class extends Service()("t3cli/Environment") {};
+//#endregion
+export { T3Config as n, Environment as t };

package/dist/service-ybOWV9pL.js

@@ -0,0 +1,5 @@
+import { n as Service } from "./Context-DueQ9iMH.js";
+//#region src/application/service.ts
+var T3Application = class extends Service()("t3cli/T3Application") {};
+//#endregion
+export { T3Application as t };

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

@@ -0,0 +1,3 @@
+export { T3Application } from "./service.ts";
+export type { SendThreadInput, StartThreadInput, StartThreadPolicy, WaitEvent } from "./service.ts";
+export type { ApplicationError } from "./error.ts";

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

@@ -87,7 +87,7 @@ export declare const makeT3Application: () => Effect.Effect<{
             readonly hasPendingUserInput: boolean;
             readonly hasActionableProposedPlan: boolean;
         }[];
-    }, import("../rpc/error.ts").RpcError, never>;
+    }, import("../domain/error.ts").ProjectLookupError | import("../rpc/error.ts").RpcError, never>;
     getThreadMessages: (threadId: string) => Effect.Effect<{
         readonly id: string & import("effect/Brand").Brand<"ThreadId">;
         readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
@@ -461,7 +461,7 @@ export declare const makeT3Application: () => Effect.Effect<{
                 readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
             } | null;
         };
-    }, import("../domain/error.ts").ModelSelectionError | import("../domain/error.ts").ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
+    }, import("../domain/error.ts").ProjectLookupError | import("../domain/error.ts").ModelSelectionError | import("../domain/error.ts").ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
     watchThread: (threadId: string) => import("effect/Stream").Stream<import("./service.ts").WaitEvent, import("../domain/error.ts").ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
     waitForThread: (threadId: string) => Effect.Effect<{
         readonly id: string & import("effect/Brand").Brand<"ThreadId">;
@@ -772,5 +772,5 @@ export declare const makeT3Application: () => Effect.Effect<{
             readonly output: string | null;
         };
     }[], import("../rpc/error.ts").RpcError, never>;
-}, never, import("../index.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("../orchestration/service.ts").T3Orchestration>;
-export declare const T3ApplicationLive: Layer.Layer<T3Application, never, import("../index.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("../orchestration/service.ts").T3Orchestration>;
+}, never, import("../orchestration/service.ts").T3Orchestration | import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto>;
+export declare const T3ApplicationLive: Layer.Layer<T3Application, never, import("../orchestration/service.ts").T3Orchestration | import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto>;

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

@@ -133,4 +133,4 @@ export declare const makeProjectApplication: () => Effect.Effect<{
             } | null | undefined;
         };
     }, ProjectCreateVisibilityError | import("../rpc/error.ts").RpcError, never>;
-}, never, Environment | Path.Path | Crypto.Crypto | T3Orchestration>;
+}, never, T3Orchestration | Environment | Path.Path | Crypto.Crypto>;

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

@@ -4,7 +4,7 @@ import type * as Stream from "effect/Stream";
 import type { DispatchResult, ModelSelection, OrchestrationMessage, OrchestrationProjectShell, OrchestrationShellSnapshot, OrchestrationThread, OrchestrationThreadShell, ServerProvider } from "#t3tools/contracts";
 import type { ApplicationError } from "./error.ts";
 export type StartThreadInput = {
-    readonly projectRef: string;
+    readonly projectRef?: string;
     readonly message: string;
     readonly title?: string;
     readonly provider?: string;

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

@@ -3,7 +3,7 @@ import * as Effect from "effect/Effect";
 import * as Path from "effect/Path";
 import { Environment } from "../environment/service.ts";
 import { T3Orchestration } from "../orchestration/service.ts";
-import { ThreadSessionError } from "../domain/error.ts";
+import { ProjectLookupError, ThreadSessionError } from "../domain/error.ts";
 import { type StartThreadInput } from "./service.ts";
 import type { SendThreadInput } from "./service.ts";
 export declare const makeThreadApplication: () => Effect.Effect<{
@@ -92,7 +92,7 @@ export declare const makeThreadApplication: () => Effect.Effect<{
             readonly hasPendingUserInput: boolean;
             readonly hasActionableProposedPlan: boolean;
         }[];
-    }, import("../rpc/error.ts").RpcError, never>;
+    }, ProjectLookupError | import("../rpc/error.ts").RpcError, never>;
     getThreadMessages: (threadId: string) => Effect.Effect<{
         readonly id: string & import("effect/Brand").Brand<"ThreadId">;
         readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
@@ -466,7 +466,7 @@ export declare const makeThreadApplication: () => Effect.Effect<{
                 readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
             } | null;
         };
-    }, import("../domain/error.ts").ModelSelectionError | ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
+    }, 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>;
     waitForThread: (threadId: string) => Effect.Effect<{
         readonly id: string & import("effect/Brand").Brand<"ThreadId">;
@@ -560,4 +560,4 @@ export declare const makeThreadApplication: () => Effect.Effect<{
             readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
         } | null;
     }, ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
-}, never, Environment | Path.Path | Crypto.Crypto | T3Orchestration>;
+}, never, T3Orchestration | Environment | Path.Path | Crypto.Crypto>;

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

@@ -0,0 +1,10 @@
+export { T3Auth } from "./service.ts";
+export { T3AuthLive, makeT3Auth } from "./layer.ts";
+export { T3LocalAuth, T3LocalAuthLive, makeT3LocalAuth } from "./local.ts";
+export { T3LocalAuthOrigin, T3LocalAuthOriginLive, makeT3LocalAuthOrigin } from "./local-origin.ts";
+export { T3LocalAuthToken, T3LocalAuthTokenLive, makeT3LocalAuthToken } from "./local-token.ts";
+export { T3AuthPairing, T3AuthPairingLive, makeT3AuthPairing, parsePairingUrl } from "./pairing.ts";
+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";

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

@@ -1,7 +1,5 @@
-import type * as Path from "effect/Path";
-import type { EnvironmentShape } from "../environment/service.ts";
-export declare function resolveLocalBaseDir(input: {
-    readonly baseDir: string | undefined;
-    readonly environment: EnvironmentShape;
-    readonly path: Path.Path;
-}): string;
+import * as Effect from "effect/Effect";
+import { Environment } from "../environment/service.ts";
+export declare const resolveLocalBaseDir: (input: {
+    readonly baseDir?: string | undefined;
+}) => Effect.Effect<string, never, Environment | import("effect/Path").Path>;

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

@@ -21,6 +21,6 @@ export declare const makeT3LocalAuthToken: () => Effect.Effect<{
         source: "local";
         baseDir: string;
     }, AuthLocalError, never>;
-}, never, Environment | Path.Path | FileSystem.FileSystem | SqlClientFactory | Crypto.Crypto>;
-export declare const T3LocalAuthTokenLive: Layer.Layer<T3LocalAuthToken, never, Environment | Path.Path | FileSystem.FileSystem | SqlClientFactory | Crypto.Crypto>;
+}, 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>;
 export {};

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

@@ -7,6 +7,7 @@ export type PairingUrl = {
 export type AuthConfigInput = {
     readonly url: string;
     readonly token: string;
+    readonly local?: boolean;
 };
 export type PairResult = {
     readonly url: string;

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

@@ -0,0 +1,15 @@
+import { Flag } from "effect/unstable/cli";
+export declare const projectFlag: Flag.Flag<import("effect/Option").Option<string>>;
+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 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">;
+export declare const modelFlags: {
+    readonly option: Flag.Flag<import("effect/Option").Option<Record<string, string>>>;
+    readonly reasoningEffort: Flag.Flag<import("effect/Option").Option<string>>;
+    readonly effort: Flag.Flag<import("effect/Option").Option<string>>;
+    readonly fastMode: Flag.Flag<import("effect/Option").Option<boolean>>;
+    readonly thinking: Flag.Flag<import("effect/Option").Option<boolean>>;
+};

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

@@ -0,0 +1 @@
+export { formatFlag, modelFlags, projectFlag, projectPathFlag, threadFlag, threadFormatFlag, waitFormatFlag, worktreeFlag, } from "./flags.ts";

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

@@ -0,0 +1,9 @@
+import type { EnvironmentShape } from "../environment/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, environment: EnvironmentShape, nonHumanFormat: T): "human" | T;
+export declare function canRenderLiveTerminal(environment: EnvironmentShape): boolean;

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

@@ -0,0 +1,5 @@
+export { T3Config } from "./service.ts";
+export type { ResolvedConfig, StoredConfig } from "./service.ts";
+export { T3ConfigLive, makeT3Config } from "./layer.ts";
+export { ConfigError, UrlError } from "./error.ts";
+export type { ConfigServiceError } from "./error.ts";

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

@@ -9,12 +9,14 @@ export declare const makeT3Config: () => Effect.Effect<{
     readStored: () => Effect.Effect<{
         readonly url?: string;
         readonly token?: string;
+        readonly local?: boolean;
     }, ConfigError, never>;
     writeStored: (config: StoredConfig) => Effect.Effect<void, ConfigError, never>;
     resolve: () => Effect.Effect<{
         url: string;
         token: string;
         source: "config" | "env";
+        local: boolean;
     }, import("./error.ts").UrlError | ConfigError, never>;
 }, never, Environment | Path.Path | FileSystem.FileSystem>;
 export declare const T3ConfigLive: Layer.Layer<T3Config, never, Environment | Path.Path | FileSystem.FileSystem>;

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

@@ -4,11 +4,13 @@ import type { ConfigError, ConfigServiceError } from "./error.ts";
 export type StoredConfig = {
     readonly url?: string;
     readonly token?: string;
+    readonly local?: boolean;
 };
 export type ResolvedConfig = {
     readonly url: string;
     readonly token: string;
     readonly source: "env" | "config";
+    readonly local: boolean;
 };
 declare const T3Config_base: Context.ServiceClass<T3Config, "t3cli/T3Config", {
     readonly readStored: () => Effect.Effect<StoredConfig, ConfigError>;

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

@@ -0,0 +1,5 @@
+export { T3CodeConnectionError } from "./error.ts";
+export { T3CodeRpcLayer, makeT3CodeRpcLayer } from "./layer.ts";
+export { T3CodeNodeRpcLayer } from "./node.ts";
+export { T3CodeConnectionProvider, T3CodeConnectionProviderLive, makeT3CodeConnectionProvider, } from "./service.ts";
+export type { T3CodeAuth, T3CodeConnection, T3CodeOrigin } from "./type.ts";

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

@@ -0,0 +1 @@
+export type { OrchestrationMessage, OrchestrationProjectShell, OrchestrationShellSnapshot, OrchestrationThread, OrchestrationThreadShell, ServerProvider, } from "#t3tools/contracts";

package/dist/src/domain/helpers.d.ts

@@ -1,38 +1,170 @@
-import type * as Path from "effect/Path";
+import * as Effect from "effect/Effect";
+import * as Path from "effect/Path";
 import type { OrchestrationProjectShell, OrchestrationShellSnapshot } from "#t3tools/contracts";
-export declare function resolveProject(snapshot: OrchestrationShellSnapshot, ref: string, path: Path.Path, cwd: string): {
-    readonly id: string & import("effect/Brand").Brand<"ProjectId">;
-    readonly title: string;
-    readonly workspaceRoot: string;
-    readonly defaultModelSelection: {
-        readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
-        readonly model: string;
-        readonly options?: readonly {
+export type ResolvedProjectScope = {
+    readonly project: OrchestrationProjectShell;
+    readonly inferredWorktreePath?: string;
+};
+export declare const resolveProjectScope: (snapshot: {
+    readonly snapshotSequence: number;
+    readonly projects: readonly {
+        readonly id: string & import("effect/Brand").Brand<"ProjectId">;
+        readonly title: string;
+        readonly workspaceRoot: string;
+        readonly defaultModelSelection: {
+            readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+            readonly model: string;
+            readonly options?: readonly {
+                readonly id: string;
+                readonly value: string | boolean;
+            }[];
+        } | null;
+        readonly scripts: readonly {
             readonly id: string;
-            readonly value: string | boolean;
+            readonly name: string;
+            readonly command: string;
+            readonly icon: "play" | "test" | "lint" | "configure" | "build" | "debug";
+            readonly runOnWorktreeCreate: boolean;
         }[];
-    } | null;
-    readonly scripts: readonly {
-        readonly id: string;
-        readonly name: string;
-        readonly command: string;
-        readonly icon: "play" | "test" | "lint" | "configure" | "build" | "debug";
-        readonly runOnWorktreeCreate: boolean;
+        readonly createdAt: string;
+        readonly updatedAt: string;
+        readonly repositoryIdentity?: {
+            readonly canonicalKey: string;
+            readonly locator: {
+                readonly source: "git-remote";
+                readonly remoteName: string;
+                readonly remoteUrl: string;
+            };
+            readonly rootPath?: string;
+            readonly displayName?: string;
+            readonly provider?: string;
+            readonly owner?: string;
+            readonly name?: string;
+        } | null | undefined;
     }[];
-    readonly createdAt: string;
-    readonly updatedAt: string;
-    readonly repositoryIdentity?: {
-        readonly canonicalKey: string;
-        readonly locator: {
-            readonly source: "git-remote";
-            readonly remoteName: string;
-            readonly remoteUrl: string;
+    readonly threads: readonly {
+        readonly id: string & import("effect/Brand").Brand<"ThreadId">;
+        readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+        readonly title: string;
+        readonly modelSelection: {
+            readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+            readonly model: string;
+            readonly options?: readonly {
+                readonly id: string;
+                readonly value: string | boolean;
+            }[];
         };
-        readonly rootPath?: string;
-        readonly displayName?: string;
-        readonly provider?: string;
-        readonly owner?: string;
-        readonly name?: string;
-    } | null | undefined;
-};
+        readonly runtimeMode: "approval-required" | "auto-accept-edits" | "full-access";
+        readonly interactionMode: "default" | "plan";
+        readonly branch: string | null;
+        readonly worktreePath: string | null;
+        readonly latestTurn: {
+            readonly turnId: string & import("effect/Brand").Brand<"TurnId">;
+            readonly state: "error" | "running" | "interrupted" | "completed";
+            readonly requestedAt: string;
+            readonly startedAt: string | null;
+            readonly completedAt: string | null;
+            readonly assistantMessageId: (string & import("effect/Brand").Brand<"MessageId">) | null;
+            readonly sourceProposedPlan?: {
+                readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+                readonly planId: string;
+            } | undefined;
+        } | null;
+        readonly createdAt: string;
+        readonly updatedAt: string;
+        readonly archivedAt: string | null;
+        readonly session: {
+            readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+            readonly status: "error" | "idle" | "starting" | "running" | "ready" | "interrupted" | "stopped";
+            readonly providerName: string | null;
+            readonly runtimeMode: "approval-required" | "auto-accept-edits" | "full-access";
+            readonly activeTurnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
+            readonly lastError: string | null;
+            readonly updatedAt: string;
+            readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
+        } | null;
+        readonly latestUserMessageAt: string | null;
+        readonly hasPendingApprovals: boolean;
+        readonly hasPendingUserInput: boolean;
+        readonly hasActionableProposedPlan: boolean;
+    }[];
+    readonly updatedAt: string;
+}, input: {
+    readonly ref: string;
+    readonly cwd: string;
+}) => Effect.Effect<{
+    project: {
+        readonly id: string & import("effect/Brand").Brand<"ProjectId">;
+        readonly title: string;
+        readonly workspaceRoot: string;
+        readonly defaultModelSelection: {
+            readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+            readonly model: string;
+            readonly options?: readonly {
+                readonly id: string;
+                readonly value: string | boolean;
+            }[];
+        } | null;
+        readonly scripts: readonly {
+            readonly id: string;
+            readonly name: string;
+            readonly command: string;
+            readonly icon: "play" | "test" | "lint" | "configure" | "build" | "debug";
+            readonly runOnWorktreeCreate: boolean;
+        }[];
+        readonly createdAt: string;
+        readonly updatedAt: string;
+        readonly repositoryIdentity?: {
+            readonly canonicalKey: string;
+            readonly locator: {
+                readonly source: "git-remote";
+                readonly remoteName: string;
+                readonly remoteUrl: string;
+            };
+            readonly rootPath?: string;
+            readonly displayName?: string;
+            readonly provider?: string;
+            readonly owner?: string;
+            readonly name?: string;
+        } | null | undefined;
+    };
+    inferredWorktreePath?: never;
+} | {
+    project: {
+        readonly id: string & import("effect/Brand").Brand<"ProjectId">;
+        readonly title: string;
+        readonly workspaceRoot: string;
+        readonly defaultModelSelection: {
+            readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+            readonly model: string;
+            readonly options?: readonly {
+                readonly id: string;
+                readonly value: string | boolean;
+            }[];
+        } | null;
+        readonly scripts: readonly {
+            readonly id: string;
+            readonly name: string;
+            readonly command: string;
+            readonly icon: "play" | "test" | "lint" | "configure" | "build" | "debug";
+            readonly runOnWorktreeCreate: boolean;
+        }[];
+        readonly createdAt: string;
+        readonly updatedAt: string;
+        readonly repositoryIdentity?: {
+            readonly canonicalKey: string;
+            readonly locator: {
+                readonly source: "git-remote";
+                readonly remoteName: string;
+                readonly remoteUrl: string;
+            };
+            readonly rootPath?: string;
+            readonly displayName?: string;
+            readonly provider?: string;
+            readonly owner?: string;
+            readonly name?: string;
+        } | null | undefined;
+    };
+    inferredWorktreePath: string;
+} | undefined, never, Path.Path>;
 export declare function findProjectById(snapshot: OrchestrationShellSnapshot, projectId: string): OrchestrationProjectShell | null;

package/dist/src/index.d.ts

@@ -1,28 +1,4 @@
-export { T3Application } from "./application/service.ts";
-export type { SendThreadInput, StartThreadInput, StartThreadPolicy, WaitEvent, } from "./application/service.ts";
-export type { ApplicationError } from "./application/error.ts";
-export { T3Auth } from "./auth/service.ts";
-export { T3AuthLive, makeT3Auth } from "./auth/layer.ts";
-export { T3LocalAuth, T3LocalAuthLive, makeT3LocalAuth } from "./auth/local.ts";
-export { T3LocalAuthOrigin, T3LocalAuthOriginLive, makeT3LocalAuthOrigin, } from "./auth/local-origin.ts";
-export { T3LocalAuthToken, T3LocalAuthTokenLive, makeT3LocalAuthToken, } from "./auth/local-token.ts";
-export { T3AuthPairing, T3AuthPairingLive, makeT3AuthPairing, parsePairingUrl, } from "./auth/pairing.ts";
-export { AuthConfigError, AuthLocalDatabaseError, AuthLocalError, AuthLocalSecretError, AuthLocalSigningError, AuthPairingUrlError, AuthTransportError, } from "./auth/error.ts";
-export type { AuthError } from "./auth/error.ts";
-export type { AuthSessionState, AuthWebSocketTicketResult } from "./auth/schema.ts";
-export type { AuthConfigInput, AuthSessionRole, LocalAuthInput, LocalAuthOriginInput, LocalAuthResult, LocalAuthTokenInput, LocalAuthTokenResult, PairingUrl, PairResult, } from "./auth/type.ts";
-export { T3Config } from "./config/service.ts";
-export type { ResolvedConfig, StoredConfig } from "./config/service.ts";
-export { T3ConfigLive, makeT3Config } from "./config/layer.ts";
-export { ConfigError, UrlError } from "./config/error.ts";
-export type { ConfigServiceError } from "./config/error.ts";
-export { makeT3CodeConnectionProvider, makeT3CodeRpcLayer, T3CodeConnectionProvider, T3CodeConnectionProviderLive, T3CodeNodeRpcLayer, T3CodeRpcLayer, T3CodeConnectionError, } from "./connection.ts";
-export type { T3CodeAuth, T3CodeConnection, T3CodeOrigin } from "./connection.ts";
-export { Environment } from "./environment/service.ts";
-export type { EnvironmentShape } from "./environment/service.ts";
-export { NodeEnvironmentLive } from "./environment/layer.ts";
-export { AppLayer, AuthAppLayer, T3AuthLayer, T3AuthPairingLayer, T3AuthTransportLayer, T3LocalAuthLayer, T3LocalAuthOriginLayer, T3LocalAuthTokenLayer, } from "./runtime.ts";
-export { SqlClientFactory } from "./sql/service.ts";
-export type { SqlClientFactoryShape, SqliteClientConfig } from "./sql/service.ts";
-export { NodeSqlClientFactoryLive, NodeSqliteClientLive, makeNodeSqliteClient, } from "./sql/node-sqlite-client.ts";
-export type { OrchestrationMessage, OrchestrationProjectShell, OrchestrationShellSnapshot, OrchestrationThread, OrchestrationThreadShell, ServerProvider, } from "#t3tools/contracts";
+export { T3Application } from "./application/index.ts";
+export type { SendThreadInput, StartThreadInput, StartThreadPolicy, WaitEvent, } from "./application/index.ts";
+export type { ApplicationError } from "./application/index.ts";
+export { AppLayer, AuthAppLayer } from "./runtime/index.ts";

package/dist/src/layout/base-dir.d.ts

@@ -0,0 +1,12 @@
+import * as Effect from "effect/Effect";
+import * as Path from "effect/Path";
+export type T3Layout = {
+    readonly cwd: string;
+    readonly homeDir: string;
+    readonly t3codeHome?: string | undefined;
+};
+export declare function readT3LayoutFromNodeProcess(): T3Layout;
+export declare const resolveT3BaseDir: (input: {
+    readonly layout: T3Layout;
+    readonly baseDir?: string | undefined;
+}) => Effect.Effect<string, never, Path.Path>;

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

@@ -0,0 +1 @@
+export { readT3LayoutFromNodeProcess, resolveT3BaseDir, type T3Layout } from "./base-dir.ts";

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

@@ -0,0 +1,2 @@
+export { T3Orchestration, type OpenThread, type Orchestration, type OrchestrationError, } from "./service.ts";
+export { T3OrchestrationLayer } from "../runtime/layer.ts";

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

@@ -0,0 +1 @@
+export { RpcError, type OrchestrationError } from "./error.ts";

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

@@ -0,0 +1,2 @@
+export { AppLayer, AuthAppLayer, T3AuthLayer, T3AuthPairingLayer, T3AuthTransportLayer, T3LocalAuthLayer, T3LocalAuthOriginLayer, T3LocalAuthTokenLayer, T3OrchestrationLayer, } from "./layer.ts";
+export { NodeEnvironmentLive } from "../environment/layer.ts";

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

@@ -0,0 +1,11 @@
+import * as Layer from "effect/Layer";
+import { T3Config } from "../config/service.ts";
+export declare const T3AuthTransportLayer: Layer.Layer<import("../auth/transport.ts").T3AuthTransport, never, never>;
+export declare const T3LocalAuthOriginLayer: Layer.Layer<import("../auth/local-origin.ts").T3LocalAuthOrigin, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/FileSystem").FileSystem>;
+export declare const T3LocalAuthTokenLayer: Layer.Layer<import("../auth/local-token.ts").T3LocalAuthToken, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("effect/FileSystem").FileSystem>;
+export declare const T3LocalAuthLayer: Layer.Layer<import("../auth/local.ts").T3LocalAuth, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("effect/FileSystem").FileSystem>;
+export declare const T3AuthPairingLayer: Layer.Layer<import("../auth/pairing.ts").T3AuthPairing, never, never>;
+export declare const T3AuthLayer: Layer.Layer<import("../auth/service.ts").T3Auth, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("effect/FileSystem").FileSystem>;
+export declare const T3OrchestrationLayer: Layer.Layer<import("../orchestration/service.ts").T3Orchestration, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/FileSystem").FileSystem>;
+export declare const AuthAppLayer: Layer.Layer<T3Config | import("../auth/service.ts").T3Auth, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("effect/FileSystem").FileSystem>;
+export declare const AppLayer: Layer.Layer<import("../index.ts").T3Application | import("../orchestration/service.ts").T3Orchestration | T3Config | import("../auth/service.ts").T3Auth | import("../rpc/service.ts").T3Rpc, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("effect/FileSystem").FileSystem>;

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

@@ -0,0 +1 @@
+export { resolveCommandProjectRef, resolveProjectRef, resolveThreadId, resolveWorktreePath, } from "./resolve.ts";

package/dist/src/scope/resolve.d.ts

@@ -0,0 +1,19 @@
+export declare function resolveProjectRef(input: {
+    readonly value: string | undefined;
+    readonly env: Readonly<Record<string, string | undefined>>;
+}): string | undefined;
+export declare function resolveCommandProjectRef(input: {
+    readonly value: string | undefined;
+    readonly env: Readonly<Record<string, string | undefined>>;
+    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 inferred?: string;
+}): string | undefined;
+export declare function resolveThreadId(input: {
+    readonly value: string | undefined;
+    readonly env: Readonly<Record<string, string | undefined>>;
+}): string | undefined;

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

@@ -0,0 +1 @@
+export * from "#t3tools/contracts";