t3code-cli 0.11.0 → 0.13.0

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

@@ -0,0 +1,33 @@
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import type { ConfigError } from "../error.ts";
+import type { KeystoreUnavailableError } from "./error.ts";
+export declare const masterKeyByteLength = 32;
+export type MasterKeyReadResult = {
+    readonly kind: "missing";
+} | {
+    readonly kind: "present";
+    readonly key: Uint8Array;
+} | {
+    readonly kind: "corrupt";
+    readonly message: string;
+} | {
+    readonly kind: "unavailable";
+    readonly message: string;
+};
+export type MasterKeyKeystore = {
+    readonly read: () => Effect.Effect<MasterKeyReadResult, ConfigError>;
+    readonly write: (key: Uint8Array) => Effect.Effect<void, ConfigError | KeystoreUnavailableError>;
+};
+declare const T3MasterKeyKeystoreFactory_base: Context.ServiceClass<T3MasterKeyKeystoreFactory, "t3cli/T3MasterKeyKeystoreFactory", {
+    readonly make: () => Effect.Effect<MasterKeyKeystore, KeystoreUnavailableError>;
+}>;
+export declare class T3MasterKeyKeystoreFactory extends T3MasterKeyKeystoreFactory_base {
+}
+export declare function shouldUseFileKeystoreForRead(result: MasterKeyReadResult): result is {
+    readonly kind: "missing";
+} | {
+    readonly kind: "unavailable";
+    readonly message: string;
+};
+export {};

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

@@ -0,0 +1 @@
+export { resolveConfigFilePath, resolveKeyFilePath, resolveT3cliConfigDir } from "./paths.ts";

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

@@ -0,0 +1,6 @@
+import * as Effect from "effect/Effect";
+import * as Path from "effect/Path";
+import { ConfigError } from "../error.ts";
+export declare const resolveT3cliConfigDir: () => Effect.Effect<string, ConfigError, Path.Path>;
+export declare const resolveConfigFilePath: () => Effect.Effect<string, ConfigError, Path.Path>;
+export declare const resolveKeyFilePath: () => Effect.Effect<string, ConfigError, Path.Path>;

package/dist/src/config/persist/file-mode.d.ts

@@ -0,0 +1,4 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import { ConfigError } from "../error.ts";
+export declare const hardenPrivateFileMode: (filePath: string, label: "config" | "credential key") => Effect.Effect<void, ConfigError, FileSystem.FileSystem>;

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

@@ -0,0 +1,68 @@
+import * as Effect from "effect/Effect";
+import { T3CredentialCrypto } from "../credential/service.ts";
+import { ConfigError } from "../error.ts";
+import type { EncryptedConfig } from "../types.ts";
+export declare const emptyEncryptedConfig: () => EncryptedConfig;
+export declare const readEncryptedConfigFromValue: (value: unknown) => Effect.Effect<{
+    config: {
+        readonly version: 2;
+        readonly default?: string;
+        readonly environments: {
+            readonly [x: string]: {
+                readonly url: string;
+                readonly local: boolean;
+                readonly token: {
+                    readonly kind: "encrypted";
+                    readonly alg: "aes-256-gcm";
+                    readonly key: "default";
+                    readonly nonce: string;
+                    readonly ciphertext: string;
+                    readonly tag: string;
+                };
+            };
+        };
+    };
+    migratedFromV1: false;
+} | {
+    config: {
+        readonly version: 2;
+        readonly default?: string;
+        readonly environments: {
+            readonly [x: string]: {
+                readonly url: string;
+                readonly local: boolean;
+                readonly token: {
+                    readonly kind: "encrypted";
+                    readonly alg: "aes-256-gcm";
+                    readonly key: "default";
+                    readonly nonce: string;
+                    readonly ciphertext: string;
+                    readonly tag: string;
+                };
+            };
+        };
+    };
+    migratedFromV1: true;
+}, ConfigError, T3CredentialCrypto>;
+export declare const migrateV1FileToEncrypted: (config: {
+    readonly url?: string;
+    readonly token?: string;
+    readonly local?: boolean;
+}) => Effect.Effect<{
+    readonly version: 2;
+    readonly default?: string;
+    readonly environments: {
+        readonly [x: string]: {
+            readonly url: string;
+            readonly local: boolean;
+            readonly token: {
+                readonly kind: "encrypted";
+                readonly alg: "aes-256-gcm";
+                readonly key: "default";
+                readonly nonce: string;
+                readonly ciphertext: string;
+                readonly tag: string;
+            };
+        };
+    };
+}, ConfigError, T3CredentialCrypto>;

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

