t3code-cli 0.7.0 → 0.9.0

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

@@ -2,6 +2,17 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { T3Application } from "./service.ts";
 export declare const makeT3Application: () => Effect.Effect<{
+    approveThread: (input: {
+        readonly threadId: string;
+        readonly requestId: string;
+        readonly decision: import("#t3tools/contracts").ProviderApprovalDecision;
+    }) => Effect.Effect<{
+        threadId: string;
+        requestId: string;
+        dispatch: {
+            readonly sequence: number;
+        };
+    }, import("../rpc/error.ts").RpcError, never>;
     archiveThread: (threadId: string) => Effect.Effect<{
         readonly sequence: number;
     }, import("../rpc/error.ts").RpcError, never>;
@@ -82,6 +93,15 @@ export declare const makeT3Application: () => Effect.Effect<{
                 readonly updatedAt: string;
                 readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
             } | null;
+            readonly goal: {
+                readonly objective: string;
+                readonly status: "active" | "paused" | "budgetLimited" | "complete";
+                readonly tokensUsed: number;
+                readonly tokenBudget: number | null;
+                readonly timeUsedSeconds: number;
+                readonly createdAt: string;
+                readonly updatedAt: string;
+            } | null;
             readonly latestUserMessageAt: string | null;
             readonly hasPendingApprovals: boolean;
             readonly hasPendingUserInput: boolean;
@@ -120,6 +140,15 @@ export declare const makeT3Application: () => Effect.Effect<{
         readonly updatedAt: string;
         readonly archivedAt: string | null;
         readonly deletedAt: string | null;
+        readonly goal: {
+            readonly objective: string;
+            readonly status: "active" | "paused" | "budgetLimited" | "complete";
+            readonly tokensUsed: number;
+            readonly tokenBudget: number | null;
+            readonly timeUsedSeconds: number;
+            readonly createdAt: string;
+            readonly updatedAt: string;
+        } | null;
         readonly messages: readonly {
             readonly id: string & import("effect/Brand").Brand<"MessageId">;
             readonly role: "user" | "assistant" | "system";
@@ -180,6 +209,17 @@ export declare const makeT3Application: () => Effect.Effect<{
             readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
         } | null;
     }, import("../rpc/error.ts").RpcError, never>;
+    respondToThread: (input: {
+        readonly threadId: string;
+        readonly requestId: string;
+        readonly answers: import("#t3tools/contracts").ProviderUserInputAnswers;
+    }) => Effect.Effect<{
+        threadId: string;
+        requestId: string;
+        dispatch: {
+            readonly sequence: number;
+        };
+    }, import("../rpc/error.ts").RpcError, never>;
     sendThread: (input: import("./service.ts").SendThreadInput, policy?: {
         readonly until: "dispatch" | "visible" | "complete";
     } | undefined) => Effect.Effect<{
@@ -225,6 +265,15 @@ export declare const makeT3Application: () => Effect.Effect<{
             readonly updatedAt: string;
             readonly archivedAt: string | null;
             readonly deletedAt: string | null;
+            readonly goal: {
+                readonly objective: string;
+                readonly status: "active" | "paused" | "budgetLimited" | "complete";
+                readonly tokensUsed: number;
+                readonly tokenBudget: number | null;
+                readonly timeUsedSeconds: number;
+                readonly createdAt: string;
+                readonly updatedAt: string;
+            } | null;
             readonly messages: readonly {
                 readonly id: string & import("effect/Brand").Brand<"MessageId">;
                 readonly role: "user" | "assistant" | "system";
@@ -286,6 +335,7 @@ export declare const makeT3Application: () => Effect.Effect<{
             } | null;
         };
     }, import("../domain/error.ts").ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
+    showThread: (threadId: string) => Effect.Effect<import("./threads.ts").ThreadShow, import("../rpc/error.ts").RpcError, never>;
     startThread: (startInput: import("./service.ts").StartThreadInput, policy?: {
         readonly until: "dispatch" | "visible" | "complete";
     } | undefined) => Effect.Effect<{
@@ -401,6 +451,15 @@ export declare const makeT3Application: () => Effect.Effect<{
             readonly updatedAt: string;
             readonly archivedAt: string | null;
             readonly deletedAt: string | null;
+            readonly goal: {
+                readonly objective: string;
+                readonly status: "active" | "paused" | "budgetLimited" | "complete";
+                readonly tokensUsed: number;
+                readonly tokenBudget: number | null;
+                readonly timeUsedSeconds: number;
+                readonly createdAt: string;
+                readonly updatedAt: string;
+            } | null;
             readonly messages: readonly {
                 readonly id: string & import("effect/Brand").Brand<"MessageId">;
                 readonly role: "user" | "assistant" | "system";
@@ -495,6 +554,15 @@ export declare const makeT3Application: () => Effect.Effect<{
         readonly updatedAt: string;
         readonly archivedAt: string | null;
         readonly deletedAt: string | null;
+        readonly goal: {
+            readonly objective: string;
+            readonly status: "active" | "paused" | "budgetLimited" | "complete";
+            readonly tokensUsed: number;
+            readonly tokenBudget: number | null;
+            readonly timeUsedSeconds: number;
+            readonly createdAt: string;
+            readonly updatedAt: string;
+        } | null;
         readonly messages: readonly {
             readonly id: string & import("effect/Brand").Brand<"MessageId">;
             readonly role: "user" | "assistant" | "system";
@@ -555,6 +623,12 @@ export declare const makeT3Application: () => Effect.Effect<{
             readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
         } | null;
     }, import("../domain/error.ts").ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
+    callbackThread: (input: import("./service.ts").CallbackThreadInput) => Effect.Effect<{
+        dispatch: {
+            readonly sequence: number;
+        };
+        targetThreadId: string;
+    }, import("../domain/error.ts").ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
     loadShell: () => Effect.Effect<{
         readonly snapshotSequence: number;
         readonly projects: readonly {
@@ -633,6 +707,15 @@ export declare const makeT3Application: () => Effect.Effect<{
                 readonly updatedAt: string;
                 readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
             } | null;
+            readonly goal: {
+                readonly objective: string;
+                readonly status: "active" | "paused" | "budgetLimited" | "complete";
+                readonly tokensUsed: number;
+                readonly tokenBudget: number | null;
+                readonly timeUsedSeconds: number;
+                readonly createdAt: string;
+                readonly updatedAt: string;
+            } | null;
             readonly latestUserMessageAt: string | null;
             readonly hasPendingApprovals: boolean;
             readonly hasPendingUserInput: boolean;
@@ -752,6 +835,7 @@ export declare const makeT3Application: () => Effect.Effect<{
             readonly groupKey: string;
         } | undefined;
         readonly showInteractionModeToggle?: boolean | undefined;
+        readonly requiresNewThreadForModelChange?: boolean | undefined;
         readonly message?: string | undefined;
         readonly availability?: "available" | "unavailable" | undefined;
         readonly unavailableReason?: string | undefined;
@@ -772,5 +856,5 @@ export declare const makeT3Application: () => Effect.Effect<{
             readonly output: string | null;
         };
     }[], import("../rpc/error.ts").RpcError, never>;
-}, 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>;
+}, never, import("../environment/service.ts").Environment | import("../orchestration/service.ts").T3Orchestration | import("effect/Path").Path | import("effect/Crypto").Crypto>;
+export declare const T3ApplicationLive: Layer.Layer<T3Application, never, import("../environment/service.ts").Environment | import("../orchestration/service.ts").T3Orchestration | import("effect/Path").Path | import("effect/Crypto").Crypto>;

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

@@ -70,6 +70,7 @@ export declare const makeModelsApplication: () => Effect.Effect<{
             readonly groupKey: string;
         } | undefined;
         readonly showInteractionModeToggle?: boolean | undefined;
+        readonly requiresNewThreadForModelChange?: boolean | undefined;
         readonly message?: string | undefined;
         readonly availability?: "available" | "unavailable" | undefined;
         readonly unavailableReason?: string | undefined;

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

@@ -83,6 +83,15 @@ export declare const makeProjectApplication: () => Effect.Effect<{
                 readonly updatedAt: string;
                 readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
             } | null;
+            readonly goal: {
+                readonly objective: string;
+                readonly status: "active" | "paused" | "budgetLimited" | "complete";
+                readonly tokensUsed: number;
+                readonly tokenBudget: number | null;
+                readonly timeUsedSeconds: number;
+                readonly createdAt: string;
+                readonly updatedAt: string;
+            } | null;
             readonly latestUserMessageAt: string | null;
             readonly hasPendingApprovals: boolean;
             readonly hasPendingUserInput: boolean;
@@ -133,4 +142,4 @@ export declare const makeProjectApplication: () => Effect.Effect<{
             } | null | undefined;
         };
     }, ProjectCreateVisibilityError | import("../rpc/error.ts").RpcError, never>;
-}, never, T3Orchestration | Environment | Path.Path | Crypto.Crypto>;
+}, never, Environment | T3Orchestration | Path.Path | Crypto.Crypto>;

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

@@ -1,8 +1,9 @@
 import * as Context from "effect/Context";
 import type * as Effect from "effect/Effect";
 import type * as Stream from "effect/Stream";
-import type { DispatchResult, ModelSelection, OrchestrationMessage, OrchestrationProjectShell, OrchestrationShellSnapshot, OrchestrationThread, OrchestrationThreadShell, ServerProvider } from "#t3tools/contracts";
+import type { DispatchResult, ModelSelection, OrchestrationMessage, OrchestrationProjectShell, OrchestrationShellSnapshot, OrchestrationThread, OrchestrationThreadShell, ProviderUserInputAnswers, ServerProvider } from "#t3tools/contracts";
 import type { ApplicationError } from "./error.ts";
+import type { ThreadShow } from "./threads.ts";
 export type StartThreadInput = {
     readonly projectRef?: string;
     readonly message: string;
@@ -17,6 +18,11 @@ export type SendThreadInput = {
     readonly message: string;
     readonly options?: NonNullable<ModelSelection["options"]>;
 };
+export type CallbackThreadInput = {
+    readonly fromThreadId: string;
+    readonly targetThreadId: string;
+    readonly prompt: string;
+};
 export type StartThreadPolicy = {
     readonly until: "dispatch" | "visible" | "complete";
 };
@@ -52,6 +58,25 @@ declare const T3Application_base: Context.ServiceClass<T3Application, "t3cli/T3A
         readonly threads: ReadonlyArray<OrchestrationThreadShell>;
     }, ApplicationError>;
     readonly getThreadMessages: (threadId: string) => Effect.Effect<OrchestrationThread, ApplicationError>;
+    readonly showThread: (threadId: string) => Effect.Effect<ThreadShow, ApplicationError>;
+    readonly approveThread: (input: {
+        readonly threadId: string;
+        readonly requestId: string;
+        readonly decision: "accept" | "decline" | "cancel";
+    }) => Effect.Effect<{
+        readonly threadId: string;
+        readonly requestId: string;
+        readonly dispatch: DispatchResult;
+    }, ApplicationError>;
+    readonly respondToThread: (input: {
+        readonly threadId: string;
+        readonly requestId: string;
+        readonly answers: ProviderUserInputAnswers;
+    }) => Effect.Effect<{
+        readonly threadId: string;
+        readonly requestId: string;
+        readonly dispatch: DispatchResult;
+    }, ApplicationError>;
     readonly archiveThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
     readonly startThread: (input: StartThreadInput, policy?: StartThreadPolicy) => Effect.Effect<{
         readonly dispatch: DispatchResult;
@@ -66,6 +91,10 @@ declare const T3Application_base: Context.ServiceClass<T3Application, "t3cli/T3A
     }, ApplicationError>;
     readonly watchThread: (threadId: string) => Stream.Stream<WaitEvent, ApplicationError>;
     readonly waitForThread: (threadId: string) => Effect.Effect<OrchestrationThread, ApplicationError>;
+    readonly callbackThread: (input: CallbackThreadInput) => Effect.Effect<{
+        readonly dispatch: DispatchResult;
+        readonly targetThreadId: string;
+    }, ApplicationError>;
 }>;
 export declare class T3Application extends T3Application_base {
 }

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

@@ -82,6 +82,15 @@ export declare function waitForShellSequence(input: {
             readonly updatedAt: string;
             readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
         } | null;
+        readonly goal: {
+            readonly objective: string;
+            readonly status: "active" | "paused" | "budgetLimited" | "complete";
+            readonly tokensUsed: number;
+            readonly tokenBudget: number | null;
+            readonly timeUsedSeconds: number;
+            readonly createdAt: string;
+            readonly updatedAt: string;
+        } | null;
         readonly latestUserMessageAt: string | null;
         readonly hasPendingApprovals: boolean;
         readonly hasPendingUserInput: boolean;

package/dist/src/application/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 } 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,3 +82,29 @@ 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 makeThreadApprovalRespondCommand: (input: {
+    readonly threadId: string;
+    readonly requestId: string;
+    readonly decision: ProviderApprovalDecision;
+}) => Effect.Effect<{
+    type: "thread.approval.respond";
+    commandId: string & import("effect/Brand").Brand<"CommandId">;
+    threadId: string & import("effect/Brand").Brand<"ThreadId">;
+    requestId: string & import("effect/Brand").Brand<"ApprovalRequestId">;
+    decision: "accept" | "acceptForSession" | "decline" | "cancel";
+    createdAt: string;
+}, never, Crypto.Crypto>;
+export declare const makeThreadUserInputRespondCommand: (input: {
+    readonly threadId: string;
+    readonly requestId: string;
+    readonly answers: ProviderUserInputAnswers;
+}) => Effect.Effect<{
+    type: "thread.user-input.respond";
+    commandId: string & import("effect/Brand").Brand<"CommandId">;
+    threadId: string & import("effect/Brand").Brand<"ThreadId">;
+    requestId: string & import("effect/Brand").Brand<"ApprovalRequestId">;
+    answers: {
+        readonly [x: string]: unknown;
+    };
+    createdAt: string;
+}, never, Crypto.Crypto>;

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

@@ -42,6 +42,15 @@ export declare function waitForThread(input: {
     readonly updatedAt: string;
     readonly archivedAt: string | null;
     readonly deletedAt: string | null;
+    readonly goal: {
+        readonly objective: string;
+        readonly status: "active" | "paused" | "budgetLimited" | "complete";
+        readonly tokensUsed: number;
+        readonly tokenBudget: number | null;
+        readonly timeUsedSeconds: number;
+        readonly createdAt: string;
+        readonly updatedAt: string;
+    } | null;
     readonly messages: readonly {
         readonly id: string & import("effect/Brand").Brand<"MessageId">;
         readonly role: "user" | "assistant" | "system";

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

@@ -5,8 +5,23 @@ import { Environment } from "../environment/service.ts";
 import { T3Orchestration } from "../orchestration/service.ts";
 import { ProjectLookupError, ThreadSessionError } from "../domain/error.ts";
 import { type StartThreadInput } from "./service.ts";
-import type { SendThreadInput } from "./service.ts";
+import type { SendThreadInput, CallbackThreadInput } 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";
 export declare const makeThreadApplication: () => Effect.Effect<{
+    approveThread: (input: {
+        readonly threadId: string;
+        readonly requestId: string;
+        readonly decision: ProviderApprovalDecision;
+    }) => Effect.Effect<{
+        threadId: string;
+        requestId: string;
+        dispatch: {
+            readonly sequence: number;
+        };
+    }, import("../rpc/error.ts").RpcError, never>;
     archiveThread: (threadId: string) => Effect.Effect<{
         readonly sequence: number;
     }, import("../rpc/error.ts").RpcError, never>;
@@ -87,6 +102,15 @@ export declare const makeThreadApplication: () => Effect.Effect<{
                 readonly updatedAt: string;
                 readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
             } | null;
+            readonly goal: {
+                readonly objective: string;
+                readonly status: "active" | "paused" | "budgetLimited" | "complete";
+                readonly tokensUsed: number;
+                readonly tokenBudget: number | null;
+                readonly timeUsedSeconds: number;
+                readonly createdAt: string;
+                readonly updatedAt: string;
+            } | null;
             readonly latestUserMessageAt: string | null;
             readonly hasPendingApprovals: boolean;
             readonly hasPendingUserInput: boolean;
@@ -125,6 +149,15 @@ export declare const makeThreadApplication: () => Effect.Effect<{
         readonly updatedAt: string;
         readonly archivedAt: string | null;
         readonly deletedAt: string | null;
+        readonly goal: {
+            readonly objective: string;
+            readonly status: "active" | "paused" | "budgetLimited" | "complete";
+            readonly tokensUsed: number;
+            readonly tokenBudget: number | null;
+            readonly timeUsedSeconds: number;
+            readonly createdAt: string;
+            readonly updatedAt: string;
+        } | null;
         readonly messages: readonly {
             readonly id: string & import("effect/Brand").Brand<"MessageId">;
             readonly role: "user" | "assistant" | "system";
@@ -185,6 +218,17 @@ export declare const makeThreadApplication: () => Effect.Effect<{
             readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
         } | null;
     }, import("../rpc/error.ts").RpcError, never>;
+    respondToThread: (input: {
+        readonly threadId: string;
+        readonly requestId: string;
+        readonly answers: ProviderUserInputAnswers;
+    }) => Effect.Effect<{
+        threadId: string;
+        requestId: string;
+        dispatch: {
+            readonly sequence: number;
+        };
+    }, import("../rpc/error.ts").RpcError, never>;
     sendThread: (input: SendThreadInput, policy?: {
         readonly until: "dispatch" | "visible" | "complete";
     } | undefined) => Effect.Effect<{
@@ -230,6 +274,15 @@ export declare const makeThreadApplication: () => Effect.Effect<{
             readonly updatedAt: string;
             readonly archivedAt: string | null;
             readonly deletedAt: string | null;
+            readonly goal: {
+                readonly objective: string;
+                readonly status: "active" | "paused" | "budgetLimited" | "complete";
+                readonly tokensUsed: number;
+                readonly tokenBudget: number | null;
+                readonly timeUsedSeconds: number;
+                readonly createdAt: string;
+                readonly updatedAt: string;
+            } | null;
             readonly messages: readonly {
                 readonly id: string & import("effect/Brand").Brand<"MessageId">;
                 readonly role: "user" | "assistant" | "system";
@@ -291,6 +344,7 @@ export declare const makeThreadApplication: () => Effect.Effect<{
             } | null;
         };
     }, ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
+    showThread: (threadId: string) => Effect.Effect<ThreadShow, import("../rpc/error.ts").RpcError, never>;
     startThread: (startInput: StartThreadInput, policy?: {
         readonly until: "dispatch" | "visible" | "complete";
     } | undefined) => Effect.Effect<{
@@ -406,6 +460,15 @@ export declare const makeThreadApplication: () => Effect.Effect<{
             readonly updatedAt: string;
             readonly archivedAt: string | null;
             readonly deletedAt: string | null;
+            readonly goal: {
+                readonly objective: string;
+                readonly status: "active" | "paused" | "budgetLimited" | "complete";
+                readonly tokensUsed: number;
+                readonly tokenBudget: number | null;
+                readonly timeUsedSeconds: number;
+                readonly createdAt: string;
+                readonly updatedAt: string;
+            } | null;
             readonly messages: readonly {
                 readonly id: string & import("effect/Brand").Brand<"MessageId">;
                 readonly role: "user" | "assistant" | "system";
@@ -500,6 +563,15 @@ export declare const makeThreadApplication: () => Effect.Effect<{
         readonly updatedAt: string;
         readonly archivedAt: string | null;
         readonly deletedAt: string | null;
+        readonly goal: {
+            readonly objective: string;
+            readonly status: "active" | "paused" | "budgetLimited" | "complete";
+            readonly tokensUsed: number;
+            readonly tokenBudget: number | null;
+            readonly timeUsedSeconds: number;
+            readonly createdAt: string;
+            readonly updatedAt: string;
+        } | null;
         readonly messages: readonly {
             readonly id: string & import("effect/Brand").Brand<"MessageId">;
             readonly role: "user" | "assistant" | "system";
@@ -560,4 +632,32 @@ export declare const makeThreadApplication: () => Effect.Effect<{
             readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
         } | null;
     }, ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
-}, never, T3Orchestration | Environment | Path.Path | Crypto.Crypto>;
+    callbackThread: (input: CallbackThreadInput) => Effect.Effect<{
+        dispatch: {
+            readonly sequence: number;
+        };
+        targetThreadId: string;
+    }, ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
+}, never, Environment | T3Orchestration | Path.Path | Crypto.Crypto>;
+export type ThreadShow = {
+    readonly id: string;
+    readonly projectId: string;
+    readonly title: string;
+    readonly status: ThreadLifecycleStatus;
+    readonly session: OrchestrationThread["session"];
+    readonly latestTurn: OrchestrationThread["latestTurn"];
+    readonly modelSelection: OrchestrationThread["modelSelection"];
+    readonly runtimeMode: OrchestrationThread["runtimeMode"];
+    readonly interactionMode: OrchestrationThread["interactionMode"];
+    readonly branch: OrchestrationThread["branch"];
+    readonly worktreePath: OrchestrationThread["worktreePath"];
+    readonly archivedAt: OrchestrationThread["archivedAt"];
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly messageCount: number;
+    readonly hasPendingApprovals: boolean;
+    readonly hasPendingUserInput: boolean;
+    readonly hasActionableProposedPlan: boolean;
+    readonly pendingApprovals: ReturnType<typeof derivePendingApprovals>;
+    readonly pendingUserInputs: ReturnType<typeof derivePendingUserInputs>;
+};

package/dist/src/cli-path/layer.d.ts

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

package/dist/src/cli-path/service.d.ts

@@ -0,0 +1,8 @@
+import * as Context from "effect/Context";
+export type CliPathShape = {
+    readonly path: string;
+};
+declare const CliPath_base: Context.ServiceClass<CliPath, "t3cli/CliPath", CliPathShape>;
+export declare class CliPath extends CliPath_base {
+}
+export {};

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

@@ -83,6 +83,15 @@ export declare const resolveProjectScope: (snapshot: {
             readonly updatedAt: string;
             readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
         } | null;
+        readonly goal: {
+            readonly objective: string;
+            readonly status: "active" | "paused" | "budgetLimited" | "complete";
+            readonly tokensUsed: number;
+            readonly tokenBudget: number | null;
+            readonly timeUsedSeconds: number;
+            readonly createdAt: string;
+            readonly updatedAt: string;
+        } | null;
         readonly latestUserMessageAt: string | null;
         readonly hasPendingApprovals: boolean;
         readonly hasPendingUserInput: boolean;

package/dist/src/domain/model-config.d.ts

@@ -66,6 +66,7 @@ export declare function firstSelectableProvider(providers: ReadonlyArray<ServerP
         readonly groupKey: string;
     } | undefined;
     readonly showInteractionModeToggle?: boolean | undefined;
+    readonly requiresNewThreadForModelChange?: boolean | undefined;
     readonly message?: string | undefined;
     readonly availability?: "available" | "unavailable" | undefined;
     readonly unavailableReason?: string | undefined;
@@ -181,6 +182,7 @@ export declare function findSelectableProvider(providers: ReadonlyArray<ServerPr
         readonly groupKey: string;
     } | undefined;
     readonly showInteractionModeToggle?: boolean | undefined;
+    readonly requiresNewThreadForModelChange?: boolean | undefined;
     readonly message?: string | undefined;
     readonly availability?: "available" | "unavailable" | undefined;
     readonly unavailableReason?: string | undefined;
@@ -271,6 +273,7 @@ export declare function filterProvidersForModelListing(input: {
         readonly groupKey: string;
     } | undefined;
     readonly showInteractionModeToggle?: boolean | undefined;
+    readonly requiresNewThreadForModelChange?: boolean | undefined;
     readonly message?: string | undefined;
     readonly availability?: "available" | "unavailable" | undefined;
     readonly unavailableReason?: string | undefined;

package/dist/src/domain/thread-activities.d.ts

@@ -0,0 +1,14 @@
+import { ApprovalRequestId, type OrchestrationThreadActivity, type UserInputQuestion } from "#t3tools/contracts";
+export type PendingApproval = {
+    readonly requestId: ApprovalRequestId;
+    readonly requestKind: "command" | "file-read" | "file-change";
+    readonly createdAt: string;
+    readonly detail?: string;
+};
+export type PendingUserInput = {
+    readonly requestId: ApprovalRequestId;
+    readonly createdAt: string;
+    readonly questions: ReadonlyArray<UserInputQuestion>;
+};
+export declare function derivePendingApprovals(activities: ReadonlyArray<OrchestrationThreadActivity>): ReadonlyArray<PendingApproval>;
+export declare function derivePendingUserInputs(activities: ReadonlyArray<OrchestrationThreadActivity>): ReadonlyArray<PendingUserInput>;

package/dist/src/domain/thread-lifecycle.d.ts

@@ -1,5 +1,6 @@
 import { type OrchestrationEvent, type OrchestrationMessage as OrchestrationMessageType, type OrchestrationThread, type OrchestrationThreadShell } from "#t3tools/contracts";
 export declare function isThreadActive(thread: OrchestrationThreadShell | OrchestrationThread): boolean;
+export type ThreadLifecycleStatus = ReturnType<typeof threadStatus>;
 export declare function threadStatus(thread: OrchestrationThreadShell | OrchestrationThread): "unknown" | "error" | "idle" | "starting" | "running" | "ready" | "interrupted" | "stopped" | "completed" | "pending";
 export declare function latestAssistantMessage(thread: OrchestrationThread): {
     readonly id: string & import("effect/Brand").Brand<"MessageId">;
@@ -50,6 +51,15 @@ export declare function applyThreadEvent(current: OrchestrationThread, event: Or
     readonly updatedAt: string;
     readonly archivedAt: string | null;
     readonly deletedAt: string | null;
+    readonly goal: {
+        readonly objective: string;
+        readonly status: "active" | "paused" | "budgetLimited" | "complete";
+        readonly tokensUsed: number;
+        readonly tokenBudget: number | null;
+        readonly timeUsedSeconds: number;
+        readonly createdAt: string;
+        readonly updatedAt: string;
+    } | null;
     readonly messages: readonly {
         readonly id: string & import("effect/Brand").Brand<"MessageId">;
         readonly role: "user" | "assistant" | "system";