@@ -0,0 +1,40 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { ConfigError } from "../error.ts";
+export declare const readEncryptedConfigFile: () => Effect.Effect<{
+    readonly version: 2;
+    readonly default?: string;
+    readonly environments: {
+        readonly [x: string]: {
+            readonly url: string;
+            readonly local: boolean;
+            readonly token: {
+                readonly kind: "encrypted";
+                readonly alg: "aes-256-gcm";
+                readonly key: "default";
+                readonly nonce: string;
+                readonly ciphertext: string;
+                readonly tag: string;
+            };
+        };
+    };
+}, ConfigError, FileSystem.FileSystem | Path.Path | import("../credential/service.ts").T3CredentialCrypto>;
+export declare const writeEncryptedConfigFile: (config: {
+    readonly version: 2;
+    readonly default?: string;
+    readonly environments: {
+        readonly [x: string]: {
+            readonly url: string;
+            readonly local: boolean;
+            readonly token: {
+                readonly kind: "encrypted";
+                readonly alg: "aes-256-gcm";
+                readonly key: "default";
+                readonly nonce: string;
+                readonly ciphertext: string;
+                readonly tag: string;
+            };
+        };
+    };
+}) => Effect.Effect<void, ConfigError, FileSystem.FileSystem | Path.Path>;

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

@@ -0,0 +1,68 @@
+import * as Schema from "effect/Schema";
+export declare const EncryptedTokenSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"encrypted">;
+    readonly alg: Schema.Literal<"aes-256-gcm">;
+    readonly key: Schema.Literal<"default">;
+    readonly nonce: Schema.String;
+    readonly ciphertext: Schema.String;
+    readonly tag: Schema.String;
+}>;
+export declare const StoredEnvironmentFileSchema: Schema.Struct<{
+    readonly url: Schema.String;
+    readonly local: Schema.Boolean;
+    readonly token: Schema.Struct<{
+        readonly kind: Schema.Literal<"encrypted">;
+        readonly alg: Schema.Literal<"aes-256-gcm">;
+        readonly key: Schema.Literal<"default">;
+        readonly nonce: Schema.String;
+        readonly ciphertext: Schema.String;
+        readonly tag: Schema.String;
+    }>;
+}>;
+export declare const StoredConfigV2FileSchema: Schema.Struct<{
+    readonly version: Schema.Literal<2>;
+    readonly default: Schema.optionalKey<Schema.String>;
+    readonly environments: Schema.$Record<Schema.String, Schema.Struct<{
+        readonly url: Schema.String;
+        readonly local: Schema.Boolean;
+        readonly token: Schema.Struct<{
+            readonly kind: Schema.Literal<"encrypted">;
+            readonly alg: Schema.Literal<"aes-256-gcm">;
+            readonly key: Schema.Literal<"default">;
+            readonly nonce: Schema.String;
+            readonly ciphertext: Schema.String;
+            readonly tag: Schema.String;
+        }>;
+    }>>;
+}>;
+export declare const StoredConfigV1FileSchema: Schema.Struct<{
+    readonly url: Schema.optionalKey<Schema.String>;
+    readonly token: Schema.optionalKey<Schema.String>;
+    readonly local: Schema.optionalKey<Schema.Boolean>;
+}>;
+export type EncryptedToken = Schema.Schema.Type<typeof EncryptedTokenSchema>;
+export type StoredEnvironmentFile = Schema.Schema.Type<typeof StoredEnvironmentFileSchema>;
+export type StoredConfigV2File = Schema.Schema.Type<typeof StoredConfigV2FileSchema>;
+export type StoredConfigV1File = Schema.Schema.Type<typeof StoredConfigV1FileSchema>;
+export declare const StoredConfigV1FileJson: Schema.fromJsonString<Schema.Struct<{
+    readonly url: Schema.optionalKey<Schema.String>;
+    readonly token: Schema.optionalKey<Schema.String>;
+    readonly local: Schema.optionalKey<Schema.Boolean>;
+}>>;
+export declare const StoredConfigV2FileJson: Schema.fromJsonString<Schema.Struct<{
+    readonly version: Schema.Literal<2>;
+    readonly default: Schema.optionalKey<Schema.String>;
+    readonly environments: Schema.$Record<Schema.String, Schema.Struct<{
+        readonly url: Schema.String;
+        readonly local: Schema.Boolean;
+        readonly token: Schema.Struct<{
+            readonly kind: Schema.Literal<"encrypted">;
+            readonly alg: Schema.Literal<"aes-256-gcm">;
+            readonly key: Schema.Literal<"default">;
+            readonly nonce: Schema.String;
+            readonly ciphertext: Schema.String;
+            readonly tag: Schema.String;
+        }>;
+    }>>;
+}>>;
+export declare const UnknownConfigFileJson: Schema.UnknownFromJsonString;

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

@@ -0,0 +1,40 @@
+import * as Effect from "effect/Effect";
+import { ConfigError } from "../error.ts";
+import type { EncryptedConfig } from "../types.ts";
+export type ResolveSelectionInput = {
+    readonly selectedEnvironment?: string | undefined;
+    readonly defaultEnvironment?: string | undefined;
+};
+export declare function selectEnvironmentName(input: ResolveSelectionInput): string | undefined;
+export type ResolveCredentialInput = {
+    readonly envUrl?: string | undefined;
+    readonly envToken?: string | undefined;
+};
+export declare function validateCredentialEnvVars(input: ResolveCredentialInput): Effect.Effect<void, never, never> | Effect.Effect<never, ConfigError, never>;
+export declare function resolveDefaultForUpsert(encrypted: EncryptedConfig, environmentName: string, makeDefault?: boolean): string | undefined;
+export declare function summarizeEnvironments(encrypted: EncryptedConfig): {
+    name: string;
+    url: string;
+    local: boolean;
+    default: boolean;
+}[];
+export declare function buildResolvedConfigFromEnv(input: {
+    readonly envUrl: string;
+    readonly envToken: string;
+}): Effect.Effect<{
+    url: string;
+    token: string;
+    source: "env";
+    local: false;
+}, ConfigError, never>;
+export declare function buildResolvedConfigFromStored(input: {
+    readonly selectedName: string;
+    readonly token: string;
+    readonly encrypted: EncryptedConfig;
+}): Effect.Effect<{
+    url: string;
+    token: string;
+    source: "config";
+    local: boolean;
+    environment: string;
+}, ConfigError, never>;

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

@@ -0,0 +1 @@
+export * as Service from "./service.ts";

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

@@ -0,0 +1,4 @@
+export declare function resolveConfiguredEnvironment(input: {
+    readonly cliFlag?: string | undefined;
+    readonly t3cliEnv?: string | undefined;
+}): string | undefined;

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

@@ -0,0 +1,10 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+declare const T3ConfigSelection_base: Context.ServiceClass<T3ConfigSelection, "t3cli/T3ConfigSelection", {
+    readonly getSelectedEnvironment: () => Effect.Effect<string | undefined>;
+}>;
+export declare class T3ConfigSelection extends T3ConfigSelection_base {
+}
+export declare const layer: Layer.Layer<T3ConfigSelection, import("effect/Config").ConfigError, never>;
+export {};

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

@@ -0,0 +1,36 @@
+import type { EncryptedToken, StoredConfigV2File, StoredEnvironmentFile } from "./persist/schema.ts";
+export type EncryptedEnvironment = StoredEnvironmentFile;
+export type EncryptedConfig = StoredConfigV2File;
+export type DecryptedEnvironment = {
+    readonly url: string;
+    readonly local: boolean;
+    readonly token: string;
+};
+export type DecryptedConfig = {
+    readonly version: 2;
+    readonly default?: string;
+    readonly environments: Readonly<Record<string, DecryptedEnvironment>>;
+};
+export type EnvironmentSummary = {
+    readonly name: string;
+    readonly url: string;
+    readonly local: boolean;
+    readonly default: boolean;
+};
+export type ResolvedConfig = {
+    readonly url: string;
+    readonly token: string;
+    readonly source: "env" | "config";
+    readonly local: boolean;
+    readonly environment?: string;
+};
+export type UpsertEnvironmentInput = {
+    readonly name: string;
+    readonly url: string;
+    readonly token: string;
+    readonly local: boolean;
+    readonly makeDefault?: boolean;
+};
+export type StoredConfig = DecryptedConfig;
+export type StoredEnvironment = DecryptedEnvironment;
+export type { EncryptedToken };

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

@@ -0,0 +1,10 @@
+import * as Cause from "effect/Cause";
+import * as Schema from "effect/Schema";
+declare const UrlError_base: Schema.Class<UrlError, Schema.TaggedStruct<"UrlError", {
+    readonly message: Schema.String;
+    readonly protocol: Schema.optionalKey<Schema.String>;
+    readonly cause: Schema.optionalKey<Schema.instanceOf<Cause.IllegalArgumentError, Cause.IllegalArgumentError>>;
+}>, Cause.YieldableError>;
+export declare class UrlError extends UrlError_base {
+}
+export {};

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

@@ -0,0 +1,2 @@
+export { normalizeHttpBaseUrl, toWebSocketBaseUrl, toHttpEndpointUrl, toWebSocketEndpointUrl, } from "./url.ts";
+export { UrlError } from "./error.ts";

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

@@ -1,7 +1,9 @@
 import * as Schema from "effect/Schema";
+import { ConfigError } from "../config/error.ts";
+import { UrlError } from "../config/url/error.ts";
 declare const T3CodeConnectionError_base: Schema.Class<T3CodeConnectionError, Schema.TaggedStruct<"T3CodeConnectionError", {
     readonly message: Schema.String;
-    readonly cause: Schema.optionalKey<Schema.Unknown>;
+    readonly cause: Schema.Union<readonly [typeof ConfigError, typeof UrlError]>;
 }>, import("effect/Cause").YieldableError>;
 export declare class T3CodeConnectionError extends T3CodeConnectionError_base {
 }

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

@@ -1,5 +1,4 @@
 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/connection/prepared.d.ts

@@ -0,0 +1,14 @@
+import { type ConnectionAttemptError, type PreparedConnection } from "@t3tools/client-runtime/connection";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { HttpClient } from "effect/unstable/http";
+import { T3CodeConnectionError } from "./error.ts";
+import { T3CodeConnectionProvider } from "./service.ts";
+declare const T3PreparedConnectionProvider_base: Context.ServiceClass<T3PreparedConnectionProvider, "t3cli/T3PreparedConnectionProvider", {
+    readonly get: Effect.Effect<PreparedConnection, ConnectionAttemptError | T3CodeConnectionError>;
+}>;
+export declare class T3PreparedConnectionProvider extends T3PreparedConnectionProvider_base {
+}
+export declare const T3PreparedConnectionProviderLive: Layer.Layer<T3PreparedConnectionProvider, never, HttpClient.HttpClient | T3CodeConnectionProvider>;
+export {};

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

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

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

@@ -40,5 +40,18 @@ declare const TerminalLookupError_base: Schema.Class<TerminalLookupError, Schema
 }>, import("effect/Cause").YieldableError>;
 export declare class TerminalLookupError extends TerminalLookupError_base {
 }
-export type DomainError = ProjectLookupError | ModelSelectionError | ThreadEventError | ThreadSessionError | ThreadLookupError | ProjectCreateVisibilityError | TerminalLookupError;
+declare const ProjectActionLookupError_base: Schema.Class<ProjectActionLookupError, Schema.TaggedStruct<"ProjectActionLookupError", {
+    readonly message: Schema.String;
+    readonly projectId: Schema.String;
+    readonly selector: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ProjectActionLookupError extends ProjectActionLookupError_base {
+}
+declare const ProjectActionValidationError_base: Schema.Class<ProjectActionValidationError, Schema.TaggedStruct<"ProjectActionValidationError", {
+    readonly message: Schema.String;
+    readonly projectId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ProjectActionValidationError extends ProjectActionValidationError_base {
+}
+export type DomainError = ProjectLookupError | ModelSelectionError | ThreadEventError | ThreadSessionError | ThreadLookupError | ProjectCreateVisibilityError | TerminalLookupError | ProjectActionLookupError | ProjectActionValidationError;
 export {};

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

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect";
 import * as Path from "effect/Path";
-import type { OrchestrationProjectShell, OrchestrationShellSnapshot } from "#t3tools/contracts";
+import type { OrchestrationProjectShell, OrchestrationShellSnapshot } from "@t3tools/contracts";
 export type ResolvedProjectScope = {
     readonly project: OrchestrationProjectShell;
     readonly inferredWorktreePath?: string;
@@ -11,6 +11,19 @@ export declare const resolveProjectScope: (snapshot: {
         readonly id: string & import("effect/Brand").Brand<"ProjectId">;
         readonly title: string;
         readonly workspaceRoot: string;
+        readonly repositoryIdentity?: {
+            readonly canonicalKey: string;
+            readonly locator: {
+                readonly source: "git-remote";
+                readonly remoteName: string;
+                readonly remoteUrl: string;
+            };
+            readonly rootPath?: string;
+            readonly displayName?: string;
+            readonly provider?: string;
+            readonly owner?: string;
+            readonly name?: string;
+        } | null | undefined;
         readonly defaultModelSelection: {
             readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
             readonly model: string;
@@ -23,24 +36,13 @@ export declare const resolveProjectScope: (snapshot: {
             readonly id: string;
             readonly name: string;
             readonly command: string;
-            readonly icon: "play" | "test" | "lint" | "configure" | "build" | "debug";
+            readonly icon: "build" | "configure" | "debug" | "lint" | "play" | "test";
             readonly runOnWorktreeCreate: boolean;
+            readonly previewUrl?: string | undefined;
+            readonly autoOpenPreview?: boolean | undefined;
         }[];
         readonly createdAt: string;
         readonly updatedAt: string;
-        readonly repositoryIdentity?: {
-            readonly canonicalKey: string;
-            readonly locator: {
-                readonly source: "git-remote";
-                readonly remoteName: string;
-                readonly remoteUrl: string;
-            };
-            readonly rootPath?: string;
-            readonly displayName?: string;
-            readonly provider?: string;
-            readonly owner?: string;
-            readonly name?: string;
-        } | null | undefined;
     }[];
     readonly threads: readonly {
         readonly id: string & import("effect/Brand").Brand<"ThreadId">;
@@ -54,13 +56,13 @@ export declare const resolveProjectScope: (snapshot: {
                 readonly value: string | boolean;
             }[];
         };
-        readonly runtimeMode: "approval-required" | "auto-accept-edits" | "full-access";
+        readonly runtimeMode: "approval-required" | "auto" | "auto-accept-edits" | "full-access";
         readonly interactionMode: "default" | "plan";
         readonly branch: string | null;
         readonly worktreePath: string | null;
         readonly latestTurn: {
             readonly turnId: string & import("effect/Brand").Brand<"TurnId">;
-            readonly state: "error" | "running" | "interrupted" | "completed";
+            readonly state: "completed" | "error" | "interrupted" | "running";
             readonly requestedAt: string;
             readonly startedAt: string | null;
             readonly completedAt: string | null;
@@ -73,15 +75,19 @@ export declare const resolveProjectScope: (snapshot: {
         readonly createdAt: string;
         readonly updatedAt: string;
         readonly archivedAt: string | null;
+        readonly settledOverride: "active" | "settled" | null;
+        readonly settledAt: string | null;
+        readonly snoozedUntil?: string | null | undefined;
+        readonly snoozedAt?: string | null | undefined;
         readonly session: {
             readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
-            readonly status: "error" | "idle" | "starting" | "running" | "ready" | "interrupted" | "stopped";
+            readonly status: "error" | "idle" | "interrupted" | "ready" | "running" | "starting" | "stopped";
             readonly providerName: string | null;
-            readonly runtimeMode: "approval-required" | "auto-accept-edits" | "full-access";
+            readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
+            readonly runtimeMode: "approval-required" | "auto" | "auto-accept-edits" | "full-access";
             readonly activeTurnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
             readonly lastError: string | null;
             readonly updatedAt: string;
-            readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
         } | null;
         readonly latestUserMessageAt: string | null;
         readonly hasPendingApprovals: boolean;
@@ -96,6 +102,19 @@ export declare const resolveProjectScope: (snapshot: {
         readonly id: string & import("effect/Brand").Brand<"ProjectId">;
         readonly title: string;
         readonly workspaceRoot: string;
+        readonly repositoryIdentity?: {
+            readonly canonicalKey: string;
+            readonly locator: {
+                readonly source: "git-remote";
+                readonly remoteName: string;
+                readonly remoteUrl: string;
+            };
+            readonly rootPath?: string;
+            readonly displayName?: string;
+            readonly provider?: string;
+            readonly owner?: string;
+            readonly name?: string;
+        } | null | undefined;
         readonly defaultModelSelection: {
             readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
             readonly model: string;
@@ -108,11 +127,21 @@ export declare const resolveProjectScope: (snapshot: {
             readonly id: string;
             readonly name: string;
             readonly command: string;
-            readonly icon: "play" | "test" | "lint" | "configure" | "build" | "debug";
+            readonly icon: "build" | "configure" | "debug" | "lint" | "play" | "test";
             readonly runOnWorktreeCreate: boolean;
+            readonly previewUrl?: string | undefined;
+            readonly autoOpenPreview?: boolean | undefined;
         }[];
         readonly createdAt: string;
         readonly updatedAt: string;
+    };
+    inferredWorktreePath: string;
+} | {
+    inferredWorktreePath?: never;
+    project: {
+        readonly id: string & import("effect/Brand").Brand<"ProjectId">;
+        readonly title: string;
+        readonly workspaceRoot: string;
         readonly repositoryIdentity?: {
             readonly canonicalKey: string;
             readonly locator: {
@@ -126,13 +155,6 @@ export declare const resolveProjectScope: (snapshot: {
             readonly owner?: string;
             readonly name?: string;
         } | null | undefined;
-    };
-    inferredWorktreePath: string;
-} | {
-    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;
@@ -145,25 +167,13 @@ export declare const resolveProjectScope: (snapshot: {
             readonly id: string;
             readonly name: string;
             readonly command: string;
-            readonly icon: "play" | "test" | "lint" | "configure" | "build" | "debug";
+            readonly icon: "build" | "configure" | "debug" | "lint" | "play" | "test";
             readonly runOnWorktreeCreate: boolean;
+            readonly previewUrl?: string | undefined;
+            readonly autoOpenPreview?: boolean | undefined;
         }[];
         readonly createdAt: string;
         readonly updatedAt: string;
-        readonly repositoryIdentity?: {
-            readonly canonicalKey: string;
-            readonly locator: {
-                readonly source: "git-remote";
-                readonly remoteName: string;
-                readonly remoteUrl: string;
-            };
-            readonly rootPath?: string;
-            readonly displayName?: string;
-            readonly provider?: string;
-            readonly owner?: string;
-            readonly name?: string;
-        } | null | undefined;
     };
-    inferredWorktreePath?: never;
 } | undefined, never, Path.Path>;
 export declare function findProjectById(snapshot: OrchestrationShellSnapshot, projectId: string): OrchestrationProjectShell | null;