t3code-cli 0.9.1 → 0.10.0

package/README.md

@@ -26,7 +26,7 @@ t3cli auth status
 t3cli project list
 
 # Start a thread
-t3cli thread start "Implement a new feature" --wait
+t3cli start "Implement a new feature" --wait
 ```
 
 ## Agent Skill
@@ -68,12 +68,12 @@ t3cli model list [--all] [--provider <provider>]
 
 Lists available provider models. Use `--all` to include hidden or unavailable entries.
 
-## Thread Management
+## Thread Workflow
 
 ### Starting Threads
 
 ```sh
-t3cli thread start [message]
+t3cli start [message]
   [--project <ref>]
   [--stdin]
   [--title <title>]
@@ -88,17 +88,23 @@ t3cli thread start [message]
   [--wait]
 ```
 
-### Thread Commands
+### Common Thread Commands
 
 ```sh
-t3cli thread list [--project <ref>]              # List threads
-t3cli thread show [--thread <id>]                # Show thread details
-t3cli thread send [--thread <id>] [message]      # Send message to thread
-t3cli thread messages [--thread <id>] [--limit]  # View messages
-t3cli thread wait [--thread <id>]                # Wait for completion
-t3cli thread archive [--thread <id>]             # Archive thread
-t3cli thread approve --request <id>              # Approve request
-t3cli thread respond --request <id>              # Respond to request
+t3cli list [--project <ref>]                 # List threads
+t3cli show [--thread <id>]                   # Show thread details
+t3cli send [--thread <id>] [message]         # Send message to thread
+t3cli transcript [--thread <id>] [--limit]   # View messages
+t3cli wait [--thread <id>]                   # Wait for completion
+```
+
+### Advanced Thread Commands
+
+```sh
+t3cli thread archive [--thread <id>]        # Archive thread
+t3cli thread approve --request <id>         # Approve request
+t3cli thread respond --request <id>         # Respond to request
+t3cli thread callback --from <id>           # Notify another thread on completion
 ```
 
 ### Environment Variables
@@ -130,8 +136,8 @@ Most commands support:
 Thread commands also support `ndjson` for streaming:
 
 ```sh
-t3cli thread start "task" --format ndjson --wait
-t3cli thread wait --format ndjson
+t3cli start "task" --format ndjson --wait
+t3cli wait --format ndjson
 ```
 
 ## Global Flags

package/dist/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { $d as string$2, $f as runFold, $p as timeoutOrElse, Af as tag, Am as getOrElse, Ap as fail, Bd as waitFormatFlag, Bf as Size, Bm as BaseProto, Bp as matchEffect, Cf as String$1, Cm as Service, Cp as as, Dd as ThreadSessionError, Df as decodeUnknownSync, Dm as flatMap$1, Dp as catchTags, Ed as ProjectLookupError, Ef as decodeUnknownEffect, Em as make$12, Ep as catchFilter, Fd as modelFlags, Ff as Path$1, Fm as match, Fp as forkScoped, Gd as T3Config, Gf as empty, Gm as isUndefined, Gp as result, Hd as canRenderLiveTerminal, Hf as make$9, Hm as isNotNull, Hp as provide$1, Id as projectFlag, If as TypeId$4, Im as none, Ip as gen, J as NodeEnvironmentLive, Jd as choice, Jf as merge, Jp as serviceOption, Kd as T3Auth, Kf as fromIterable, Km as dual, Kp as runFork, Ld as projectPathFlag, Lf as FileDescriptor, Lm as some, Lp as ignore, Md as resolveWorktreePath, Mf as make$8, Mm as isNone, Mp as fn, Nd as T3Application, Nf as fromReadable, Nm as isSome, Np as fnUntraced, Od as CliPath, Of as fromJsonString, Om as fromNullishOr, Op as catch_, Pd as formatFlag, Pf as fromWritable, Pm as map$3, Pp as forEach, Qd as optional$2, Qf as runDrain, Qp as tapError, Rd as threadFlag, Rf as FileSystem, Rm as Prototype, Rp as interrupt, Sf as Literal, Sm as Reference, Sp as andThen, Tf as TaggedErrorClass, Tm as getUnsafe, Tp as callback, Ud as resolveOutputFormat, Uf as callback$1, Um as isNotUndefined, Up as provideContext, Vd as worktreeFlag, Vf as WatchBackend, Vm as hasProperty, Vp as orDie, Wd as Environment, Wf as decodeText, Wm as isNullish, Wp as provideService, X as threadStatus, Xd as integer, Xf as run$1, Xp as suspend, Y as latestAssistantMessage, Yd as choiceWithValue, Yf as mkString, Yp as succeed, Zd as map$2, Zf as runCollect, Zp as sync, _f as ShowHelp, _m as ConsoleRef, _p as systemError, af as getParamMetadata, am as effect, ap as unwrap, bf as isCliError, bm as fail$2, bp as acquireRelease, cf as optional$1, cm as provideMerge, cp as drain, df as getTypeName, dm as MinimumLogLevel, dp as failCauseUnsafe, ef as withAlias, em as tryPromise, ep as runLast, ff as isBoolean, fm as _await, fp as make$11, gf as InvalidValue, gm as succeed$1, gp as badArgument, hf as DuplicateOption, hm as makeUnsafe, hp as BadArgument, if as extractSingleParams, im as fail$1, ip as transduce, jd as resolveThreadId, jf as Crypto, jm as getOrUndefined, jp as flatMap, kd as resolveCommandProjectRef, kf as optionalKey, km as fromUndefinedOr, kp as effectify, lf as string$1, lm as succeed$2, lp as isSink, mf as isTrueValue, mm as isDone, mp as offerUnsafe, nf as withDescription$1, nm as uninterruptible, np as succeed$4, of as isFlagParam, om as mergeAll, op as get, pf as isFalseValue, pm as doneUnsafe, pp as offer, qd as boolean, qf as isStream, qm as pipe, qp as scoped, rf as argumentKind, rm as void_, rp as tap, sf as isParam, sl as ProviderUserInputAnswers, sm as provide, sp as make$10, t as AppLayer, tf as withDefault, tm as try_, tp as splitLines, uf as getChoiceKeys, um as sync$2, up as endUnsafe, vf as UnknownSubcommand, vm as sync$1, vp as nominal, wf as Struct, wm as empty$1, wp as asVoid, xf as ErrorClass, xm as succeed$3, xp as addFinalizer, yf as UnrecognizedOption, ym as map$1, yp as makeRunMain, zd as threadFormatFlag, zf as FileTypeId, zm as withFiber, zp as map } from "./shared.js";
+import { $d as string$2, $f as runFold, $p as timeoutOrElse, Af as tag, Am as getOrElse, Ap as fail, Bd as waitFormatFlag, Bf as Size, Bm as BaseProto, Bp as matchEffect, Cf as String$1, Cm as Service, Cp as as, Df as decodeUnknownSync, Dm as flatMap$1, Dp as catchTags, Ef as decodeUnknownEffect, Em as make$12, Ep as catchFilter, Fd as modelFlags, Ff as Path$1, Fm as match, Fp as forkScoped, Gd as T3Config, Gf as empty, Gm as isUndefined, Gp as result, Hd as canRenderLiveTerminal, Hf as make$9, Hm as isNotNull, Hp as provide$1, Id as projectFlag, If as TypeId$4, Im as none, Ip as gen, J as NodeEnvironmentLive, Jd as choice, Jf as merge, Jp as serviceOption, Kd as T3Auth, Kf as fromIterable, Km as dual, Kp as runFork, Ld as projectPathFlag, Lf as FileDescriptor, Lm as some, Lp as ignore, Md as resolveWorktreePath, Mf as make$8, Mm as isNone, Mp as fn, Nd as T3Application, Nf as fromReadable, Nm as isSome, Np as fnUntraced, Od as CliPath, Of as fromJsonString, Om as fromNullishOr, Op as catch_, Pd as formatFlag, Pf as fromWritable, Pm as map$3, Pp as forEach, Q as ThreadSessionError, Qd as optional$2, Qf as runDrain, Qp as tapError, Rd as threadFlag, Rf as FileSystem, Rm as Prototype, Rp as interrupt, Sf as Literal, Sm as Reference, Sp as andThen, Tf as TaggedErrorClass, Tm as getUnsafe, Tp as callback, Ud as resolveOutputFormat, Uf as callback$1, Um as isNotUndefined, Up as provideContext, Vd as worktreeFlag, Vf as WatchBackend, Vm as hasProperty, Vp as orDie, Wd as Environment, Wf as decodeText, Wm as isNullish, Wp as provideService, X as threadStatus, Xd as integer, Xf as run$1, Xp as suspend, Y as latestAssistantMessage, Yd as choiceWithValue, Yf as mkString, Yp as succeed, Z as ProjectLookupError, Zd as map$2, Zf as runCollect, Zp as sync, _f as ShowHelp, _m as ConsoleRef, _p as systemError, af as getParamMetadata, am as effect, ap as unwrap, bf as isCliError, bm as fail$2, bp as acquireRelease, cf as optional$1, cm as provideMerge, cp as drain, df as getTypeName, dm as MinimumLogLevel, dp as failCauseUnsafe, ef as withAlias, em as tryPromise, ep as runLast, ff as isBoolean, fm as _await, fp as make$11, gf as InvalidValue, gm as succeed$1, gp as badArgument, hf as DuplicateOption, hm as makeUnsafe, hp as BadArgument, if as extractSingleParams, im as fail$1, ip as transduce, jd as resolveThreadId, jf as Crypto, jm as getOrUndefined, jp as flatMap, kd as resolveCommandProjectRef, kf as optionalKey, km as fromUndefinedOr, kp as effectify, lf as string$1, ll as ProviderUserInputAnswers, lm as succeed$2, lp as isSink, mf as isTrueValue, mm as isDone, mp as offerUnsafe, nf as withDescription$1, nm as uninterruptible, np as succeed$4, of as isFlagParam, om as mergeAll, op as get, pf as isFalseValue, pm as doneUnsafe, pp as offer, qd as boolean, qf as isStream, qm as pipe, qp as scoped, rf as argumentKind, rm as void_, rp as tap, sf as isParam, sm as provide, sp as make$10, t as AppLayer, tf as withDefault, tm as try_, tp as splitLines, uf as getChoiceKeys, um as sync$2, up as endUnsafe, vf as UnknownSubcommand, vm as sync$1, vp as nominal, wf as Struct, wm as empty$1, wp as asVoid, xf as ErrorClass, xm as succeed$3, xp as addFinalizer, yf as UnrecognizedOption, ym as map$1, yp as makeRunMain, zd as threadFormatFlag, zf as FileTypeId, zm as withFiber, zp as map } from "./shared.js";
 import * as NodeChildProcess from "node:child_process";
 import * as NodeCrypto from "node:crypto";
 import * as NFS from "node:fs";
@@ -4483,6 +4483,73 @@ const callbackThreadCommand = make("callback", {
 	yield* output.printInfo(`callback sent to ${result.targetThreadId} (dispatch: ${result.dispatch.sequence})`);
 })).pipe(withDescription("watch a thread and send a message when it completes"));
 //#endregion
+//#region src/cli/message-input.ts
+function readInitialMessage(input) {
+	if (input.message !== void 0 && input.message.length > 0 && input.fromStdin) return fail(new MessageInputError({ message: "pass message argument or --stdin, not both" }));
+	if (input.fromStdin) return input.readStdin();
+	if (input.message === void 0 || input.message.length === 0) return fail(new MessageInputError({ message: "message required unless --stdin is used" }));
+	return succeed(input.message);
+}
+function readJsonAnswers(input) {
+	if (input.answers !== void 0 && input.answers.length > 0 && input.fromStdin) return fail(new MessageInputError({ message: "pass --answers or --stdin, not both" }));
+	if (input.fromStdin) return input.readStdin().pipe(flatMap(parseJsonAnswers));
+	if (input.answers === void 0 || input.answers.length === 0) return fail(new MessageInputError({ message: "answers required unless --stdin is used" }));
+	return parseJsonAnswers(input.answers);
+}
+function parseJsonAnswers(text) {
+	try {
+		const parsed = JSON.parse(text);
+		return succeed(decodeUnknownSync(ProviderUserInputAnswers)(parsed));
+	} catch {
+		return fail(new MessageInputError({ message: "invalid JSON in answers" }));
+	}
+}
+//#endregion
+//#region src/cli/input/service.ts
+var T3Input = class extends Service()("t3cli/T3Input") {};
+const respondThreadCommand = make("respond", {
+	thread: threadFlag,
+	request: string$2("request").pipe(withDescription$1("Pending user-input request id"), optional$2),
+	answers: string$2("answers").pipe(optional$2),
+	stdin: boolean("stdin"),
+	format: formatFlag
+}, ({ thread, request, answers, stdin, format }) => gen(function* () {
+	const inputService = yield* T3Input;
+	const parsedAnswers = yield* readJsonAnswers({
+		answers: getOrUndefined(answers),
+		fromStdin: stdin,
+		readStdin: inputService.readStdin
+	});
+	const application = yield* T3Application;
+	const environment = yield* Environment;
+	const output = yield* T3Output;
+	const threadId = resolveThreadId({
+		value: getOrUndefined(thread),
+		env: environment.env
+	});
+	if (threadId === void 0) return yield* fail(new MissingThreadError({ message: "thread id is required: pass --thread or set T3CODE_THREAD_ID" }));
+	const requestId = getOrUndefined(request);
+	if (requestId === void 0 || requestId.length === 0) return yield* fail(new MissingRequestError({ message: "request id is required: pass --request" }));
+	const resolvedFormat = resolveOutputFormat(format, environment, "json");
+	const result = yield* application.respondToThread({
+		threadId,
+		requestId,
+		answers: parsedAnswers
+	});
+	if (resolvedFormat === "json") return yield* output.printJson(result);
+	return yield* output.printInfo(`user input submitted: ${result.requestId}\nsequence: ${result.dispatch.sequence}`);
+})).pipe(withDescription("respond to a pending user-input request"));
+//#endregion
+//#region src/cli/thread.ts
+function createThreadCommand() {
+	return make("thread").pipe(withDescription("advanced thread commands"), withSubcommands([
+		approveThreadCommand,
+		respondThreadCommand,
+		archiveThreadCommand,
+		callbackThreadCommand
+	]));
+}
+//#endregion
 //#region src/cli/require.ts
 const requireCommandProjectRef = fn("requireCommandProjectRef")(function* (input) {
 	const resolved = yield* (yield* T3Config).resolve();
@@ -4604,88 +4671,6 @@ const listThreadsCommand = make("list", {
 	else yield* output.writeStdout(formatThreadsHuman(result.threads));
 })).pipe(withDescription("list project threads"));
 //#endregion
-//#region src/cli/threads/messages.ts
-const getThreadMessagesCommand = make("messages", {
-	thread: threadFlag,
-	limit: integer("limit").pipe(withDefault(20)),
-	full: boolean("full"),
-	format: formatFlag
-}, ({ thread, limit, full, format }) => gen(function* () {
-	if (limit < 0) return yield* fail(new InvalidLimitError({
-		message: `invalid limit: ${limit}`,
-		value: String(limit)
-	}));
-	const application = yield* T3Application;
-	const environment = yield* Environment;
-	const output = yield* T3Output;
-	const threadId = resolveThreadId({
-		value: getOrUndefined(thread),
-		env: environment.env
-	});
-	if (threadId === void 0) return yield* fail(new MissingThreadError({ message: "thread id is required: pass --thread or set T3CODE_THREAD_ID" }));
-	const resolvedFormat = resolveOutputFormat(format, environment, "json");
-	const detail = yield* application.getThreadMessages(threadId);
-	if (resolvedFormat === "json") return yield* output.printJson(formatThreadMessagesJson(detail, full));
-	return yield* output.writeStdout(formatThreadMessagesHuman(detail, limit));
-})).pipe(withDescription("get latest thread messages"));
-//#endregion
-//#region src/cli/message-input.ts
-function readInitialMessage(input) {
-	if (input.message !== void 0 && input.message.length > 0 && input.fromStdin) return fail(new MessageInputError({ message: "pass message argument or --stdin, not both" }));
-	if (input.fromStdin) return input.readStdin();
-	if (input.message === void 0 || input.message.length === 0) return fail(new MessageInputError({ message: "message required unless --stdin is used" }));
-	return succeed(input.message);
-}
-function readJsonAnswers(input) {
-	if (input.answers !== void 0 && input.answers.length > 0 && input.fromStdin) return fail(new MessageInputError({ message: "pass --answers or --stdin, not both" }));
-	if (input.fromStdin) return input.readStdin().pipe(flatMap(parseJsonAnswers));
-	if (input.answers === void 0 || input.answers.length === 0) return fail(new MessageInputError({ message: "answers required unless --stdin is used" }));
-	return parseJsonAnswers(input.answers);
-}
-function parseJsonAnswers(text) {
-	try {
-		const parsed = JSON.parse(text);
-		return succeed(decodeUnknownSync(ProviderUserInputAnswers)(parsed));
-	} catch {
-		return fail(new MessageInputError({ message: "invalid JSON in answers" }));
-	}
-}
-//#endregion
-//#region src/cli/input/service.ts
-var T3Input = class extends Service()("t3cli/T3Input") {};
-const respondThreadCommand = make("respond", {
-	thread: threadFlag,
-	request: string$2("request").pipe(withDescription$1("Pending user-input request id"), optional$2),
-	answers: string$2("answers").pipe(optional$2),
-	stdin: boolean("stdin"),
-	format: formatFlag
-}, ({ thread, request, answers, stdin, format }) => gen(function* () {
-	const inputService = yield* T3Input;
-	const parsedAnswers = yield* readJsonAnswers({
-		answers: getOrUndefined(answers),
-		fromStdin: stdin,
-		readStdin: inputService.readStdin
-	});
-	const application = yield* T3Application;
-	const environment = yield* Environment;
-	const output = yield* T3Output;
-	const threadId = resolveThreadId({
-		value: getOrUndefined(thread),
-		env: environment.env
-	});
-	if (threadId === void 0) return yield* fail(new MissingThreadError({ message: "thread id is required: pass --thread or set T3CODE_THREAD_ID" }));
-	const requestId = getOrUndefined(request);
-	if (requestId === void 0 || requestId.length === 0) return yield* fail(new MissingRequestError({ message: "request id is required: pass --request" }));
-	const resolvedFormat = resolveOutputFormat(format, environment, "json");
-	const result = yield* application.respondToThread({
-		threadId,
-		requestId,
-		answers: parsedAnswers
-	});
-	if (resolvedFormat === "json") return yield* output.printJson(result);
-	return yield* output.printInfo(`user input submitted: ${result.requestId}\nsequence: ${result.dispatch.sequence}`);
-})).pipe(withDescription("respond to a pending user-input request"));
-//#endregion
 //#region src/cli/model-options.ts
 function buildModelOptions(input) {
 	const options = /* @__PURE__ */ new Map();
@@ -4948,6 +4933,31 @@ const startThreadCommand = make("start", {
 	}));
 })).pipe(withDescription("start thread with initial message"));
 //#endregion
+//#region src/cli/threads/messages.ts
+const getThreadTranscriptCommand = make("transcript", {
+	thread: threadFlag,
+	limit: integer("limit").pipe(withDefault(20)),
+	full: boolean("full"),
+	format: formatFlag
+}, ({ thread, limit, full, format }) => gen(function* () {
+	if (limit < 0) return yield* fail(new InvalidLimitError({
+		message: `invalid limit: ${limit}`,
+		value: String(limit)
+	}));
+	const application = yield* T3Application;
+	const environment = yield* Environment;
+	const output = yield* T3Output;
+	const threadId = resolveThreadId({
+		value: getOrUndefined(thread),
+		env: environment.env
+	});
+	if (threadId === void 0) return yield* fail(new MissingThreadError({ message: "thread id is required: pass --thread or set T3CODE_THREAD_ID" }));
+	const resolvedFormat = resolveOutputFormat(format, environment, "json");
+	const detail = yield* application.getThreadMessages(threadId);
+	if (resolvedFormat === "json") return yield* output.printJson(formatThreadMessagesJson(detail, full));
+	return yield* output.writeStdout(formatThreadMessagesHuman(detail, limit));
+})).pipe(withDescription("get latest thread transcript"));
+//#endregion
 //#region src/cli/threads/wait.ts
 const waitForThreadCommand = make("wait", {
 	thread: threadFlag,
@@ -4968,28 +4978,18 @@ const waitForThreadCommand = make("wait", {
 	});
 })).pipe(withDescription("wait for thread to pause"));
 //#endregion
-//#region src/cli/thread.ts
-function createThreadCommand() {
-	return make("thread").pipe(withDescription("thread commands"), withSubcommands([
-		listThreadsCommand,
-		startThreadCommand,
-		sendThreadCommand,
-		showThreadCommand,
-		approveThreadCommand,
-		respondThreadCommand,
-		archiveThreadCommand,
-		getThreadMessagesCommand,
-		waitForThreadCommand,
-		callbackThreadCommand
-	]));
-}
-//#endregion
 //#region src/cli/app.ts
 function createCliCommand() {
 	return make("t3cli").pipe(withDescription("non-interactive cli for running t3code server"), withSubcommands([
 		createAuthCommand(),
+		listThreadsCommand,
 		createModelCommand(),
 		createProjectCommand(),
+		startThreadCommand,
+		sendThreadCommand,
+		showThreadCommand,
+		getThreadTranscriptCommand,
+		waitForThreadCommand,
 		createThreadCommand()
 	]));
 }
@@ -5055,7 +5055,7 @@ var T3Version = class extends Service()("t3cli/T3Version") {};
 //#endregion
 //#region src/version/layer.ts
 const PackageJsonSchema = fromJsonString(Struct({ version: String$1 }));
-const T3VersionBundledLive = sync$2(T3Version, () => ({ version: "0.9.1" }));
+const T3VersionBundledLive = sync$2(T3Version, () => ({ version: "0.10.0" }));
 effect(T3Version, gen(function* () {
 	const packageJson = yield* (yield* FileSystem).readFileString(fileURLToPath(new URL("../../package.json", import.meta.url)));
 	return { version: (yield* decodeUnknownEffect(PackageJsonSchema)(packageJson)).version };

package/dist/shared.js

@@ -43344,22 +43344,6 @@ function resolveThreadId(input) {
 //#region src/cli-path/service.ts
 var CliPath = class extends Service$1()("t3cli/CliPath") {};
 //#endregion
-//#region src/domain/error.ts
-var ProjectLookupError = class extends TaggedErrorClass()("ProjectLookupError", {
-	message: String$1,
-	ref: String$1
-}) {};
-var ModelSelectionError = class extends TaggedErrorClass()("ModelSelectionError", { message: String$1 }) {};
-TaggedErrorClass()("ThreadEventError", { message: String$1 });
-var ThreadSessionError = class extends TaggedErrorClass()("ThreadSessionError", {
-	message: String$1,
-	threadId: String$1
-}) {};
-var ProjectCreateVisibilityError = class extends TaggedErrorClass()("ProjectCreateVisibilityError", {
-	message: String$1,
-	projectId: String$1
-}) {};
-//#endregion
 //#region upstream-t3code/packages/contracts/src/baseSchemas.ts
 const TrimmedString = String$1.pipe(decodeTo(String$1, transformOrFail({
 	decode: (value) => succeed$2(value.trim()),
@@ -52958,9 +52942,27 @@ const WsSubscribeAuthAccessRpc = make$6(WS_METHODS.subscribeAuthAccess, {
 });
 const WsRpcGroup = make$5(WsServerGetConfigRpc$1, WsServerRefreshProvidersRpc, WsServerUpdateProviderRpc, WsServerUpsertKeybindingRpc, WsServerRemoveKeybindingRpc, WsServerGetSettingsRpc, WsServerUpdateSettingsRpc, WsServerDiscoverSourceControlRpc, WsServerGetTraceDiagnosticsRpc, WsServerGetProcessDiagnosticsRpc, WsServerGetProcessResourceHistoryRpc, WsServerSignalProcessRpc, WsCloudGetRelayClientStatusRpc, WsCloudInstallRelayClientRpc, WsSourceControlLookupRepositoryRpc, WsSourceControlCloneRepositoryRpc, WsSourceControlPublishRepositoryRpc, WsProjectsSearchEntriesRpc, WsProjectsWriteFileRpc, WsShellOpenInEditorRpc, WsFilesystemBrowseRpc, WsSubscribeVcsStatusRpc, WsVcsPullRpc, WsVcsRefreshStatusRpc, WsGitRunStackedActionRpc, WsGitResolvePullRequestRpc, WsGitPreparePullRequestThreadRpc, WsVcsListRefsRpc, WsVcsCreateWorktreeRpc, WsVcsRemoveWorktreeRpc, WsVcsCreateRefRpc, WsVcsSwitchRefRpc, WsVcsInitRpc, WsReviewGetDiffPreviewRpc, WsTerminalOpenRpc, WsTerminalAttachRpc, WsTerminalWriteRpc, WsTerminalResizeRpc, WsTerminalClearRpc, WsTerminalRestartRpc, WsTerminalCloseRpc, WsSubscribeTerminalEventsRpc, WsSubscribeTerminalMetadataRpc, WsSubscribeServerConfigRpc, WsSubscribeServerLifecycleRpc, WsSubscribeAuthAccessRpc, WsOrchestrationDispatchCommandRpc, WsOrchestrationGetTurnDiffRpc, WsOrchestrationGetFullThreadDiffRpc, WsOrchestrationReplayEventsRpc, WsOrchestrationGetArchivedShellSnapshotRpc, WsOrchestrationSubscribeShellRpc, WsOrchestrationSubscribeThreadRpc);
 //#endregion
+//#region src/domain/error.ts
+var ProjectLookupError = class extends TaggedErrorClass()("ProjectLookupError", {
+	message: String$1,
+	ref: String$1
+}) {};
+var ModelSelectionError = class extends TaggedErrorClass()("ModelSelectionError", { message: String$1 }) {};
+TaggedErrorClass()("ThreadEventError", { message: String$1 });
+var ThreadSessionError = class extends TaggedErrorClass()("ThreadSessionError", {
+	message: String$1,
+	threadId: String$1
+}) {};
+var ProjectCreateVisibilityError = class extends TaggedErrorClass()("ProjectCreateVisibilityError", {
+	message: String$1,
+	projectId: String$1
+}) {};
+//#endregion
 //#region src/domain/thread-lifecycle.ts
 function isThreadActive(thread) {
-	return thread.session?.status === "starting" || thread.session?.status === "running" || thread.latestTurn?.state === "running" || isPendingStart(thread);
+	if (thread.session?.status === "starting" || thread.session?.status === "running") return true;
+	if (thread.latestTurn?.state === "running") return !("messages" in thread && hasTerminalSession(thread) && isThreadCompleteEnough(thread));
+	return isPendingStart(thread);
 }
 function threadStatus(thread) {
 	if (isPendingStart(thread)) return "pending";
@@ -53013,6 +53015,9 @@ function isPendingStart(thread) {
 	if (thread.session !== null || thread.latestTurn !== null || !("messages" in thread)) return false;
 	return thread.messages.at(-1)?.role === "user";
 }
+function hasTerminalSession(thread) {
+	return thread.session !== null && thread.session?.status !== "starting" && thread.session?.status !== "running";
+}
 //#endregion
 //#region src/environment/layer.ts
 const NodeEnvironmentLive = succeed$3(Environment)({
@@ -85489,4 +85494,4 @@ const T3ApplicationLayer = T3ApplicationLive.pipe(provide$2(T3OrchestrationLayer
 const AuthAppLayer = mergeAll$1(T3ConfigLive, T3AuthLayer);
 const AppLayer = mergeAll$1(T3ConfigLive, T3AuthLayer, T3RpcLayer, T3OrchestrationLayer, T3ApplicationLayer, NodeCliPathLayer);
 //#endregion
-export { WsCloudInstallRelayClientRpc as $, ProviderSendTurnInput as $a, ProjectionPendingApprovalDecision as $c, string as $d, runFold as $f, OpenCodeSettings as $i, ProviderInstanceEnvironmentVariable as $l, SourceControlDiscoveryResult as $n, DesktopUpdateStatusSchema as $o, timeoutOrElse as $p, ServerProcessResourceHistorySummary as $r, ModelSelection as $s, ReviewDiffPreviewInput as $t, AuthWebSocketTicketResult as $u, T3LocalAuthOriginLive as A, ResolvedKeybindingRule as Aa, OrchestrationSession as Ac, resolveProjectRef as Ad, tag as Af, ServerUpsertKeybindingInput as Ai, ThreadTurnStartCommand as Al, getOrElse$1 as Am, VcsCreateRefInput as An, DesktopEnvironmentBootstrapSchema as Ao, fail$2 as Ap, VcsUnsupportedOperationError as Ar, EnvironmentHttpBadRequestError as As, WsSourceControlPublishRepositoryRpc as At, AuthBrowserSessionResult as Au, AuthLocalSigningError as B, ProviderRuntimeThreadGoalStatus as Ba, OrchestrationThreadGoal as Bc, waitFormatFlag as Bd, Size as Bf, DEFAULT_CLIENT_SETTINGS as Bi, ModelCapabilities as Bl, BaseProto as Bm, VcsRemoveWorktreeInput as Bn, DesktopSshEnvironmentEnsureResultSchema as Bo, matchEffect as Bp, ServerConfigStreamSnapshotEvent as Br, EnvironmentOperationForbiddenReason as Bs, WsTerminalOpenRpc as Bt, AuthOrchestrationReadScope as Bu, T3LocalAuth as C, MAX_KEYBINDINGS_COUNT as Ca, OrchestrationProjectShell as Cc, TrimmedNonEmptyString as Cd, String$1 as Cf, ServerTraceDiagnosticsErrorKind as Ci, ThreadRevertedPayload as Cl, Service$1 as Cm, GitPullRequestRefInput as Cn, TerminalWriteInput as Co, as as Cp, VcsOutputDecodeError as Cr, EnvironmentAuthenticatedPrincipal as Cs, WsServerSignalProcessRpc as Ct, AuthAccessStreamPairingLinkUpsertedEvent as Cu, T3LocalAuthTokenLive as D, MAX_WHEN_EXPRESSION_DEPTH as Da, OrchestrationReplayEventsError as Dc, ThreadSessionError as Dd, decodeUnknownSync as Df, ServerTraceDiagnosticsResult as Di, ThreadTurnDiff as Dl, flatMap$4 as Dm, GitRunStackedActionToastRunAction as Dn, DesktopCloudAuthFetchInputSchema as Do, catchTags$1 as Dp, VcsRemote as Dr, EnvironmentCloudRelayConfigResult as Ds, WsShellOpenInEditorRpc as Dt, AuthAccessWriteScope as Du, T3LocalAuthToken as E, MAX_SCRIPT_ID_LENGTH as Ea, OrchestrationReadModel as Ec, ProjectLookupError as Ed, decodeUnknownEffect as Ef, ServerTraceDiagnosticsRecentFailure as Ei, ThreadSessionStopRequestedPayload as El, make$41 as Em, GitRunStackedActionResult as En, DesktopAppStageLabelSchema as Eo, catchFilter$2 as Ep, VcsProcessTimeoutError as Er, EnvironmentCloudPreferencesRequest as Es, WsServerUpsertKeybindingRpc as Et, AuthAccessTokenType as Eu, T3CodeConnectionError as F, CanonicalItemType as Fa, OrchestrationSubscribeThreadInput as Fc, modelFlags as Fd, Path as Ff, ClientSettingsSchema as Fi, DEFAULT_GIT_TEXT_GENERATION_MODEL as Fl, match$3 as Fm, VcsListRefsInput as Fn, DesktopSshBearerBootstrapInputSchema as Fo, forkScoped as Fp, ServerConfigSettingsUpdatedPayload as Fr, EnvironmentHttpUnauthorizedError as Fs, WsSubscribeTerminalMetadataRpc as Ft, AuthCreatePairingCredentialInput as Fu, T3Orchestration as G, ToolLifecycleItemType as Ga, PROVIDER_SEND_TURN_MAX_IMAGE_BYTES as Gc, T3Config as Gd, empty$6 as Gf, DEFAULT_SIDEBAR_THREAD_PREVIEW_COUNT as Gi, ProviderOptionSelection as Gl, isUndefined as Gm, VcsStatusStreamEvent as Gn, DesktopSshPasswordPromptCancelledType as Go, result as Gp, ServerLifecycleStreamWelcomeEvent as Gr, AssistantDeliveryMode as Gs, WsVcsCreateWorktreeRpc as Gt, AuthReviewWriteScope as Gu, AuthTransportError as H, RuntimeEventRaw as Ha, OrchestrationThreadShell as Hc, canRenderLiveTerminal as Hd, make$25 as Hf, DEFAULT_SERVER_SETTINGS as Hi, ProviderOptionChoice as Hl, isNotNull as Hm, VcsStatusLocalResult as Hn, DesktopSshHostSourceSchema as Ho, provide as Hp, ServerLifecycleReadyPayload as Hr, EnvironmentRequestInvalidError as Hs, WsTerminalRestartRpc as Ht, AuthPairingLink as Hu, AuthConfigError as I, CanonicalRequestType as Ia, OrchestrationThread as Ic, projectFlag as Id, TypeId$32 as If, CodexSettings as Ii, DEFAULT_GIT_TEXT_GENERATION_MODEL_BY_PROVIDER as Il, none as Im, VcsListRefsResult as In, DesktopSshBearerRequestInputSchema as Io, gen as Ip, ServerConfigStreamEvent as Ir, EnvironmentInternalError as Is, WsSubscribeVcsStatusRpc as It, AuthEnvironmentBootstrapTokenType as Iu, NodeEnvironmentLive as J, ProviderEvent as Ja, ProjectCreatedPayload as Jc, choice as Jd, merge$1 as Jf, DEFAULT_UNIFIED_SETTINGS as Ji, SelectProviderOptionDescriptor as Jl, ChangeRequest as Jn, DesktopThemeSchema as Jo, serviceOption as Jp, ServerProcessDiagnosticsEntry as Jr, ClientOrchestrationCommand as Js, WsVcsPullRpc as Jt, AuthSessionState as Ju, layerWebSocketConstructor as K, UserInputQuestion as Ka, PROVIDER_SEND_TURN_MAX_INPUT_CHARS as Kc, T3Auth as Kd, fromIterable$1 as Kf, DEFAULT_SIDEBAR_THREAD_SORT_ORDER as Ki, ProviderOptionSelectionValue as Kl, dual as Km, VcsSwitchRefInput as Kn, DesktopSshPasswordPromptRequestSchema as Ko, runFork as Kp, ServerLifecycleWelcomePayload as Kr, ChatAttachment as Ks, WsVcsInitRpc as Kt, AuthRevokeClientSessionInput as Ku, AuthLocalDatabaseError as L, ItemLifecyclePayload as La, OrchestrationThreadActivity as Lc, projectPathFlag as Ld, FileDescriptor as Lf, ContextMenuStyle as Li, DEFAULT_MODEL as Ll, some as Lm, VcsPullInput as Ln, DesktopSshEnvironmentBootstrapSchema as Lo, ignore$1 as Lp, ServerConfigStreamKeybindingsUpdatedEvent as Lr, EnvironmentInternalErrorReason as Ls, WsTerminalAttachRpc as Lt, AuthEnvironmentScope as Lu, readT3LayoutFromNodeProcess as M, SCRIPT_RUN_COMMAND_PATTERN as Ma, OrchestrationShellSnapshot as Mc, resolveWorktreePath as Md, make$24 as Mf, isProviderAvailable as Mi, ThreadUnarchivedPayload as Ml, isNone as Mm, VcsCreateWorktreeInput as Mn, DesktopRuntimeInfoSchema as Mo, fn as Mp, ServerConfigIssue as Mr, EnvironmentHttpConflictError as Ms, WsSubscribeServerConfigRpc as Mt, AuthClientMetadataDeviceType as Mu, resolveT3BaseDir as N, THREAD_JUMP_KEYBINDING_COMMANDS as Na, OrchestrationShellStreamEvent as Nc, T3Application as Nd, fromReadable as Nf, ClaudeSettings as Ni, TurnCountRange as Nl, isSome as Nm, VcsCreateWorktreeResult as Nn, DesktopServerExposureModeSchema as No, fnUntraced as Np, ServerConfigKeybindingsUpdatedPayload as Nr, EnvironmentHttpForbiddenError as Ns, WsSubscribeServerLifecycleRpc as Nt, AuthClientPresentationMetadata as Nu, makeT3LocalAuthToken as O, MODEL_PICKER_JUMP_KEYBINDING_COMMANDS as Oa, OrchestrationReplayEventsInput as Oc, CliPath as Od, fromJsonString as Of, ServerTraceDiagnosticsSpanOccurrence as Oi, ThreadTurnDiffCompletedPayload as Ol, fromNullishOr as Om, GitStackedAction as On, DesktopCloudAuthFetchResultSchema as Oo, catch_$1 as Op, VcsRepositoryDetectionError as Or, EnvironmentConnectHttpApi as Os, WsSourceControlCloneRepositoryRpc as Ot, AuthAdministrativeScopes as Ou, RpcError as P, THREAD_KEYBINDING_COMMANDS as Pa, OrchestrationShellStreamItem as Pc, formatFlag as Pd, fromWritable as Pf, ClientSettingsPatch as Pi, BooleanProviderOptionDescriptor as Pl, map$9 as Pm, VcsInitInput as Pn, DesktopServerExposureStateSchema as Po, forEach$1 as Pp, ServerConfigProviderStatusesPayload as Pr, EnvironmentHttpInternalServerError as Ps, WsSubscribeTerminalEventsRpc as Pt, AuthClientSession as Pu, WsCloudGetRelayClientStatusRpc as Q, ProviderRespondToUserInputInput as Qa, ProjectScriptIcon as Qc, optional as Qd, runDrain as Qf, ObservabilitySettings as Qi, ProviderInstanceEnvironment as Ql, SourceControlCloneRepositoryResult as Qn, DesktopUpdateStateSchema as Qo, tapError$2 as Qp, ServerProcessResourceHistoryResult as Qr, DispatchResult as Qs, ReviewDiffPreviewError as Qt, AuthTokenExchangeRequest as Qu, AuthLocalError as R, ProviderRuntimeEvent as Ra, OrchestrationThreadActivityTone as Rc, threadFlag as Rd, FileSystem as Rf, CursorSettings as Ri, DEFAULT_MODEL_BY_PROVIDER as Rl, Prototype as Rm, VcsPullResult as Rn, DesktopSshEnvironmentEnsureInputSchema as Ro, interrupt$1 as Rp, ServerConfigStreamProviderStatusesEvent as Rr, EnvironmentMetadataHttpApi as Rs, WsTerminalClearRpc as Rt, AuthEnvironmentScopes as Ru, T3AuthTransportLive as S, KeybindingsConfigError as Sa, OrchestrationProject as Sc, ThreadId as Sd, Literal as Sf, ServerSignalProcessResult as Si, ThreadProposedPlanUpsertedPayload as Sl, Reference as Sm, GitPreparePullRequestThreadResult as Sn, TerminalThreadInput as So, andThen as Sp, VcsListWorkspaceFilesResult as Sr, EnvironmentAuthenticatedAuth as Ss, WsServerRemoveKeybindingRpc as St, AuthAccessStreamPairingLinkRemovedEvent as Su, makeT3LocalAuth as T, MAX_KEYBINDING_WHEN_LENGTH as Ta, OrchestrationProposedPlanId as Tc, TurnId as Td, TaggedErrorClass as Tf, ServerTraceDiagnosticsLogEvent as Ti, ThreadSessionSetPayload as Tl, getUnsafe$2 as Tm, GitRunStackedActionInput as Tn, DesktopAppBrandingSchema as To, callback$1 as Tp, VcsProcessSpawnError as Tr, EnvironmentCloudLinkStateResult as Ts, WsServerUpdateSettingsRpc as Tt, AuthAccessTokenResult as Tu, ConfigError as U, TOOL_LIFECYCLE_ITEM_TYPES as Ua, OrchestrationThreadStreamItem as Uc, resolveOutputFormat as Ud, callback as Uf, DEFAULT_SIDEBAR_PROJECT_GROUPING_MODE as Ui, ProviderOptionDescriptor as Ul, isNotUndefined as Um, VcsStatusRemoteResult as Un, DesktopSshHttpBaseUrlInputSchema as Uo, provideContext$2 as Up, ServerLifecycleStreamEvent as Ur, EnvironmentRequestInvalidReason as Us, WsTerminalWriteRpc as Ut, AuthRelayReadScope as Uu, AuthPairingUrlError as V, ProviderRuntimeTurnStatus as Va, OrchestrationThreadGoalStatus as Vc, worktreeFlag as Vd, WatchBackend as Vf, DEFAULT_CONTEXT_MENU_STYLE as Vi, PROVIDER_DISPLAY_NAMES as Vl, hasProperty as Vm, VcsStatusInput as Vn, DesktopSshEnvironmentTargetSchema as Vo, orDie as Vp, ServerConfigUpdatedPayload as Vr, EnvironmentOrchestrationHttpApi as Vs, WsTerminalResizeRpc as Vt, AuthPairingCredentialResult as Vu, UrlError as W, ThreadTokenUsageSnapshot as Wa, PROVIDER_SEND_TURN_MAX_ATTACHMENTS as Wc, Environment as Wd, decodeText as Wf, DEFAULT_SIDEBAR_PROJECT_SORT_ORDER as Wi, ProviderOptionDescriptorType as Wl, isNullish as Wm, VcsStatusResult as Wn, DesktopSshPasswordPromptCancelledResultSchema as Wo, provideService$1 as Wp, ServerLifecycleStreamReadyEvent as Wr, EnvironmentScopeRequiredError as Ws, WsVcsCreateRefRpc as Wt, AuthRelayWriteScope as Wu, threadStatus as X, ProviderInterruptTurnInput as Xa, ProjectMetaUpdatedPayload as Xc, integer as Xd, run$1 as Xf, MAX_SIDEBAR_THREAD_PREVIEW_COUNT as Xi, ProviderInstanceConfig as Xl, SourceControlCloneProtocol as Xn, DesktopUpdateChannelSchema as Xo, suspend$3 as Xp, ServerProcessResourceHistoryBucket as Xr, DEFAULT_PROVIDER_INTERACTION_MODE as Xs, WsVcsRemoveWorktreeRpc as Xt, AuthTerminalOperateScope as Xu, latestAssistantMessage as Y, ProviderGoalRequestInput as Ya, ProjectDeletedPayload as Yc, choiceWithValue as Yd, mkString as Yf, GrokSettings as Yi, ProviderDriverKind as Yl, ChangeRequestState as Yn, DesktopUpdateActionResultSchema as Yo, succeed$2 as Yp, ServerProcessDiagnosticsResult as Yr, CorrelationId as Ys, WsVcsRefreshStatusRpc as Yt, AuthStandardClientScopes as Yu, WS_METHODS as Z, ProviderRespondToRequestInput as Za, ProjectScript as Zc, map as Zd, runCollect as Zf, MIN_SIDEBAR_THREAD_PREVIEW_COUNT as Zi, ProviderInstanceConfigMap as Zl, SourceControlCloneRepositoryInput as Zn, DesktopUpdateCheckResultSchema as Zo, sync as Zp, ServerProcessResourceHistoryInput as Zr, DEFAULT_RUNTIME_MODE as Zs, WsVcsSwitchRefRpc as Zt, AuthTokenExchangeGrantType as Zu, makeT3Auth as _, KeybindingShortcut as _a, OrchestrationGetTurnDiffInput as _c, ProviderItemId as _d, ShowHelp as _f, ServerProviderVersionAdvisoryStatus as _i, ThreadGoalRequestedPayload as _l, ConsoleRef as _m, GitActionProgressStream as _n, TerminalRestartInput as _o, systemError as _p, VcsDriverKind as _r, AuthOtherClientSessionsRevokeResult as _s, WsServerGetProcessDiagnosticsRpc as _t, AuthAccessSnapshot as _u, T3AuthTransportLayer as a, SidebarThreadPreviewCount as aa, OrchestrationCheckpointSummary as ac, ApprovalRequestId as ad, getParamMetadata as af, ServerProviderContinuation as ai, ProviderSandboxMode as al, effect as am, FilesystemBrowseInput as an, TerminalAttachInput as ao, unwrap as ap, SourceControlProviderInfo as ar, AdvertisedEndpointProvider as as, WsOrchestrationGetArchivedShellSnapshotRpc as at, EnvironmentConnectionState as au, makeT3AuthPairing as b, KeybindingWhenNode as ba, OrchestrationMessage as bc, RuntimeSessionId as bd, isCliError as bf, ServerRemoveKeybindingResult as bi, ThreadMessageSentPayload as bl, fail$6 as bm, GitManagerServiceError as bn, TerminalSessionStatus as bo, acquireRelease as bp, VcsFreshnessSource as br, EnvironmentAuthInvalidError as bs, WsServerGetTraceDiagnosticsRpc as bt, AuthAccessStreamError as bu, T3LocalAuthTokenLayer as c, TimestampFormat as ca, OrchestrationDispatchCommandError as cc, CommandId as cd, optional$1 as cf, ServerProviderSlashCommand as ci, RuntimeMode as cl, provideMerge as cm, ProjectSearchEntriesError as cn, TerminalCloseInput as co, drain as cp, SourceControlPublishRepositoryResult as cr, AdvertisedEndpointSource as cs, WsOrchestrationReplayEventsRpc as ct, ExecutionEnvironmentPlatform as cu, T3CodeConnectionProvider as d, EditorId as da, OrchestrationEventType as dc, IsoDateTime as dd, getTypeName as df, ServerProviderUpdateError as di, ThreadArchivedPayload as dl, MinimumLogLevel as dm, ProjectWriteFileError as dn, TerminalEvent as do, failCauseUnsafe as dp, SourceControlRepositoryError as dr, RelayClientInstallFailedError as ds, WsProjectsSearchEntriesRpc as dt, RepositoryIdentity as du, ServerSettings as ea, ORCHESTRATION_WS_METHODS as ec, EnvironmentAuthorizationError as ed, withAlias as ef, ServerProcessSignal as ei, ProjectionPendingApprovalStatus as el, tryPromise as em, ReviewDiffPreviewResult as en, ProviderSession as eo, runLast as ep, SourceControlDiscoveryStatus as er, PersistedSavedEnvironmentRecordSchema as es, WsFilesystemBrowseRpc as et, ProviderInstanceEnvironmentVariableName as eu, T3CodeConnectionProviderLive as f, EditorLaunchStyle as fa, OrchestrationGetFullThreadDiffError as fc, MessageId as fd, isBoolean as ff, ServerProviderUpdateInput as fi, ThreadCheckpointRevertRequestedPayload as fl, _await as fm, ProjectWriteFileInput as fn, TerminalHistoryError as fo, make$28 as fp, SourceControlRepositoryInfo as fr, RelayClientInstallFailureReasonSchema as fs, WsProjectsWriteFileRpc as ft, RepositoryIdentityLocator as fu, T3AuthLive as g, KeybindingRule as ga, OrchestrationGetTurnDiffError as gc, ProjectId as gd, InvalidValue as gf, ServerProviderVersionAdvisory as gi, ThreadGoalRequest as gl, succeed$4 as gm, GitActionProgressPhase as gn, TerminalResizeInput as go, badArgument as gp, VcsDriverCapabilities as gr, AuthClientSessionRevokeResult as gs, WsServerGetConfigRpc$1 as gt, AuthAccessReadScope as gu, makeT3Config as h, KeybindingCommand as ha, OrchestrationGetSnapshotError as hc, PositiveInt as hd, DuplicateOption as hf, ServerProviderUpdatedPayload as hi, ThreadGoalClearedPayload as hl, makeUnsafe$8 as hm, GitActionProgressKind as hn, TerminalOpenInput as ho, BadArgument as hp, VcsDiscoveryItem as hr, RelayClientStatusSchema as hs, WsServerDiscoverSourceControlRpc as ht, ScopedThreadSessionRef as hu, T3AuthPairingLayer as i, SidebarProjectSortOrder as ia, OrchestrationCheckpointStatus as ic, ServerAuthSessionMethod as id, extractSingleParams as if, ServerProviderAvailability as ii, ProviderRequestKind as il, fail$3 as im, FilesystemBrowseError as in, DEFAULT_TERMINAL_ID as io, transduce as ip, SourceControlProviderError as ir, AdvertisedEndpointHostedHttpsCompatibility as is, WsOrchestrationDispatchCommandRpc as it, isProviderDriverKind as iu, makeT3LocalAuthOrigin as j, ResolvedKeybindingsConfig as ja, OrchestrationSessionStatus as jc, resolveThreadId as jd, Crypto as jf, ServerUpsertKeybindingResult as ji, ThreadTurnStartRequestedPayload as jl, getOrUndefined as jm, VcsCreateRefResult as jn, DesktopRuntimeArchSchema as jo, flatMap$2 as jp, ServerConfig as jr, EnvironmentHttpCommonError as js, WsSubscribeAuthAccessRpc as jt, AuthClientMetadata as ju, T3LocalAuthOrigin as k, MODEL_PICKER_KEYBINDING_COMMANDS as ka, OrchestrationRpcSchemas as kc, resolveCommandProjectRef as kd, optionalKey as kf, ServerTraceDiagnosticsSpanSummary as ki, ThreadTurnInterruptRequestedPayload as kl, fromUndefinedOr as km, TextGenerationError as kn, DesktopDiscoveredSshHostSchema as ko, effectify as kp, VcsRepositoryIdentity as kr, EnvironmentHttpApi as ks, WsSourceControlLookupRepositoryRpc as kt, AuthBrowserSessionRequest as ku, T3OrchestrationLayer as l, makeProviderSettingsSchema as la, OrchestrationEvent as lc, EnvironmentId as ld, string$1 as lf, ServerProviderSlashCommandInput as li, ThreadActivityAppendedPayload as ll, succeed$3 as lm, ProjectSearchEntriesInput as ln, TerminalCwdError as lo, isSink as lp, SourceControlPublishStatus as lr, AdvertisedEndpointStatus as ls, WsOrchestrationSubscribeShellRpc as lt, ExecutionEnvironmentPlatformArch as lu, T3ConfigLive as m, LaunchEditorInput as ma, OrchestrationGetFullThreadDiffResult as mc, PortSchema as md, isTrueValue as mf, ServerProviderUpdateStatus as mi, ThreadDeletedPayload as ml, isDone$1 as mm, GitActionProgressEvent as mn, TerminalNotRunningError as mo, offerUnsafe as mp, SourceControlRepositoryVisibility as mr, RelayClientInstallProgressStageSchema as ms, WsRpcGroup as mt, ScopedThreadRef as mu, AuthAppLayer as n, ServerSettingsPatch as na, OrchestrationAggregateKind as nc, ServerAuthDescriptor as nd, withDescription as nf, ServerProviderAuth as ni, ProviderApprovalPolicy as nl, uninterruptible as nm, ReviewDiffPreviewSourceKind as nn, ProviderStopSessionInput as no, succeed as np, SourceControlProviderAuthStatus as nr, AdvertisedEndpoint as ns, WsGitResolvePullRequestRpc as nt, ProviderInstanceRef as nu, T3LocalAuthLayer as o, SidebarThreadSortOrder as oa, OrchestrationCommand as oc, AuthSessionId as od, isFlagParam as of, ServerProviderModel as oi, ProviderSessionRuntimeStatus as ol, mergeAll$1 as om, FilesystemBrowseResult as on, TerminalAttachStreamEvent as oo, get$2 as op, SourceControlProviderKind as or, AdvertisedEndpointProviderKind as os, WsOrchestrationGetFullThreadDiffRpc as ot, ExecutionEnvironmentCapabilities as ou, makeT3CodeConnectionProvider as p, ExternalLauncherError as pa, OrchestrationGetFullThreadDiffInput as pc, NonNegativeInt as pd, isFalseValue as pf, ServerProviderUpdateState as pi, ThreadCreatedPayload as pl, doneUnsafe as pm, ProjectWriteFileResult as pn, TerminalMetadataStreamEvent as po, offer as pp, SourceControlRepositoryLookupInput as pr, RelayClientInstallProgressEventSchema as ps, WsReviewGetDiffPreviewRpc as pt, ScopedProjectRef as pu, layerUndici as q, isToolLifecycleItemType as qa, ProjectCreateCommand as qc, boolean as qd, isStream as qf, DEFAULT_TIMESTAMP_FORMAT as qi, ProviderOptionSelections as ql, pipe as qm, VcsSwitchRefResult as qn, DesktopSshPasswordPromptResolutionInputSchema as qo, scoped$2 as qp, ServerObservability as qr, ChatImageAttachment as qs, WsVcsListRefsRpc as qt, AuthRevokePairingLinkInput as qu, T3AuthLayer as r, SidebarProjectGroupingMode as ra, OrchestrationCheckpointFile as rc, ServerAuthPolicy as rd, argumentKind as rf, ServerProviderAuthStatus as ri, ProviderInteractionMode as rl, void_$1 as rm, FilesystemBrowseEntry as rn, ProviderTurnStartResult as ro, tap as rp, SourceControlProviderDiscoveryItem as rr, AdvertisedEndpointCompatibility as rs, WsGitRunStackedActionRpc as rt, defaultInstanceIdForDriver as ru, T3LocalAuthOriginLayer as s, ThreadEnvMode as sa, OrchestrationCommandReceiptStatus as sc, CheckpointRef as sd, isParam as sf, ServerProviderSkill as si, ProviderUserInputAnswers as sl, provide$2 as sm, ProjectEntry as sn, TerminalClearInput as so, make$26 as sp, SourceControlPublishRepositoryInput as sr, AdvertisedEndpointReachability as ss, WsOrchestrationGetTurnDiffRpc as st, ExecutionEnvironmentDescriptor as su, AppLayer as t, ServerSettingsError as ta, OrchestrationActorKind as tc, ServerAuthBootstrapMethod as td, withDefault as tf, ServerProvider as ti, ProviderApprovalDecision as tl, try_ as tm, ReviewDiffPreviewSource as tn, ProviderSessionStartInput as to, splitLines as tp, SourceControlProviderAuth as tr, PickFolderOptionsSchema as ts, WsGitPreparePullRequestThreadRpc as tt, ProviderInstanceId as tu, T3RpcLive as u, EDITORS as ua, OrchestrationEventMetadata as uc, EventId as ud, getChoiceKeys as uf, ServerProviderState as ui, ThreadApprovalResponseRequestedPayload as ul, sync$1 as um, ProjectSearchEntriesResult as un, TerminalError as uo, endUnsafe as up, SourceControlRepositoryCloneUrls as ur, DesktopBackendBootstrap as us, WsOrchestrationSubscribeThreadRpc as ut, ExecutionEnvironmentPlatformOs as uu, T3AuthPairing as v, KeybindingValue as va, OrchestrationGetTurnDiffResult as vc, RuntimeItemId as vd, UnknownSubcommand as vf, ServerProviders as vi, ThreadGoalUpdatedPayload as vl, sync$2 as vm, GitCommandError as vn, TerminalSessionLookupError as vo, nominal as vp, VcsError as vr, AuthPairingLinkRevokeResult as vs, WsServerGetProcessResourceHistoryRpc as vt, AuthAccessStreamClientRemovedEvent as vu, T3LocalAuthLive as w, MAX_KEYBINDING_VALUE_LENGTH as wa, OrchestrationProposedPlan as wc, TrimmedString as wd, Struct as wf, ServerTraceDiagnosticsFailureSummary as wi, ThreadRuntimeModeSetPayload as wl, empty$11 as wm, GitResolvePullRequestResult as wn, ContextMenuItemSchema as wo, asVoid as wp, VcsProcessExitError as wr, EnvironmentCloudEndpointUnavailableError as ws, WsServerUpdateProviderRpc as wt, AuthAccessStreamSnapshotEvent as wu, parsePairingUrl as x, KeybindingsConfig as xa, OrchestrationMessageRole as xc, RuntimeTaskId as xd, ErrorClass as xf, ServerSignalProcessInput as xi, ThreadMetaUpdatedPayload as xl, succeed$6 as xm, GitPreparePullRequestThreadInput as xn, TerminalSummary as xo, addFinalizer as xp, VcsListRemotesResult as xr, EnvironmentAuthInvalidReason as xs, WsServerRefreshProvidersRpc as xt, AuthAccessStreamEvent as xu, T3AuthPairingLive as y, KeybindingWhen as ya, OrchestrationLatestTurn as yc, RuntimeRequestId as yd, UnrecognizedOption as yf, ServerRemoveKeybindingInput as yi, ThreadInteractionModeSetPayload as yl, map$7 as ym, GitManagerError as yn, TerminalSessionSnapshot as yo, makeRunMain as yp, VcsFreshness as yr, EnvironmentAuthHttpApi as ys, WsServerGetSettingsRpc as yt, AuthAccessStreamClientUpsertedEvent as yu, AuthLocalSecretError as z, ProviderRuntimeEventV2 as za, OrchestrationThreadDetailSnapshot as zc, threadFormatFlag as zd, FileTypeId as zf, DEFAULT_AUTOMATIC_GIT_FETCH_INTERVAL as zi, MODEL_SLUG_ALIASES_BY_PROVIDER as zl, withFiber$1 as zm, VcsRef as zn, DesktopSshEnvironmentEnsureOptionsSchema as zo, map$5 as zp, ServerConfigStreamSettingsUpdatedEvent as zr, EnvironmentOperationForbiddenError as zs, WsTerminalCloseRpc as zt, AuthOrchestrationOperateScope as zu };
+export { WS_METHODS as $, ProviderRespondToRequestInput as $a, ProjectScript as $c, string as $d, runFold as $f, MIN_SIDEBAR_THREAD_PREVIEW_COUNT as $i, ProviderInstanceConfigMap as $l, SourceControlCloneRepositoryInput as $n, DesktopUpdateCheckResultSchema as $o, timeoutOrElse as $p, ServerProcessResourceHistoryInput as $r, DEFAULT_RUNTIME_MODE as $s, WsVcsSwitchRefRpc as $t, AuthTokenExchangeGrantType as $u, T3LocalAuthOriginLive as A, MODEL_PICKER_JUMP_KEYBINDING_COMMANDS as Aa, OrchestrationReplayEventsInput as Ac, resolveProjectRef as Ad, tag as Af, ServerTraceDiagnosticsSpanOccurrence as Ai, ThreadTurnDiffCompletedPayload as Al, getOrElse$1 as Am, GitStackedAction as An, DesktopCloudAuthFetchResultSchema as Ao, fail$2 as Ap, VcsRepositoryDetectionError as Ar, EnvironmentConnectHttpApi as As, WsSourceControlCloneRepositoryRpc as At, AuthAdministrativeScopes as Au, AuthLocalSigningError as B, ProviderRuntimeEvent as Ba, OrchestrationThreadActivityTone as Bc, waitFormatFlag as Bd, Size as Bf, CursorSettings as Bi, DEFAULT_MODEL_BY_PROVIDER as Bl, BaseProto as Bm, VcsPullResult as Bn, DesktopSshEnvironmentEnsureInputSchema as Bo, matchEffect as Bp, ServerConfigStreamProviderStatusesEvent as Br, EnvironmentMetadataHttpApi as Bs, WsTerminalClearRpc as Bt, AuthEnvironmentScopes as Bu, T3LocalAuth as C, KeybindingsConfig as Ca, OrchestrationMessageRole as Cc, RuntimeTaskId as Cd, String$1 as Cf, ServerSignalProcessInput as Ci, ThreadMetaUpdatedPayload as Cl, Service$1 as Cm, GitPreparePullRequestThreadInput as Cn, TerminalSummary as Co, as as Cp, VcsListRemotesResult as Cr, EnvironmentAuthInvalidReason as Cs, WsServerRefreshProvidersRpc as Ct, AuthAccessStreamEvent as Cu, T3LocalAuthTokenLive as D, MAX_KEYBINDING_WHEN_LENGTH as Da, OrchestrationProposedPlanId as Dc, TurnId as Dd, decodeUnknownSync as Df, ServerTraceDiagnosticsLogEvent as Di, ThreadSessionSetPayload as Dl, flatMap$4 as Dm, GitRunStackedActionInput as Dn, DesktopAppBrandingSchema as Do, catchTags$1 as Dp, VcsProcessSpawnError as Dr, EnvironmentCloudLinkStateResult as Ds, WsServerUpdateSettingsRpc as Dt, AuthAccessTokenResult as Du, T3LocalAuthToken as E, MAX_KEYBINDING_VALUE_LENGTH as Ea, OrchestrationProposedPlan as Ec, TrimmedString as Ed, decodeUnknownEffect as Ef, ServerTraceDiagnosticsFailureSummary as Ei, ThreadRuntimeModeSetPayload as El, make$41 as Em, GitResolvePullRequestResult as En, ContextMenuItemSchema as Eo, catchFilter$2 as Ep, VcsProcessExitError as Er, EnvironmentCloudEndpointUnavailableError as Es, WsServerUpdateProviderRpc as Et, AuthAccessStreamSnapshotEvent as Eu, T3CodeConnectionError as F, THREAD_JUMP_KEYBINDING_COMMANDS as Fa, OrchestrationShellStreamEvent as Fc, modelFlags as Fd, Path as Ff, ClaudeSettings as Fi, TurnCountRange as Fl, match$3 as Fm, VcsCreateWorktreeResult as Fn, DesktopServerExposureModeSchema as Fo, forkScoped as Fp, ServerConfigKeybindingsUpdatedPayload as Fr, EnvironmentHttpForbiddenError as Fs, WsSubscribeServerLifecycleRpc as Ft, AuthClientPresentationMetadata as Fu, T3Orchestration as G, TOOL_LIFECYCLE_ITEM_TYPES as Ga, OrchestrationThreadStreamItem as Gc, T3Config as Gd, empty$6 as Gf, DEFAULT_SIDEBAR_PROJECT_GROUPING_MODE as Gi, ProviderOptionDescriptor as Gl, isUndefined as Gm, VcsStatusRemoteResult as Gn, DesktopSshHttpBaseUrlInputSchema as Go, result as Gp, ServerLifecycleStreamEvent as Gr, EnvironmentRequestInvalidReason as Gs, WsTerminalWriteRpc as Gt, AuthRelayReadScope as Gu, AuthTransportError as H, ProviderRuntimeThreadGoalStatus as Ha, OrchestrationThreadGoal as Hc, canRenderLiveTerminal as Hd, make$25 as Hf, DEFAULT_CLIENT_SETTINGS as Hi, ModelCapabilities as Hl, isNotNull as Hm, VcsRemoveWorktreeInput as Hn, DesktopSshEnvironmentEnsureResultSchema as Ho, provide as Hp, ServerConfigStreamSnapshotEvent as Hr, EnvironmentOperationForbiddenReason as Hs, WsTerminalOpenRpc as Ht, AuthOrchestrationReadScope as Hu, AuthConfigError as I, THREAD_KEYBINDING_COMMANDS as Ia, OrchestrationShellStreamItem as Ic, projectFlag as Id, TypeId$32 as If, ClientSettingsPatch as Ii, BooleanProviderOptionDescriptor as Il, none as Im, VcsInitInput as In, DesktopServerExposureStateSchema as Io, gen as Ip, ServerConfigProviderStatusesPayload as Ir, EnvironmentHttpInternalServerError as Is, WsSubscribeTerminalEventsRpc as It, AuthClientSession as Iu, NodeEnvironmentLive as J, UserInputQuestion as Ja, PROVIDER_SEND_TURN_MAX_INPUT_CHARS as Jc, choice as Jd, merge$1 as Jf, DEFAULT_SIDEBAR_THREAD_SORT_ORDER as Ji, ProviderOptionSelectionValue as Jl, VcsSwitchRefInput as Jn, DesktopSshPasswordPromptRequestSchema as Jo, serviceOption as Jp, ServerLifecycleWelcomePayload as Jr, ChatAttachment as Js, WsVcsInitRpc as Jt, AuthRevokeClientSessionInput as Ju, layerWebSocketConstructor as K, ThreadTokenUsageSnapshot as Ka, PROVIDER_SEND_TURN_MAX_ATTACHMENTS as Kc, T3Auth as Kd, fromIterable$1 as Kf, DEFAULT_SIDEBAR_PROJECT_SORT_ORDER as Ki, ProviderOptionDescriptorType as Kl, dual as Km, VcsStatusResult as Kn, DesktopSshPasswordPromptCancelledResultSchema as Ko, runFork as Kp, ServerLifecycleStreamReadyEvent as Kr, EnvironmentScopeRequiredError as Ks, WsVcsCreateRefRpc as Kt, AuthRelayWriteScope as Ku, AuthLocalDatabaseError as L, CanonicalItemType as La, OrchestrationSubscribeThreadInput as Lc, projectPathFlag as Ld, FileDescriptor as Lf, ClientSettingsSchema as Li, DEFAULT_GIT_TEXT_GENERATION_MODEL as Ll, some as Lm, VcsListRefsInput as Ln, DesktopSshBearerBootstrapInputSchema as Lo, ignore$1 as Lp, ServerConfigSettingsUpdatedPayload as Lr, EnvironmentHttpUnauthorizedError as Ls, WsSubscribeTerminalMetadataRpc as Lt, AuthCreatePairingCredentialInput as Lu, readT3LayoutFromNodeProcess as M, ResolvedKeybindingRule as Ma, OrchestrationSession as Mc, resolveWorktreePath as Md, make$24 as Mf, ServerUpsertKeybindingInput as Mi, ThreadTurnStartCommand as Ml, isNone as Mm, VcsCreateRefInput as Mn, DesktopEnvironmentBootstrapSchema as Mo, fn as Mp, VcsUnsupportedOperationError as Mr, EnvironmentHttpBadRequestError as Ms, WsSourceControlPublishRepositoryRpc as Mt, AuthBrowserSessionResult as Mu, resolveT3BaseDir as N, ResolvedKeybindingsConfig as Na, OrchestrationSessionStatus as Nc, T3Application as Nd, fromReadable as Nf, ServerUpsertKeybindingResult as Ni, ThreadTurnStartRequestedPayload as Nl, isSome as Nm, VcsCreateRefResult as Nn, DesktopRuntimeArchSchema as No, fnUntraced as Np, ServerConfig as Nr, EnvironmentHttpCommonError as Ns, WsSubscribeAuthAccessRpc as Nt, AuthClientMetadata as Nu, makeT3LocalAuthToken as O, MAX_SCRIPT_ID_LENGTH as Oa, OrchestrationReadModel as Oc, CliPath as Od, fromJsonString as Of, ServerTraceDiagnosticsRecentFailure as Oi, ThreadSessionStopRequestedPayload as Ol, fromNullishOr as Om, GitRunStackedActionResult as On, DesktopAppStageLabelSchema as Oo, catch_$1 as Op, VcsProcessTimeoutError as Or, EnvironmentCloudPreferencesRequest as Os, WsServerUpsertKeybindingRpc as Ot, AuthAccessTokenType as Ou, RpcError as P, SCRIPT_RUN_COMMAND_PATTERN as Pa, OrchestrationShellSnapshot as Pc, formatFlag as Pd, fromWritable as Pf, isProviderAvailable as Pi, ThreadUnarchivedPayload as Pl, map$9 as Pm, VcsCreateWorktreeInput as Pn, DesktopRuntimeInfoSchema as Po, forEach$1 as Pp, ServerConfigIssue as Pr, EnvironmentHttpConflictError as Ps, WsSubscribeServerConfigRpc as Pt, AuthClientMetadataDeviceType as Pu, ThreadSessionError as Q, ProviderInterruptTurnInput as Qa, ProjectMetaUpdatedPayload as Qc, optional as Qd, runDrain as Qf, MAX_SIDEBAR_THREAD_PREVIEW_COUNT as Qi, ProviderInstanceConfig as Ql, SourceControlCloneProtocol as Qn, DesktopUpdateChannelSchema as Qo, tapError$2 as Qp, ServerProcessResourceHistoryBucket as Qr, DEFAULT_PROVIDER_INTERACTION_MODE as Qs, WsVcsRemoveWorktreeRpc as Qt, AuthTerminalOperateScope as Qu, AuthLocalError as R, CanonicalRequestType as Ra, OrchestrationThread as Rc, threadFlag as Rd, FileSystem as Rf, CodexSettings as Ri, DEFAULT_GIT_TEXT_GENERATION_MODEL_BY_PROVIDER as Rl, Prototype as Rm, VcsListRefsResult as Rn, DesktopSshBearerRequestInputSchema as Ro, interrupt$1 as Rp, ServerConfigStreamEvent as Rr, EnvironmentInternalError as Rs, WsSubscribeVcsStatusRpc as Rt, AuthEnvironmentBootstrapTokenType as Ru, T3AuthTransportLive as S, KeybindingWhenNode as Sa, OrchestrationMessage as Sc, RuntimeSessionId as Sd, Literal as Sf, ServerRemoveKeybindingResult as Si, ThreadMessageSentPayload as Sl, Reference as Sm, GitManagerServiceError as Sn, TerminalSessionStatus as So, andThen as Sp, VcsFreshnessSource as Sr, EnvironmentAuthInvalidError as Ss, WsServerGetTraceDiagnosticsRpc as St, AuthAccessStreamError as Su, makeT3LocalAuth as T, MAX_KEYBINDINGS_COUNT as Ta, OrchestrationProjectShell as Tc, TrimmedNonEmptyString as Td, TaggedErrorClass as Tf, ServerTraceDiagnosticsErrorKind as Ti, ThreadRevertedPayload as Tl, getUnsafe$2 as Tm, GitPullRequestRefInput as Tn, TerminalWriteInput as To, callback$1 as Tp, VcsOutputDecodeError as Tr, EnvironmentAuthenticatedPrincipal as Ts, WsServerSignalProcessRpc as Tt, AuthAccessStreamPairingLinkUpsertedEvent as Tu, ConfigError as U, ProviderRuntimeTurnStatus as Ua, OrchestrationThreadGoalStatus as Uc, resolveOutputFormat as Ud, callback as Uf, DEFAULT_CONTEXT_MENU_STYLE as Ui, PROVIDER_DISPLAY_NAMES as Ul, isNotUndefined as Um, VcsStatusInput as Un, DesktopSshEnvironmentTargetSchema as Uo, provideContext$2 as Up, ServerConfigUpdatedPayload as Ur, EnvironmentOrchestrationHttpApi as Us, WsTerminalResizeRpc as Ut, AuthPairingCredentialResult as Uu, AuthPairingUrlError as V, ProviderRuntimeEventV2 as Va, OrchestrationThreadDetailSnapshot as Vc, worktreeFlag as Vd, WatchBackend as Vf, DEFAULT_AUTOMATIC_GIT_FETCH_INTERVAL as Vi, MODEL_SLUG_ALIASES_BY_PROVIDER as Vl, hasProperty as Vm, VcsRef as Vn, DesktopSshEnvironmentEnsureOptionsSchema as Vo, orDie as Vp, ServerConfigStreamSettingsUpdatedEvent as Vr, EnvironmentOperationForbiddenError as Vs, WsTerminalCloseRpc as Vt, AuthOrchestrationOperateScope as Vu, UrlError as W, RuntimeEventRaw as Wa, OrchestrationThreadShell as Wc, Environment as Wd, decodeText as Wf, DEFAULT_SERVER_SETTINGS as Wi, ProviderOptionChoice as Wl, isNullish as Wm, VcsStatusLocalResult as Wn, DesktopSshHostSourceSchema as Wo, provideService$1 as Wp, ServerLifecycleReadyPayload as Wr, EnvironmentRequestInvalidError as Ws, WsTerminalRestartRpc as Wt, AuthPairingLink as Wu, threadStatus as X, ProviderEvent as Xa, ProjectCreatedPayload as Xc, integer as Xd, run$1 as Xf, DEFAULT_UNIFIED_SETTINGS as Xi, SelectProviderOptionDescriptor as Xl, ChangeRequest as Xn, DesktopThemeSchema as Xo, suspend$3 as Xp, ServerProcessDiagnosticsEntry as Xr, ClientOrchestrationCommand as Xs, WsVcsPullRpc as Xt, AuthSessionState as Xu, latestAssistantMessage as Y, isToolLifecycleItemType as Ya, ProjectCreateCommand as Yc, choiceWithValue as Yd, mkString as Yf, DEFAULT_TIMESTAMP_FORMAT as Yi, ProviderOptionSelections as Yl, VcsSwitchRefResult as Yn, DesktopSshPasswordPromptResolutionInputSchema as Yo, succeed$2 as Yp, ServerObservability as Yr, ChatImageAttachment as Ys, WsVcsListRefsRpc as Yt, AuthRevokePairingLinkInput as Yu, ProjectLookupError as Z, ProviderGoalRequestInput as Za, ProjectDeletedPayload as Zc, map as Zd, runCollect as Zf, GrokSettings as Zi, ProviderDriverKind as Zl, ChangeRequestState as Zn, DesktopUpdateActionResultSchema as Zo, sync as Zp, ServerProcessDiagnosticsResult as Zr, CorrelationId as Zs, WsVcsRefreshStatusRpc as Zt, AuthStandardClientScopes as Zu, makeT3Auth as _, KeybindingCommand as _a, OrchestrationGetSnapshotError as _c, PositiveInt as _d, ShowHelp as _f, ServerProviderUpdatedPayload as _i, ThreadGoalClearedPayload as _l, ConsoleRef as _m, GitActionProgressKind as _n, TerminalOpenInput as _o, systemError as _p, VcsDiscoveryItem as _r, RelayClientStatusSchema as _s, WsServerDiscoverSourceControlRpc as _t, ScopedThreadSessionRef as _u, T3AuthTransportLayer as a, SidebarProjectGroupingMode as aa, OrchestrationCheckpointFile as ac, ServerAuthPolicy as ad, getParamMetadata as af, ServerProviderAuthStatus as ai, ProviderInteractionMode as al, effect as am, FilesystemBrowseEntry as an, ProviderTurnStartResult as ao, unwrap as ap, SourceControlProviderDiscoveryItem as ar, AdvertisedEndpointCompatibility as as, WsGitRunStackedActionRpc as at, defaultInstanceIdForDriver as au, makeT3AuthPairing as b, KeybindingValue as ba, OrchestrationGetTurnDiffResult as bc, RuntimeItemId as bd, isCliError as bf, ServerProviders as bi, ThreadGoalUpdatedPayload as bl, fail$6 as bm, GitCommandError as bn, TerminalSessionLookupError as bo, acquireRelease as bp, VcsError as br, AuthPairingLinkRevokeResult as bs, WsServerGetProcessResourceHistoryRpc as bt, AuthAccessStreamClientRemovedEvent as bu, T3LocalAuthTokenLayer as c, SidebarThreadSortOrder as ca, OrchestrationCommand as cc, AuthSessionId as cd, optional$1 as cf, ServerProviderModel as ci, ProviderSessionRuntimeStatus as cl, provideMerge as cm, FilesystemBrowseResult as cn, TerminalAttachStreamEvent as co, drain as cp, SourceControlProviderKind as cr, AdvertisedEndpointProviderKind as cs, WsOrchestrationGetFullThreadDiffRpc as ct, ExecutionEnvironmentCapabilities as cu, T3CodeConnectionProvider as d, makeProviderSettingsSchema as da, OrchestrationEvent as dc, EnvironmentId as dd, getTypeName as df, ServerProviderSlashCommandInput as di, ThreadActivityAppendedPayload as dl, MinimumLogLevel as dm, ProjectSearchEntriesInput as dn, TerminalCwdError as do, failCauseUnsafe as dp, SourceControlPublishStatus as dr, AdvertisedEndpointStatus as ds, WsOrchestrationSubscribeShellRpc as dt, ExecutionEnvironmentPlatformArch as du, ObservabilitySettings as ea, DispatchResult as ec, AuthTokenExchangeRequest as ed, withAlias as ef, ServerProcessResourceHistoryResult as ei, ProjectScriptIcon as el, tryPromise as em, ReviewDiffPreviewError as en, ProviderRespondToUserInputInput as eo, runLast as ep, SourceControlCloneRepositoryResult as er, DesktopUpdateStateSchema as es, WsCloudGetRelayClientStatusRpc as et, ProviderInstanceEnvironment as eu, T3CodeConnectionProviderLive as f, EDITORS as fa, OrchestrationEventMetadata as fc, EventId as fd, isBoolean as ff, ServerProviderState as fi, ThreadApprovalResponseRequestedPayload as fl, _await as fm, ProjectSearchEntriesResult as fn, TerminalError as fo, make$28 as fp, SourceControlRepositoryCloneUrls as fr, DesktopBackendBootstrap as fs, WsOrchestrationSubscribeThreadRpc as ft, ExecutionEnvironmentPlatformOs as fu, T3AuthLive as g, LaunchEditorInput as ga, OrchestrationGetFullThreadDiffResult as gc, PortSchema as gd, InvalidValue as gf, ServerProviderUpdateStatus as gi, ThreadDeletedPayload as gl, succeed$4 as gm, GitActionProgressEvent as gn, TerminalNotRunningError as go, badArgument as gp, SourceControlRepositoryVisibility as gr, RelayClientInstallProgressStageSchema as gs, WsRpcGroup as gt, ScopedThreadRef as gu, makeT3Config as h, ExternalLauncherError as ha, OrchestrationGetFullThreadDiffInput as hc, NonNegativeInt as hd, DuplicateOption as hf, ServerProviderUpdateState as hi, ThreadCreatedPayload as hl, makeUnsafe$8 as hm, ProjectWriteFileResult as hn, TerminalMetadataStreamEvent as ho, BadArgument as hp, SourceControlRepositoryLookupInput as hr, RelayClientInstallProgressEventSchema as hs, WsReviewGetDiffPreviewRpc as ht, ScopedProjectRef as hu, T3AuthPairingLayer as i, ServerSettingsPatch as ia, OrchestrationAggregateKind as ic, ServerAuthDescriptor as id, extractSingleParams as if, ServerProviderAuth as ii, ProviderApprovalPolicy as il, fail$3 as im, ReviewDiffPreviewSourceKind as in, ProviderStopSessionInput as io, transduce as ip, SourceControlProviderAuthStatus as ir, AdvertisedEndpoint as is, WsGitResolvePullRequestRpc as it, ProviderInstanceRef as iu, makeT3LocalAuthOrigin as j, MODEL_PICKER_KEYBINDING_COMMANDS as ja, OrchestrationRpcSchemas as jc, resolveThreadId as jd, Crypto as jf, ServerTraceDiagnosticsSpanSummary as ji, ThreadTurnInterruptRequestedPayload as jl, getOrUndefined as jm, TextGenerationError as jn, DesktopDiscoveredSshHostSchema as jo, flatMap$2 as jp, VcsRepositoryIdentity as jr, EnvironmentHttpApi as js, WsSourceControlLookupRepositoryRpc as jt, AuthBrowserSessionRequest as ju, T3LocalAuthOrigin as k, MAX_WHEN_EXPRESSION_DEPTH as ka, OrchestrationReplayEventsError as kc, resolveCommandProjectRef as kd, optionalKey as kf, ServerTraceDiagnosticsResult as ki, ThreadTurnDiff as kl, fromUndefinedOr as km, GitRunStackedActionToastRunAction as kn, DesktopCloudAuthFetchInputSchema as ko, effectify as kp, VcsRemote as kr, EnvironmentCloudRelayConfigResult as ks, WsShellOpenInEditorRpc as kt, AuthAccessWriteScope as ku, T3OrchestrationLayer as l, ThreadEnvMode as la, OrchestrationCommandReceiptStatus as lc, CheckpointRef as ld, string$1 as lf, ServerProviderSkill as li, ProviderUserInputAnswers as ll, succeed$3 as lm, ProjectEntry as ln, TerminalClearInput as lo, isSink as lp, SourceControlPublishRepositoryInput as lr, AdvertisedEndpointReachability as ls, WsOrchestrationGetTurnDiffRpc as lt, ExecutionEnvironmentDescriptor as lu, T3ConfigLive as m, EditorLaunchStyle as ma, OrchestrationGetFullThreadDiffError as mc, MessageId as md, isTrueValue as mf, ServerProviderUpdateInput as mi, ThreadCheckpointRevertRequestedPayload as ml, isDone$1 as mm, ProjectWriteFileInput as mn, TerminalHistoryError as mo, offerUnsafe as mp, SourceControlRepositoryInfo as mr, RelayClientInstallFailureReasonSchema as ms, WsProjectsWriteFileRpc as mt, RepositoryIdentityLocator as mu, AuthAppLayer as n, ServerSettings as na, ORCHESTRATION_WS_METHODS as nc, EnvironmentAuthorizationError as nd, withDescription as nf, ServerProcessSignal as ni, ProjectionPendingApprovalStatus as nl, uninterruptible as nm, ReviewDiffPreviewResult as nn, ProviderSession as no, succeed as np, SourceControlDiscoveryStatus as nr, PersistedSavedEnvironmentRecordSchema as ns, WsFilesystemBrowseRpc as nt, ProviderInstanceEnvironmentVariableName as nu, T3LocalAuthLayer as o, SidebarProjectSortOrder as oa, OrchestrationCheckpointStatus as oc, ServerAuthSessionMethod as od, isFlagParam as of, ServerProviderAvailability as oi, ProviderRequestKind as ol, mergeAll$1 as om, FilesystemBrowseError as on, DEFAULT_TERMINAL_ID as oo, get$2 as op, SourceControlProviderError as or, AdvertisedEndpointHostedHttpsCompatibility as os, WsOrchestrationDispatchCommandRpc as ot, isProviderDriverKind as ou, makeT3CodeConnectionProvider as p, EditorId as pa, OrchestrationEventType as pc, IsoDateTime as pd, isFalseValue as pf, ServerProviderUpdateError as pi, ThreadArchivedPayload as pl, doneUnsafe as pm, ProjectWriteFileError as pn, TerminalEvent as po, offer as pp, SourceControlRepositoryError as pr, RelayClientInstallFailedError as ps, WsProjectsSearchEntriesRpc as pt, RepositoryIdentity as pu, layerUndici as q, ToolLifecycleItemType as qa, PROVIDER_SEND_TURN_MAX_IMAGE_BYTES as qc, boolean as qd, isStream as qf, DEFAULT_SIDEBAR_THREAD_PREVIEW_COUNT as qi, ProviderOptionSelection as ql, pipe as qm, VcsStatusStreamEvent as qn, DesktopSshPasswordPromptCancelledType as qo, scoped$2 as qp, ServerLifecycleStreamWelcomeEvent as qr, AssistantDeliveryMode as qs, WsVcsCreateWorktreeRpc as qt, AuthReviewWriteScope as qu, T3AuthLayer as r, ServerSettingsError as ra, OrchestrationActorKind as rc, ServerAuthBootstrapMethod as rd, argumentKind as rf, ServerProvider as ri, ProviderApprovalDecision as rl, void_$1 as rm, ReviewDiffPreviewSource as rn, ProviderSessionStartInput as ro, tap as rp, SourceControlProviderAuth as rr, PickFolderOptionsSchema as rs, WsGitPreparePullRequestThreadRpc as rt, ProviderInstanceId as ru, T3LocalAuthOriginLayer as s, SidebarThreadPreviewCount as sa, OrchestrationCheckpointSummary as sc, ApprovalRequestId as sd, isParam as sf, ServerProviderContinuation as si, ProviderSandboxMode as sl, provide$2 as sm, FilesystemBrowseInput as sn, TerminalAttachInput as so, make$26 as sp, SourceControlProviderInfo as sr, AdvertisedEndpointProvider as ss, WsOrchestrationGetArchivedShellSnapshotRpc as st, EnvironmentConnectionState as su, AppLayer as t, OpenCodeSettings as ta, ModelSelection as tc, AuthWebSocketTicketResult as td, withDefault as tf, ServerProcessResourceHistorySummary as ti, ProjectionPendingApprovalDecision as tl, try_ as tm, ReviewDiffPreviewInput as tn, ProviderSendTurnInput as to, splitLines as tp, SourceControlDiscoveryResult as tr, DesktopUpdateStatusSchema as ts, WsCloudInstallRelayClientRpc as tt, ProviderInstanceEnvironmentVariable as tu, T3RpcLive as u, TimestampFormat as ua, OrchestrationDispatchCommandError as uc, CommandId as ud, getChoiceKeys as uf, ServerProviderSlashCommand as ui, RuntimeMode as ul, sync$1 as um, ProjectSearchEntriesError as un, TerminalCloseInput as uo, endUnsafe as up, SourceControlPublishRepositoryResult as ur, AdvertisedEndpointSource as us, WsOrchestrationReplayEventsRpc as ut, ExecutionEnvironmentPlatform as uu, T3AuthPairing as v, KeybindingRule as va, OrchestrationGetTurnDiffError as vc, ProjectId as vd, UnknownSubcommand as vf, ServerProviderVersionAdvisory as vi, ThreadGoalRequest as vl, sync$2 as vm, GitActionProgressPhase as vn, TerminalResizeInput as vo, nominal as vp, VcsDriverCapabilities as vr, AuthClientSessionRevokeResult as vs, WsServerGetConfigRpc$1 as vt, AuthAccessReadScope as vu, T3LocalAuthLive as w, KeybindingsConfigError as wa, OrchestrationProject as wc, ThreadId as wd, Struct as wf, ServerSignalProcessResult as wi, ThreadProposedPlanUpsertedPayload as wl, empty$11 as wm, GitPreparePullRequestThreadResult as wn, TerminalThreadInput as wo, asVoid as wp, VcsListWorkspaceFilesResult as wr, EnvironmentAuthenticatedAuth as ws, WsServerRemoveKeybindingRpc as wt, AuthAccessStreamPairingLinkRemovedEvent as wu, parsePairingUrl as x, KeybindingWhen as xa, OrchestrationLatestTurn as xc, RuntimeRequestId as xd, ErrorClass as xf, ServerRemoveKeybindingInput as xi, ThreadInteractionModeSetPayload as xl, succeed$6 as xm, GitManagerError as xn, TerminalSessionSnapshot as xo, addFinalizer as xp, VcsFreshness as xr, EnvironmentAuthHttpApi as xs, WsServerGetSettingsRpc as xt, AuthAccessStreamClientUpsertedEvent as xu, T3AuthPairingLive as y, KeybindingShortcut as ya, OrchestrationGetTurnDiffInput as yc, ProviderItemId as yd, UnrecognizedOption as yf, ServerProviderVersionAdvisoryStatus as yi, ThreadGoalRequestedPayload as yl, map$7 as ym, GitActionProgressStream as yn, TerminalRestartInput as yo, makeRunMain as yp, VcsDriverKind as yr, AuthOtherClientSessionsRevokeResult as ys, WsServerGetProcessDiagnosticsRpc as yt, AuthAccessSnapshot as yu, AuthLocalSecretError as z, ItemLifecyclePayload as za, OrchestrationThreadActivity as zc, threadFormatFlag as zd, FileTypeId as zf, ContextMenuStyle as zi, DEFAULT_MODEL as zl, withFiber$1 as zm, VcsPullInput as zn, DesktopSshEnvironmentBootstrapSchema as zo, map$5 as zp, ServerConfigStreamKeybindingsUpdatedEvent as zr, EnvironmentInternalErrorReason as zs, WsTerminalAttachRpc as zt, AuthEnvironmentScope as zu };

package/dist/t3tools.js

@@ -1,2 +1,2 @@
-import { $ as WsCloudInstallRelayClientRpc, $a as ProviderSendTurnInput, $c as ProjectionPendingApprovalDecision, $i as OpenCodeSettings, $l as ProviderInstanceEnvironmentVariable, $n as SourceControlDiscoveryResult, $o as DesktopUpdateStatusSchema, $r as ServerProcessResourceHistorySummary, $s as ModelSelection, $t as ReviewDiffPreviewInput, $u as AuthWebSocketTicketResult, Aa as ResolvedKeybindingRule, Ac as OrchestrationSession, Ai as ServerUpsertKeybindingInput, Al as ThreadTurnStartCommand, An as VcsCreateRefInput, Ao as DesktopEnvironmentBootstrapSchema, Ar as VcsUnsupportedOperationError, As as EnvironmentHttpBadRequestError, At as WsSourceControlPublishRepositoryRpc, Au as AuthBrowserSessionResult, Ba as ProviderRuntimeThreadGoalStatus, Bc as OrchestrationThreadGoal, Bi as DEFAULT_CLIENT_SETTINGS, Bl as ModelCapabilities, Bn as VcsRemoveWorktreeInput, Bo as DesktopSshEnvironmentEnsureResultSchema, Br as ServerConfigStreamSnapshotEvent, Bs as EnvironmentOperationForbiddenReason, Bt as WsTerminalOpenRpc, Bu as AuthOrchestrationReadScope, Ca as MAX_KEYBINDINGS_COUNT, Cc as OrchestrationProjectShell, Cd as TrimmedNonEmptyString, Ci as ServerTraceDiagnosticsErrorKind, Cl as ThreadRevertedPayload, Cn as GitPullRequestRefInput, Co as TerminalWriteInput, Cr as VcsOutputDecodeError, Cs as EnvironmentAuthenticatedPrincipal, Ct as WsServerSignalProcessRpc, Cu as AuthAccessStreamPairingLinkUpsertedEvent, Da as MAX_WHEN_EXPRESSION_DEPTH, Dc as OrchestrationReplayEventsError, Di as ServerTraceDiagnosticsResult, Dl as ThreadTurnDiff, Dn as GitRunStackedActionToastRunAction, Do as DesktopCloudAuthFetchInputSchema, Dr as VcsRemote, Ds as EnvironmentCloudRelayConfigResult, Dt as WsShellOpenInEditorRpc, Du as AuthAccessWriteScope, Ea as MAX_SCRIPT_ID_LENGTH, Ec as OrchestrationReadModel, Ei as ServerTraceDiagnosticsRecentFailure, El as ThreadSessionStopRequestedPayload, En as GitRunStackedActionResult, Eo as DesktopAppStageLabelSchema, Er as VcsProcessTimeoutError, Es as EnvironmentCloudPreferencesRequest, Et as WsServerUpsertKeybindingRpc, Eu as AuthAccessTokenType, Fa as CanonicalItemType, Fc as OrchestrationSubscribeThreadInput, Fi as ClientSettingsSchema, Fl as DEFAULT_GIT_TEXT_GENERATION_MODEL, Fn as VcsListRefsInput, Fo as DesktopSshBearerBootstrapInputSchema, Fr as ServerConfigSettingsUpdatedPayload, Fs as EnvironmentHttpUnauthorizedError, Ft as WsSubscribeTerminalMetadataRpc, Fu as AuthCreatePairingCredentialInput, Ga as ToolLifecycleItemType, Gc as PROVIDER_SEND_TURN_MAX_IMAGE_BYTES, Gi as DEFAULT_SIDEBAR_THREAD_PREVIEW_COUNT, Gl as ProviderOptionSelection, Gn as VcsStatusStreamEvent, Go as DesktopSshPasswordPromptCancelledType, Gr as ServerLifecycleStreamWelcomeEvent, Gs as AssistantDeliveryMode, Gt as WsVcsCreateWorktreeRpc, Gu as AuthReviewWriteScope, Ha as RuntimeEventRaw, Hc as OrchestrationThreadShell, Hi as DEFAULT_SERVER_SETTINGS, Hl as ProviderOptionChoice, Hn as VcsStatusLocalResult, Ho as DesktopSshHostSourceSchema, Hr as ServerLifecycleReadyPayload, Hs as EnvironmentRequestInvalidError, Ht as WsTerminalRestartRpc, Hu as AuthPairingLink, Ia as CanonicalRequestType, Ic as OrchestrationThread, Ii as CodexSettings, Il as DEFAULT_GIT_TEXT_GENERATION_MODEL_BY_PROVIDER, In as VcsListRefsResult, Io as DesktopSshBearerRequestInputSchema, Ir as ServerConfigStreamEvent, Is as EnvironmentInternalError, It as WsSubscribeVcsStatusRpc, Iu as AuthEnvironmentBootstrapTokenType, Ja as ProviderEvent, Jc as ProjectCreatedPayload, Ji as DEFAULT_UNIFIED_SETTINGS, Jl as SelectProviderOptionDescriptor, Jn as ChangeRequest, Jo as DesktopThemeSchema, Jr as ServerProcessDiagnosticsEntry, Js as ClientOrchestrationCommand, Jt as WsVcsPullRpc, Ju as AuthSessionState, Ka as UserInputQuestion, Kc as PROVIDER_SEND_TURN_MAX_INPUT_CHARS, Ki as DEFAULT_SIDEBAR_THREAD_SORT_ORDER, Kl as ProviderOptionSelectionValue, Kn as VcsSwitchRefInput, Ko as DesktopSshPasswordPromptRequestSchema, Kr as ServerLifecycleWelcomePayload, Ks as ChatAttachment, Kt as WsVcsInitRpc, Ku as AuthRevokeClientSessionInput, La as ItemLifecyclePayload, Lc as OrchestrationThreadActivity, Li as ContextMenuStyle, Ll as DEFAULT_MODEL, Ln as VcsPullInput, Lo as DesktopSshEnvironmentBootstrapSchema, Lr as ServerConfigStreamKeybindingsUpdatedEvent, Ls as EnvironmentInternalErrorReason, Lt as WsTerminalAttachRpc, Lu as AuthEnvironmentScope, Ma as SCRIPT_RUN_COMMAND_PATTERN, Mc as OrchestrationShellSnapshot, Mi as isProviderAvailable, Ml as ThreadUnarchivedPayload, Mn as VcsCreateWorktreeInput, Mo as DesktopRuntimeInfoSchema, Mr as ServerConfigIssue, Ms as EnvironmentHttpConflictError, Mt as WsSubscribeServerConfigRpc, Mu as AuthClientMetadataDeviceType, Na as THREAD_JUMP_KEYBINDING_COMMANDS, Nc as OrchestrationShellStreamEvent, Ni as ClaudeSettings, Nl as TurnCountRange, Nn as VcsCreateWorktreeResult, No as DesktopServerExposureModeSchema, Nr as ServerConfigKeybindingsUpdatedPayload, Ns as EnvironmentHttpForbiddenError, Nt as WsSubscribeServerLifecycleRpc, Nu as AuthClientPresentationMetadata, Oa as MODEL_PICKER_JUMP_KEYBINDING_COMMANDS, Oc as OrchestrationReplayEventsInput, Oi as ServerTraceDiagnosticsSpanOccurrence, Ol as ThreadTurnDiffCompletedPayload, On as GitStackedAction, Oo as DesktopCloudAuthFetchResultSchema, Or as VcsRepositoryDetectionError, Os as EnvironmentConnectHttpApi, Ot as WsSourceControlCloneRepositoryRpc, Ou as AuthAdministrativeScopes, Pa as THREAD_KEYBINDING_COMMANDS, Pc as OrchestrationShellStreamItem, Pi as ClientSettingsPatch, Pl as BooleanProviderOptionDescriptor, Pn as VcsInitInput, Po as DesktopServerExposureStateSchema, Pr as ServerConfigProviderStatusesPayload, Ps as EnvironmentHttpInternalServerError, Pt as WsSubscribeTerminalEventsRpc, Pu as AuthClientSession, Q as WsCloudGetRelayClientStatusRpc, Qa as ProviderRespondToUserInputInput, Qc as ProjectScriptIcon, Qi as ObservabilitySettings, Ql as ProviderInstanceEnvironment, Qn as SourceControlCloneRepositoryResult, Qo as DesktopUpdateStateSchema, Qr as ServerProcessResourceHistoryResult, Qs as DispatchResult, Qt as ReviewDiffPreviewError, Qu as AuthTokenExchangeRequest, Ra as ProviderRuntimeEvent, Rc as OrchestrationThreadActivityTone, Ri as CursorSettings, Rl as DEFAULT_MODEL_BY_PROVIDER, Rn as VcsPullResult, Ro as DesktopSshEnvironmentEnsureInputSchema, Rr as ServerConfigStreamProviderStatusesEvent, Rs as EnvironmentMetadataHttpApi, Rt as WsTerminalClearRpc, Ru as AuthEnvironmentScopes, Sa as KeybindingsConfigError, Sc as OrchestrationProject, Sd as ThreadId, Si as ServerSignalProcessResult, Sl as ThreadProposedPlanUpsertedPayload, Sn as GitPreparePullRequestThreadResult, So as TerminalThreadInput, Sr as VcsListWorkspaceFilesResult, Ss as EnvironmentAuthenticatedAuth, St as WsServerRemoveKeybindingRpc, Su as AuthAccessStreamPairingLinkRemovedEvent, Ta as MAX_KEYBINDING_WHEN_LENGTH, Tc as OrchestrationProposedPlanId, Td as TurnId, Ti as ServerTraceDiagnosticsLogEvent, Tl as ThreadSessionSetPayload, Tn as GitRunStackedActionInput, To as DesktopAppBrandingSchema, Tr as VcsProcessSpawnError, Ts as EnvironmentCloudLinkStateResult, Tt as WsServerUpdateSettingsRpc, Tu as AuthAccessTokenResult, Ua as TOOL_LIFECYCLE_ITEM_TYPES, Uc as OrchestrationThreadStreamItem, Ui as DEFAULT_SIDEBAR_PROJECT_GROUPING_MODE, Ul as ProviderOptionDescriptor, Un as VcsStatusRemoteResult, Uo as DesktopSshHttpBaseUrlInputSchema, Ur as ServerLifecycleStreamEvent, Us as EnvironmentRequestInvalidReason, Ut as WsTerminalWriteRpc, Uu as AuthRelayReadScope, Va as ProviderRuntimeTurnStatus, Vc as OrchestrationThreadGoalStatus, Vi as DEFAULT_CONTEXT_MENU_STYLE, Vl as PROVIDER_DISPLAY_NAMES, Vn as VcsStatusInput, Vo as DesktopSshEnvironmentTargetSchema, Vr as ServerConfigUpdatedPayload, Vs as EnvironmentOrchestrationHttpApi, Vt as WsTerminalResizeRpc, Vu as AuthPairingCredentialResult, Wa as ThreadTokenUsageSnapshot, Wc as PROVIDER_SEND_TURN_MAX_ATTACHMENTS, Wi as DEFAULT_SIDEBAR_PROJECT_SORT_ORDER, Wl as ProviderOptionDescriptorType, Wn as VcsStatusResult, Wo as DesktopSshPasswordPromptCancelledResultSchema, Wr as ServerLifecycleStreamReadyEvent, Ws as EnvironmentScopeRequiredError, Wt as WsVcsCreateRefRpc, Wu as AuthRelayWriteScope, Xa as ProviderInterruptTurnInput, Xc as ProjectMetaUpdatedPayload, Xi as MAX_SIDEBAR_THREAD_PREVIEW_COUNT, Xl as ProviderInstanceConfig, Xn as SourceControlCloneProtocol, Xo as DesktopUpdateChannelSchema, Xr as ServerProcessResourceHistoryBucket, Xs as DEFAULT_PROVIDER_INTERACTION_MODE, Xt as WsVcsRemoveWorktreeRpc, Xu as AuthTerminalOperateScope, Ya as ProviderGoalRequestInput, Yc as ProjectDeletedPayload, Yi as GrokSettings, Yl as ProviderDriverKind, Yn as ChangeRequestState, Yo as DesktopUpdateActionResultSchema, Yr as ServerProcessDiagnosticsResult, Ys as CorrelationId, Yt as WsVcsRefreshStatusRpc, Yu as AuthStandardClientScopes, Z as WS_METHODS, Za as ProviderRespondToRequestInput, Zc as ProjectScript, Zi as MIN_SIDEBAR_THREAD_PREVIEW_COUNT, Zl as ProviderInstanceConfigMap, Zn as SourceControlCloneRepositoryInput, Zo as DesktopUpdateCheckResultSchema, Zr as ServerProcessResourceHistoryInput, Zs as DEFAULT_RUNTIME_MODE, Zt as WsVcsSwitchRefRpc, Zu as AuthTokenExchangeGrantType, _a as KeybindingShortcut, _c as OrchestrationGetTurnDiffInput, _d as ProviderItemId, _i as ServerProviderVersionAdvisoryStatus, _l as ThreadGoalRequestedPayload, _n as GitActionProgressStream, _o as TerminalRestartInput, _r as VcsDriverKind, _s as AuthOtherClientSessionsRevokeResult, _t as WsServerGetProcessDiagnosticsRpc, _u as AuthAccessSnapshot, aa as SidebarThreadPreviewCount, ac as OrchestrationCheckpointSummary, ad as ApprovalRequestId, ai as ServerProviderContinuation, al as ProviderSandboxMode, an as FilesystemBrowseInput, ao as TerminalAttachInput, ar as SourceControlProviderInfo, as as AdvertisedEndpointProvider, at as WsOrchestrationGetArchivedShellSnapshotRpc, au as EnvironmentConnectionState, ba as KeybindingWhenNode, bc as OrchestrationMessage, bd as RuntimeSessionId, bi as ServerRemoveKeybindingResult, bl as ThreadMessageSentPayload, bn as GitManagerServiceError, bo as TerminalSessionStatus, br as VcsFreshnessSource, bs as EnvironmentAuthInvalidError, bt as WsServerGetTraceDiagnosticsRpc, bu as AuthAccessStreamError, ca as TimestampFormat, cc as OrchestrationDispatchCommandError, cd as CommandId, ci as ServerProviderSlashCommand, cl as RuntimeMode, cn as ProjectSearchEntriesError, co as TerminalCloseInput, cr as SourceControlPublishRepositoryResult, cs as AdvertisedEndpointSource, ct as WsOrchestrationReplayEventsRpc, cu as ExecutionEnvironmentPlatform, da as EditorId, dc as OrchestrationEventType, dd as IsoDateTime, di as ServerProviderUpdateError, dl as ThreadArchivedPayload, dn as ProjectWriteFileError, do as TerminalEvent, dr as SourceControlRepositoryError, ds as RelayClientInstallFailedError, dt as WsProjectsSearchEntriesRpc, du as RepositoryIdentity, ea as ServerSettings, ec as ORCHESTRATION_WS_METHODS, ed as EnvironmentAuthorizationError, ei as ServerProcessSignal, el as ProjectionPendingApprovalStatus, en as ReviewDiffPreviewResult, eo as ProviderSession, er as SourceControlDiscoveryStatus, es as PersistedSavedEnvironmentRecordSchema, et as WsFilesystemBrowseRpc, eu as ProviderInstanceEnvironmentVariableName, fa as EditorLaunchStyle, fc as OrchestrationGetFullThreadDiffError, fd as MessageId, fi as ServerProviderUpdateInput, fl as ThreadCheckpointRevertRequestedPayload, fn as ProjectWriteFileInput, fo as TerminalHistoryError, fr as SourceControlRepositoryInfo, fs as RelayClientInstallFailureReasonSchema, ft as WsProjectsWriteFileRpc, fu as RepositoryIdentityLocator, ga as KeybindingRule, gc as OrchestrationGetTurnDiffError, gd as ProjectId, gi as ServerProviderVersionAdvisory, gl as ThreadGoalRequest, gn as GitActionProgressPhase, go as TerminalResizeInput, gr as VcsDriverCapabilities, gs as AuthClientSessionRevokeResult, gt as WsServerGetConfigRpc, gu as AuthAccessReadScope, ha as KeybindingCommand, hc as OrchestrationGetSnapshotError, hd as PositiveInt, hi as ServerProviderUpdatedPayload, hl as ThreadGoalClearedPayload, hn as GitActionProgressKind, ho as TerminalOpenInput, hr as VcsDiscoveryItem, hs as RelayClientStatusSchema, ht as WsServerDiscoverSourceControlRpc, hu as ScopedThreadSessionRef, ia as SidebarProjectSortOrder, ic as OrchestrationCheckpointStatus, id as ServerAuthSessionMethod, ii as ServerProviderAvailability, il as ProviderRequestKind, in as FilesystemBrowseError, io as DEFAULT_TERMINAL_ID, ir as SourceControlProviderError, is as AdvertisedEndpointHostedHttpsCompatibility, it as WsOrchestrationDispatchCommandRpc, iu as isProviderDriverKind, ja as ResolvedKeybindingsConfig, jc as OrchestrationSessionStatus, ji as ServerUpsertKeybindingResult, jl as ThreadTurnStartRequestedPayload, jn as VcsCreateRefResult, jo as DesktopRuntimeArchSchema, jr as ServerConfig, js as EnvironmentHttpCommonError, jt as WsSubscribeAuthAccessRpc, ju as AuthClientMetadata, ka as MODEL_PICKER_KEYBINDING_COMMANDS, kc as OrchestrationRpcSchemas, ki as ServerTraceDiagnosticsSpanSummary, kl as ThreadTurnInterruptRequestedPayload, kn as TextGenerationError, ko as DesktopDiscoveredSshHostSchema, kr as VcsRepositoryIdentity, ks as EnvironmentHttpApi, kt as WsSourceControlLookupRepositoryRpc, ku as AuthBrowserSessionRequest, la as makeProviderSettingsSchema, lc as OrchestrationEvent, ld as EnvironmentId, li as ServerProviderSlashCommandInput, ll as ThreadActivityAppendedPayload, ln as ProjectSearchEntriesInput, lo as TerminalCwdError, lr as SourceControlPublishStatus, ls as AdvertisedEndpointStatus, lt as WsOrchestrationSubscribeShellRpc, lu as ExecutionEnvironmentPlatformArch, ma as LaunchEditorInput, mc as OrchestrationGetFullThreadDiffResult, md as PortSchema, mi as ServerProviderUpdateStatus, ml as ThreadDeletedPayload, mn as GitActionProgressEvent, mo as TerminalNotRunningError, mr as SourceControlRepositoryVisibility, ms as RelayClientInstallProgressStageSchema, mt as WsRpcGroup, mu as ScopedThreadRef, na as ServerSettingsPatch, nc as OrchestrationAggregateKind, nd as ServerAuthDescriptor, ni as ServerProviderAuth, nl as ProviderApprovalPolicy, nn as ReviewDiffPreviewSourceKind, no as ProviderStopSessionInput, nr as SourceControlProviderAuthStatus, ns as AdvertisedEndpoint, nt as WsGitResolvePullRequestRpc, nu as ProviderInstanceRef, oa as SidebarThreadSortOrder, oc as OrchestrationCommand, od as AuthSessionId, oi as ServerProviderModel, ol as ProviderSessionRuntimeStatus, on as FilesystemBrowseResult, oo as TerminalAttachStreamEvent, or as SourceControlProviderKind, os as AdvertisedEndpointProviderKind, ot as WsOrchestrationGetFullThreadDiffRpc, ou as ExecutionEnvironmentCapabilities, pa as ExternalLauncherError, pc as OrchestrationGetFullThreadDiffInput, pd as NonNegativeInt, pi as ServerProviderUpdateState, pl as ThreadCreatedPayload, pn as ProjectWriteFileResult, po as TerminalMetadataStreamEvent, pr as SourceControlRepositoryLookupInput, ps as RelayClientInstallProgressEventSchema, pt as WsReviewGetDiffPreviewRpc, pu as ScopedProjectRef, qa as isToolLifecycleItemType, qc as ProjectCreateCommand, qi as DEFAULT_TIMESTAMP_FORMAT, ql as ProviderOptionSelections, qn as VcsSwitchRefResult, qo as DesktopSshPasswordPromptResolutionInputSchema, qr as ServerObservability, qs as ChatImageAttachment, qt as WsVcsListRefsRpc, qu as AuthRevokePairingLinkInput, ra as SidebarProjectGroupingMode, rc as OrchestrationCheckpointFile, rd as ServerAuthPolicy, ri as ServerProviderAuthStatus, rl as ProviderInteractionMode, rn as FilesystemBrowseEntry, ro as ProviderTurnStartResult, rr as SourceControlProviderDiscoveryItem, rs as AdvertisedEndpointCompatibility, rt as WsGitRunStackedActionRpc, ru as defaultInstanceIdForDriver, sa as ThreadEnvMode, sc as OrchestrationCommandReceiptStatus, sd as CheckpointRef, si as ServerProviderSkill, sl as ProviderUserInputAnswers, sn as ProjectEntry, so as TerminalClearInput, sr as SourceControlPublishRepositoryInput, ss as AdvertisedEndpointReachability, st as WsOrchestrationGetTurnDiffRpc, su as ExecutionEnvironmentDescriptor, ta as ServerSettingsError, tc as OrchestrationActorKind, td as ServerAuthBootstrapMethod, ti as ServerProvider, tl as ProviderApprovalDecision, tn as ReviewDiffPreviewSource, to as ProviderSessionStartInput, tr as SourceControlProviderAuth, ts as PickFolderOptionsSchema, tt as WsGitPreparePullRequestThreadRpc, tu as ProviderInstanceId, ua as EDITORS, uc as OrchestrationEventMetadata, ud as EventId, ui as ServerProviderState, ul as ThreadApprovalResponseRequestedPayload, un as ProjectSearchEntriesResult, uo as TerminalError, ur as SourceControlRepositoryCloneUrls, us as DesktopBackendBootstrap, ut as WsOrchestrationSubscribeThreadRpc, uu as ExecutionEnvironmentPlatformOs, va as KeybindingValue, vc as OrchestrationGetTurnDiffResult, vd as RuntimeItemId, vi as ServerProviders, vl as ThreadGoalUpdatedPayload, vn as GitCommandError, vo as TerminalSessionLookupError, vr as VcsError, vs as AuthPairingLinkRevokeResult, vt as WsServerGetProcessResourceHistoryRpc, vu as AuthAccessStreamClientRemovedEvent, wa as MAX_KEYBINDING_VALUE_LENGTH, wc as OrchestrationProposedPlan, wd as TrimmedString, wi as ServerTraceDiagnosticsFailureSummary, wl as ThreadRuntimeModeSetPayload, wn as GitResolvePullRequestResult, wo as ContextMenuItemSchema, wr as VcsProcessExitError, ws as EnvironmentCloudEndpointUnavailableError, wt as WsServerUpdateProviderRpc, wu as AuthAccessStreamSnapshotEvent, xa as KeybindingsConfig, xc as OrchestrationMessageRole, xd as RuntimeTaskId, xi as ServerSignalProcessInput, xl as ThreadMetaUpdatedPayload, xn as GitPreparePullRequestThreadInput, xo as TerminalSummary, xr as VcsListRemotesResult, xs as EnvironmentAuthInvalidReason, xt as WsServerRefreshProvidersRpc, xu as AuthAccessStreamEvent, ya as KeybindingWhen, yc as OrchestrationLatestTurn, yd as RuntimeRequestId, yi as ServerRemoveKeybindingInput, yl as ThreadInteractionModeSetPayload, yn as GitManagerError, yo as TerminalSessionSnapshot, yr as VcsFreshness, ys as EnvironmentAuthHttpApi, yt as WsServerGetSettingsRpc, yu as AuthAccessStreamClientUpsertedEvent, za as ProviderRuntimeEventV2, zc as OrchestrationThreadDetailSnapshot, zi as DEFAULT_AUTOMATIC_GIT_FETCH_INTERVAL, zl as MODEL_SLUG_ALIASES_BY_PROVIDER, zn as VcsRef, zo as DesktopSshEnvironmentEnsureOptionsSchema, zr as ServerConfigStreamSettingsUpdatedEvent, zs as EnvironmentOperationForbiddenError, zt as WsTerminalCloseRpc, zu as AuthOrchestrationOperateScope } from "./shared.js";
+import { $ as WS_METHODS, $a as ProviderRespondToRequestInput, $c as ProjectScript, $i as MIN_SIDEBAR_THREAD_PREVIEW_COUNT, $l as ProviderInstanceConfigMap, $n as SourceControlCloneRepositoryInput, $o as DesktopUpdateCheckResultSchema, $r as ServerProcessResourceHistoryInput, $s as DEFAULT_RUNTIME_MODE, $t as WsVcsSwitchRefRpc, $u as AuthTokenExchangeGrantType, Aa as MODEL_PICKER_JUMP_KEYBINDING_COMMANDS, Ac as OrchestrationReplayEventsInput, Ai as ServerTraceDiagnosticsSpanOccurrence, Al as ThreadTurnDiffCompletedPayload, An as GitStackedAction, Ao as DesktopCloudAuthFetchResultSchema, Ar as VcsRepositoryDetectionError, As as EnvironmentConnectHttpApi, At as WsSourceControlCloneRepositoryRpc, Au as AuthAdministrativeScopes, Ba as ProviderRuntimeEvent, Bc as OrchestrationThreadActivityTone, Bi as CursorSettings, Bl as DEFAULT_MODEL_BY_PROVIDER, Bn as VcsPullResult, Bo as DesktopSshEnvironmentEnsureInputSchema, Br as ServerConfigStreamProviderStatusesEvent, Bs as EnvironmentMetadataHttpApi, Bt as WsTerminalClearRpc, Bu as AuthEnvironmentScopes, Ca as KeybindingsConfig, Cc as OrchestrationMessageRole, Cd as RuntimeTaskId, Ci as ServerSignalProcessInput, Cl as ThreadMetaUpdatedPayload, Cn as GitPreparePullRequestThreadInput, Co as TerminalSummary, Cr as VcsListRemotesResult, Cs as EnvironmentAuthInvalidReason, Ct as WsServerRefreshProvidersRpc, Cu as AuthAccessStreamEvent, Da as MAX_KEYBINDING_WHEN_LENGTH, Dc as OrchestrationProposedPlanId, Dd as TurnId, Di as ServerTraceDiagnosticsLogEvent, Dl as ThreadSessionSetPayload, Dn as GitRunStackedActionInput, Do as DesktopAppBrandingSchema, Dr as VcsProcessSpawnError, Ds as EnvironmentCloudLinkStateResult, Dt as WsServerUpdateSettingsRpc, Du as AuthAccessTokenResult, Ea as MAX_KEYBINDING_VALUE_LENGTH, Ec as OrchestrationProposedPlan, Ed as TrimmedString, Ei as ServerTraceDiagnosticsFailureSummary, El as ThreadRuntimeModeSetPayload, En as GitResolvePullRequestResult, Eo as ContextMenuItemSchema, Er as VcsProcessExitError, Es as EnvironmentCloudEndpointUnavailableError, Et as WsServerUpdateProviderRpc, Eu as AuthAccessStreamSnapshotEvent, Fa as THREAD_JUMP_KEYBINDING_COMMANDS, Fc as OrchestrationShellStreamEvent, Fi as ClaudeSettings, Fl as TurnCountRange, Fn as VcsCreateWorktreeResult, Fo as DesktopServerExposureModeSchema, Fr as ServerConfigKeybindingsUpdatedPayload, Fs as EnvironmentHttpForbiddenError, Ft as WsSubscribeServerLifecycleRpc, Fu as AuthClientPresentationMetadata, Ga as TOOL_LIFECYCLE_ITEM_TYPES, Gc as OrchestrationThreadStreamItem, Gi as DEFAULT_SIDEBAR_PROJECT_GROUPING_MODE, Gl as ProviderOptionDescriptor, Gn as VcsStatusRemoteResult, Go as DesktopSshHttpBaseUrlInputSchema, Gr as ServerLifecycleStreamEvent, Gs as EnvironmentRequestInvalidReason, Gt as WsTerminalWriteRpc, Gu as AuthRelayReadScope, Ha as ProviderRuntimeThreadGoalStatus, Hc as OrchestrationThreadGoal, Hi as DEFAULT_CLIENT_SETTINGS, Hl as ModelCapabilities, Hn as VcsRemoveWorktreeInput, Ho as DesktopSshEnvironmentEnsureResultSchema, Hr as ServerConfigStreamSnapshotEvent, Hs as EnvironmentOperationForbiddenReason, Ht as WsTerminalOpenRpc, Hu as AuthOrchestrationReadScope, Ia as THREAD_KEYBINDING_COMMANDS, Ic as OrchestrationShellStreamItem, Ii as ClientSettingsPatch, Il as BooleanProviderOptionDescriptor, In as VcsInitInput, Io as DesktopServerExposureStateSchema, Ir as ServerConfigProviderStatusesPayload, Is as EnvironmentHttpInternalServerError, It as WsSubscribeTerminalEventsRpc, Iu as AuthClientSession, Ja as UserInputQuestion, Jc as PROVIDER_SEND_TURN_MAX_INPUT_CHARS, Ji as DEFAULT_SIDEBAR_THREAD_SORT_ORDER, Jl as ProviderOptionSelectionValue, Jn as VcsSwitchRefInput, Jo as DesktopSshPasswordPromptRequestSchema, Jr as ServerLifecycleWelcomePayload, Js as ChatAttachment, Jt as WsVcsInitRpc, Ju as AuthRevokeClientSessionInput, Ka as ThreadTokenUsageSnapshot, Kc as PROVIDER_SEND_TURN_MAX_ATTACHMENTS, Ki as DEFAULT_SIDEBAR_PROJECT_SORT_ORDER, Kl as ProviderOptionDescriptorType, Kn as VcsStatusResult, Ko as DesktopSshPasswordPromptCancelledResultSchema, Kr as ServerLifecycleStreamReadyEvent, Ks as EnvironmentScopeRequiredError, Kt as WsVcsCreateRefRpc, Ku as AuthRelayWriteScope, La as CanonicalItemType, Lc as OrchestrationSubscribeThreadInput, Li as ClientSettingsSchema, Ll as DEFAULT_GIT_TEXT_GENERATION_MODEL, Ln as VcsListRefsInput, Lo as DesktopSshBearerBootstrapInputSchema, Lr as ServerConfigSettingsUpdatedPayload, Ls as EnvironmentHttpUnauthorizedError, Lt as WsSubscribeTerminalMetadataRpc, Lu as AuthCreatePairingCredentialInput, Ma as ResolvedKeybindingRule, Mc as OrchestrationSession, Mi as ServerUpsertKeybindingInput, Ml as ThreadTurnStartCommand, Mn as VcsCreateRefInput, Mo as DesktopEnvironmentBootstrapSchema, Mr as VcsUnsupportedOperationError, Ms as EnvironmentHttpBadRequestError, Mt as WsSourceControlPublishRepositoryRpc, Mu as AuthBrowserSessionResult, Na as ResolvedKeybindingsConfig, Nc as OrchestrationSessionStatus, Ni as ServerUpsertKeybindingResult, Nl as ThreadTurnStartRequestedPayload, Nn as VcsCreateRefResult, No as DesktopRuntimeArchSchema, Nr as ServerConfig, Ns as EnvironmentHttpCommonError, Nt as WsSubscribeAuthAccessRpc, Nu as AuthClientMetadata, Oa as MAX_SCRIPT_ID_LENGTH, Oc as OrchestrationReadModel, Oi as ServerTraceDiagnosticsRecentFailure, Ol as ThreadSessionStopRequestedPayload, On as GitRunStackedActionResult, Oo as DesktopAppStageLabelSchema, Or as VcsProcessTimeoutError, Os as EnvironmentCloudPreferencesRequest, Ot as WsServerUpsertKeybindingRpc, Ou as AuthAccessTokenType, Pa as SCRIPT_RUN_COMMAND_PATTERN, Pc as OrchestrationShellSnapshot, Pi as isProviderAvailable, Pl as ThreadUnarchivedPayload, Pn as VcsCreateWorktreeInput, Po as DesktopRuntimeInfoSchema, Pr as ServerConfigIssue, Ps as EnvironmentHttpConflictError, Pt as WsSubscribeServerConfigRpc, Pu as AuthClientMetadataDeviceType, Qa as ProviderInterruptTurnInput, Qc as ProjectMetaUpdatedPayload, Qi as MAX_SIDEBAR_THREAD_PREVIEW_COUNT, Ql as ProviderInstanceConfig, Qn as SourceControlCloneProtocol, Qo as DesktopUpdateChannelSchema, Qr as ServerProcessResourceHistoryBucket, Qs as DEFAULT_PROVIDER_INTERACTION_MODE, Qt as WsVcsRemoveWorktreeRpc, Qu as AuthTerminalOperateScope, Ra as CanonicalRequestType, Rc as OrchestrationThread, Ri as CodexSettings, Rl as DEFAULT_GIT_TEXT_GENERATION_MODEL_BY_PROVIDER, Rn as VcsListRefsResult, Ro as DesktopSshBearerRequestInputSchema, Rr as ServerConfigStreamEvent, Rs as EnvironmentInternalError, Rt as WsSubscribeVcsStatusRpc, Ru as AuthEnvironmentBootstrapTokenType, Sa as KeybindingWhenNode, Sc as OrchestrationMessage, Sd as RuntimeSessionId, Si as ServerRemoveKeybindingResult, Sl as ThreadMessageSentPayload, Sn as GitManagerServiceError, So as TerminalSessionStatus, Sr as VcsFreshnessSource, Ss as EnvironmentAuthInvalidError, St as WsServerGetTraceDiagnosticsRpc, Su as AuthAccessStreamError, Ta as MAX_KEYBINDINGS_COUNT, Tc as OrchestrationProjectShell, Td as TrimmedNonEmptyString, Ti as ServerTraceDiagnosticsErrorKind, Tl as ThreadRevertedPayload, Tn as GitPullRequestRefInput, To as TerminalWriteInput, Tr as VcsOutputDecodeError, Ts as EnvironmentAuthenticatedPrincipal, Tt as WsServerSignalProcessRpc, Tu as AuthAccessStreamPairingLinkUpsertedEvent, Ua as ProviderRuntimeTurnStatus, Uc as OrchestrationThreadGoalStatus, Ui as DEFAULT_CONTEXT_MENU_STYLE, Ul as PROVIDER_DISPLAY_NAMES, Un as VcsStatusInput, Uo as DesktopSshEnvironmentTargetSchema, Ur as ServerConfigUpdatedPayload, Us as EnvironmentOrchestrationHttpApi, Ut as WsTerminalResizeRpc, Uu as AuthPairingCredentialResult, Va as ProviderRuntimeEventV2, Vc as OrchestrationThreadDetailSnapshot, Vi as DEFAULT_AUTOMATIC_GIT_FETCH_INTERVAL, Vl as MODEL_SLUG_ALIASES_BY_PROVIDER, Vn as VcsRef, Vo as DesktopSshEnvironmentEnsureOptionsSchema, Vr as ServerConfigStreamSettingsUpdatedEvent, Vs as EnvironmentOperationForbiddenError, Vt as WsTerminalCloseRpc, Vu as AuthOrchestrationOperateScope, Wa as RuntimeEventRaw, Wc as OrchestrationThreadShell, Wi as DEFAULT_SERVER_SETTINGS, Wl as ProviderOptionChoice, Wn as VcsStatusLocalResult, Wo as DesktopSshHostSourceSchema, Wr as ServerLifecycleReadyPayload, Ws as EnvironmentRequestInvalidError, Wt as WsTerminalRestartRpc, Wu as AuthPairingLink, Xa as ProviderEvent, Xc as ProjectCreatedPayload, Xi as DEFAULT_UNIFIED_SETTINGS, Xl as SelectProviderOptionDescriptor, Xn as ChangeRequest, Xo as DesktopThemeSchema, Xr as ServerProcessDiagnosticsEntry, Xs as ClientOrchestrationCommand, Xt as WsVcsPullRpc, Xu as AuthSessionState, Ya as isToolLifecycleItemType, Yc as ProjectCreateCommand, Yi as DEFAULT_TIMESTAMP_FORMAT, Yl as ProviderOptionSelections, Yn as VcsSwitchRefResult, Yo as DesktopSshPasswordPromptResolutionInputSchema, Yr as ServerObservability, Ys as ChatImageAttachment, Yt as WsVcsListRefsRpc, Yu as AuthRevokePairingLinkInput, Za as ProviderGoalRequestInput, Zc as ProjectDeletedPayload, Zi as GrokSettings, Zl as ProviderDriverKind, Zn as ChangeRequestState, Zo as DesktopUpdateActionResultSchema, Zr as ServerProcessDiagnosticsResult, Zs as CorrelationId, Zt as WsVcsRefreshStatusRpc, Zu as AuthStandardClientScopes, _a as KeybindingCommand, _c as OrchestrationGetSnapshotError, _d as PositiveInt, _i as ServerProviderUpdatedPayload, _l as ThreadGoalClearedPayload, _n as GitActionProgressKind, _o as TerminalOpenInput, _r as VcsDiscoveryItem, _s as RelayClientStatusSchema, _t as WsServerDiscoverSourceControlRpc, _u as ScopedThreadSessionRef, aa as SidebarProjectGroupingMode, ac as OrchestrationCheckpointFile, ad as ServerAuthPolicy, ai as ServerProviderAuthStatus, al as ProviderInteractionMode, an as FilesystemBrowseEntry, ao as ProviderTurnStartResult, ar as SourceControlProviderDiscoveryItem, as as AdvertisedEndpointCompatibility, at as WsGitRunStackedActionRpc, au as defaultInstanceIdForDriver, ba as KeybindingValue, bc as OrchestrationGetTurnDiffResult, bd as RuntimeItemId, bi as ServerProviders, bl as ThreadGoalUpdatedPayload, bn as GitCommandError, bo as TerminalSessionLookupError, br as VcsError, bs as AuthPairingLinkRevokeResult, bt as WsServerGetProcessResourceHistoryRpc, bu as AuthAccessStreamClientRemovedEvent, ca as SidebarThreadSortOrder, cc as OrchestrationCommand, cd as AuthSessionId, ci as ServerProviderModel, cl as ProviderSessionRuntimeStatus, cn as FilesystemBrowseResult, co as TerminalAttachStreamEvent, cr as SourceControlProviderKind, cs as AdvertisedEndpointProviderKind, ct as WsOrchestrationGetFullThreadDiffRpc, cu as ExecutionEnvironmentCapabilities, da as makeProviderSettingsSchema, dc as OrchestrationEvent, dd as EnvironmentId, di as ServerProviderSlashCommandInput, dl as ThreadActivityAppendedPayload, dn as ProjectSearchEntriesInput, do as TerminalCwdError, dr as SourceControlPublishStatus, ds as AdvertisedEndpointStatus, dt as WsOrchestrationSubscribeShellRpc, du as ExecutionEnvironmentPlatformArch, ea as ObservabilitySettings, ec as DispatchResult, ed as AuthTokenExchangeRequest, ei as ServerProcessResourceHistoryResult, el as ProjectScriptIcon, en as ReviewDiffPreviewError, eo as ProviderRespondToUserInputInput, er as SourceControlCloneRepositoryResult, es as DesktopUpdateStateSchema, et as WsCloudGetRelayClientStatusRpc, eu as ProviderInstanceEnvironment, fa as EDITORS, fc as OrchestrationEventMetadata, fd as EventId, fi as ServerProviderState, fl as ThreadApprovalResponseRequestedPayload, fn as ProjectSearchEntriesResult, fo as TerminalError, fr as SourceControlRepositoryCloneUrls, fs as DesktopBackendBootstrap, ft as WsOrchestrationSubscribeThreadRpc, fu as ExecutionEnvironmentPlatformOs, ga as LaunchEditorInput, gc as OrchestrationGetFullThreadDiffResult, gd as PortSchema, gi as ServerProviderUpdateStatus, gl as ThreadDeletedPayload, gn as GitActionProgressEvent, go as TerminalNotRunningError, gr as SourceControlRepositoryVisibility, gs as RelayClientInstallProgressStageSchema, gt as WsRpcGroup, gu as ScopedThreadRef, ha as ExternalLauncherError, hc as OrchestrationGetFullThreadDiffInput, hd as NonNegativeInt, hi as ServerProviderUpdateState, hl as ThreadCreatedPayload, hn as ProjectWriteFileResult, ho as TerminalMetadataStreamEvent, hr as SourceControlRepositoryLookupInput, hs as RelayClientInstallProgressEventSchema, ht as WsReviewGetDiffPreviewRpc, hu as ScopedProjectRef, ia as ServerSettingsPatch, ic as OrchestrationAggregateKind, id as ServerAuthDescriptor, ii as ServerProviderAuth, il as ProviderApprovalPolicy, in as ReviewDiffPreviewSourceKind, io as ProviderStopSessionInput, ir as SourceControlProviderAuthStatus, is as AdvertisedEndpoint, it as WsGitResolvePullRequestRpc, iu as ProviderInstanceRef, ja as MODEL_PICKER_KEYBINDING_COMMANDS, jc as OrchestrationRpcSchemas, ji as ServerTraceDiagnosticsSpanSummary, jl as ThreadTurnInterruptRequestedPayload, jn as TextGenerationError, jo as DesktopDiscoveredSshHostSchema, jr as VcsRepositoryIdentity, js as EnvironmentHttpApi, jt as WsSourceControlLookupRepositoryRpc, ju as AuthBrowserSessionRequest, ka as MAX_WHEN_EXPRESSION_DEPTH, kc as OrchestrationReplayEventsError, ki as ServerTraceDiagnosticsResult, kl as ThreadTurnDiff, kn as GitRunStackedActionToastRunAction, ko as DesktopCloudAuthFetchInputSchema, kr as VcsRemote, ks as EnvironmentCloudRelayConfigResult, kt as WsShellOpenInEditorRpc, ku as AuthAccessWriteScope, la as ThreadEnvMode, lc as OrchestrationCommandReceiptStatus, ld as CheckpointRef, li as ServerProviderSkill, ll as ProviderUserInputAnswers, ln as ProjectEntry, lo as TerminalClearInput, lr as SourceControlPublishRepositoryInput, ls as AdvertisedEndpointReachability, lt as WsOrchestrationGetTurnDiffRpc, lu as ExecutionEnvironmentDescriptor, ma as EditorLaunchStyle, mc as OrchestrationGetFullThreadDiffError, md as MessageId, mi as ServerProviderUpdateInput, ml as ThreadCheckpointRevertRequestedPayload, mn as ProjectWriteFileInput, mo as TerminalHistoryError, mr as SourceControlRepositoryInfo, ms as RelayClientInstallFailureReasonSchema, mt as WsProjectsWriteFileRpc, mu as RepositoryIdentityLocator, na as ServerSettings, nc as ORCHESTRATION_WS_METHODS, nd as EnvironmentAuthorizationError, ni as ServerProcessSignal, nl as ProjectionPendingApprovalStatus, nn as ReviewDiffPreviewResult, no as ProviderSession, nr as SourceControlDiscoveryStatus, ns as PersistedSavedEnvironmentRecordSchema, nt as WsFilesystemBrowseRpc, nu as ProviderInstanceEnvironmentVariableName, oa as SidebarProjectSortOrder, oc as OrchestrationCheckpointStatus, od as ServerAuthSessionMethod, oi as ServerProviderAvailability, ol as ProviderRequestKind, on as FilesystemBrowseError, oo as DEFAULT_TERMINAL_ID, or as SourceControlProviderError, os as AdvertisedEndpointHostedHttpsCompatibility, ot as WsOrchestrationDispatchCommandRpc, ou as isProviderDriverKind, pa as EditorId, pc as OrchestrationEventType, pd as IsoDateTime, pi as ServerProviderUpdateError, pl as ThreadArchivedPayload, pn as ProjectWriteFileError, po as TerminalEvent, pr as SourceControlRepositoryError, ps as RelayClientInstallFailedError, pt as WsProjectsSearchEntriesRpc, pu as RepositoryIdentity, qa as ToolLifecycleItemType, qc as PROVIDER_SEND_TURN_MAX_IMAGE_BYTES, qi as DEFAULT_SIDEBAR_THREAD_PREVIEW_COUNT, ql as ProviderOptionSelection, qn as VcsStatusStreamEvent, qo as DesktopSshPasswordPromptCancelledType, qr as ServerLifecycleStreamWelcomeEvent, qs as AssistantDeliveryMode, qt as WsVcsCreateWorktreeRpc, qu as AuthReviewWriteScope, ra as ServerSettingsError, rc as OrchestrationActorKind, rd as ServerAuthBootstrapMethod, ri as ServerProvider, rl as ProviderApprovalDecision, rn as ReviewDiffPreviewSource, ro as ProviderSessionStartInput, rr as SourceControlProviderAuth, rs as PickFolderOptionsSchema, rt as WsGitPreparePullRequestThreadRpc, ru as ProviderInstanceId, sa as SidebarThreadPreviewCount, sc as OrchestrationCheckpointSummary, sd as ApprovalRequestId, si as ServerProviderContinuation, sl as ProviderSandboxMode, sn as FilesystemBrowseInput, so as TerminalAttachInput, sr as SourceControlProviderInfo, ss as AdvertisedEndpointProvider, st as WsOrchestrationGetArchivedShellSnapshotRpc, su as EnvironmentConnectionState, ta as OpenCodeSettings, tc as ModelSelection, td as AuthWebSocketTicketResult, ti as ServerProcessResourceHistorySummary, tl as ProjectionPendingApprovalDecision, tn as ReviewDiffPreviewInput, to as ProviderSendTurnInput, tr as SourceControlDiscoveryResult, ts as DesktopUpdateStatusSchema, tt as WsCloudInstallRelayClientRpc, tu as ProviderInstanceEnvironmentVariable, ua as TimestampFormat, uc as OrchestrationDispatchCommandError, ud as CommandId, ui as ServerProviderSlashCommand, ul as RuntimeMode, un as ProjectSearchEntriesError, uo as TerminalCloseInput, ur as SourceControlPublishRepositoryResult, us as AdvertisedEndpointSource, ut as WsOrchestrationReplayEventsRpc, uu as ExecutionEnvironmentPlatform, va as KeybindingRule, vc as OrchestrationGetTurnDiffError, vd as ProjectId, vi as ServerProviderVersionAdvisory, vl as ThreadGoalRequest, vn as GitActionProgressPhase, vo as TerminalResizeInput, vr as VcsDriverCapabilities, vs as AuthClientSessionRevokeResult, vt as WsServerGetConfigRpc, vu as AuthAccessReadScope, wa as KeybindingsConfigError, wc as OrchestrationProject, wd as ThreadId, wi as ServerSignalProcessResult, wl as ThreadProposedPlanUpsertedPayload, wn as GitPreparePullRequestThreadResult, wo as TerminalThreadInput, wr as VcsListWorkspaceFilesResult, ws as EnvironmentAuthenticatedAuth, wt as WsServerRemoveKeybindingRpc, wu as AuthAccessStreamPairingLinkRemovedEvent, xa as KeybindingWhen, xc as OrchestrationLatestTurn, xd as RuntimeRequestId, xi as ServerRemoveKeybindingInput, xl as ThreadInteractionModeSetPayload, xn as GitManagerError, xo as TerminalSessionSnapshot, xr as VcsFreshness, xs as EnvironmentAuthHttpApi, xt as WsServerGetSettingsRpc, xu as AuthAccessStreamClientUpsertedEvent, ya as KeybindingShortcut, yc as OrchestrationGetTurnDiffInput, yd as ProviderItemId, yi as ServerProviderVersionAdvisoryStatus, yl as ThreadGoalRequestedPayload, yn as GitActionProgressStream, yo as TerminalRestartInput, yr as VcsDriverKind, ys as AuthOtherClientSessionsRevokeResult, yt as WsServerGetProcessDiagnosticsRpc, yu as AuthAccessSnapshot, za as ItemLifecyclePayload, zc as OrchestrationThreadActivity, zi as ContextMenuStyle, zl as DEFAULT_MODEL, zn as VcsPullInput, zo as DesktopSshEnvironmentBootstrapSchema, zr as ServerConfigStreamKeybindingsUpdatedEvent, zs as EnvironmentInternalErrorReason, zt as WsTerminalAttachRpc, zu as AuthEnvironmentScope } from "./shared.js";
 export { AdvertisedEndpoint, AdvertisedEndpointCompatibility, AdvertisedEndpointHostedHttpsCompatibility, AdvertisedEndpointProvider, AdvertisedEndpointProviderKind, AdvertisedEndpointReachability, AdvertisedEndpointSource, AdvertisedEndpointStatus, ApprovalRequestId, AssistantDeliveryMode, AuthAccessReadScope, AuthAccessSnapshot, AuthAccessStreamClientRemovedEvent, AuthAccessStreamClientUpsertedEvent, AuthAccessStreamError, AuthAccessStreamEvent, AuthAccessStreamPairingLinkRemovedEvent, AuthAccessStreamPairingLinkUpsertedEvent, AuthAccessStreamSnapshotEvent, AuthAccessTokenResult, AuthAccessTokenType, AuthAccessWriteScope, AuthAdministrativeScopes, AuthBrowserSessionRequest, AuthBrowserSessionResult, AuthClientMetadata, AuthClientMetadataDeviceType, AuthClientPresentationMetadata, AuthClientSession, AuthClientSessionRevokeResult, AuthCreatePairingCredentialInput, AuthEnvironmentBootstrapTokenType, AuthEnvironmentScope, AuthEnvironmentScopes, AuthOrchestrationOperateScope, AuthOrchestrationReadScope, AuthOtherClientSessionsRevokeResult, AuthPairingCredentialResult, AuthPairingLink, AuthPairingLinkRevokeResult, AuthRelayReadScope, AuthRelayWriteScope, AuthReviewWriteScope, AuthRevokeClientSessionInput, AuthRevokePairingLinkInput, AuthSessionId, AuthSessionState, AuthStandardClientScopes, AuthTerminalOperateScope, AuthTokenExchangeGrantType, AuthTokenExchangeRequest, AuthWebSocketTicketResult, BooleanProviderOptionDescriptor, CanonicalItemType, CanonicalRequestType, ChangeRequest, ChangeRequestState, ChatAttachment, ChatImageAttachment, CheckpointRef, ClaudeSettings, ClientOrchestrationCommand, ClientSettingsPatch, ClientSettingsSchema, CodexSettings, CommandId, ContextMenuItemSchema, ContextMenuStyle, CorrelationId, CursorSettings, DEFAULT_AUTOMATIC_GIT_FETCH_INTERVAL, DEFAULT_CLIENT_SETTINGS, DEFAULT_CONTEXT_MENU_STYLE, DEFAULT_GIT_TEXT_GENERATION_MODEL, DEFAULT_GIT_TEXT_GENERATION_MODEL_BY_PROVIDER, DEFAULT_MODEL, DEFAULT_MODEL_BY_PROVIDER, DEFAULT_PROVIDER_INTERACTION_MODE, DEFAULT_RUNTIME_MODE, DEFAULT_SERVER_SETTINGS, DEFAULT_SIDEBAR_PROJECT_GROUPING_MODE, DEFAULT_SIDEBAR_PROJECT_SORT_ORDER, DEFAULT_SIDEBAR_THREAD_PREVIEW_COUNT, DEFAULT_SIDEBAR_THREAD_SORT_ORDER, DEFAULT_TERMINAL_ID, DEFAULT_TIMESTAMP_FORMAT, DEFAULT_UNIFIED_SETTINGS, DesktopAppBrandingSchema, DesktopAppStageLabelSchema, DesktopBackendBootstrap, DesktopCloudAuthFetchInputSchema, DesktopCloudAuthFetchResultSchema, DesktopDiscoveredSshHostSchema, DesktopEnvironmentBootstrapSchema, DesktopRuntimeArchSchema, DesktopRuntimeInfoSchema, DesktopServerExposureModeSchema, DesktopServerExposureStateSchema, DesktopSshBearerBootstrapInputSchema, DesktopSshBearerRequestInputSchema, DesktopSshEnvironmentBootstrapSchema, DesktopSshEnvironmentEnsureInputSchema, DesktopSshEnvironmentEnsureOptionsSchema, DesktopSshEnvironmentEnsureResultSchema, DesktopSshEnvironmentTargetSchema, DesktopSshHostSourceSchema, DesktopSshHttpBaseUrlInputSchema, DesktopSshPasswordPromptCancelledResultSchema, DesktopSshPasswordPromptCancelledType, DesktopSshPasswordPromptRequestSchema, DesktopSshPasswordPromptResolutionInputSchema, DesktopThemeSchema, DesktopUpdateActionResultSchema, DesktopUpdateChannelSchema, DesktopUpdateCheckResultSchema, DesktopUpdateStateSchema, DesktopUpdateStatusSchema, DispatchResult, EDITORS, EditorId, EditorLaunchStyle, EnvironmentAuthHttpApi, EnvironmentAuthInvalidError, EnvironmentAuthInvalidReason, EnvironmentAuthenticatedAuth, EnvironmentAuthenticatedPrincipal, EnvironmentAuthorizationError, EnvironmentCloudEndpointUnavailableError, EnvironmentCloudLinkStateResult, EnvironmentCloudPreferencesRequest, EnvironmentCloudRelayConfigResult, EnvironmentConnectHttpApi, EnvironmentConnectionState, EnvironmentHttpApi, EnvironmentHttpBadRequestError, EnvironmentHttpCommonError, EnvironmentHttpConflictError, EnvironmentHttpForbiddenError, EnvironmentHttpInternalServerError, EnvironmentHttpUnauthorizedError, EnvironmentId, EnvironmentInternalError, EnvironmentInternalErrorReason, EnvironmentMetadataHttpApi, EnvironmentOperationForbiddenError, EnvironmentOperationForbiddenReason, EnvironmentOrchestrationHttpApi, EnvironmentRequestInvalidError, EnvironmentRequestInvalidReason, EnvironmentScopeRequiredError, EventId, ExecutionEnvironmentCapabilities, ExecutionEnvironmentDescriptor, ExecutionEnvironmentPlatform, ExecutionEnvironmentPlatformArch, ExecutionEnvironmentPlatformOs, ExternalLauncherError, FilesystemBrowseEntry, FilesystemBrowseError, FilesystemBrowseInput, FilesystemBrowseResult, GitActionProgressEvent, GitActionProgressKind, GitActionProgressPhase, GitActionProgressStream, GitCommandError, GitManagerError, GitManagerServiceError, GitPreparePullRequestThreadInput, GitPreparePullRequestThreadResult, GitPullRequestRefInput, GitResolvePullRequestResult, GitRunStackedActionInput, GitRunStackedActionResult, GitRunStackedActionToastRunAction, GitStackedAction, GrokSettings, IsoDateTime, ItemLifecyclePayload, KeybindingCommand, KeybindingRule, KeybindingShortcut, KeybindingValue, KeybindingWhen, KeybindingWhenNode, KeybindingsConfig, KeybindingsConfigError, LaunchEditorInput, MAX_KEYBINDINGS_COUNT, MAX_KEYBINDING_VALUE_LENGTH, MAX_KEYBINDING_WHEN_LENGTH, MAX_SCRIPT_ID_LENGTH, MAX_SIDEBAR_THREAD_PREVIEW_COUNT, MAX_WHEN_EXPRESSION_DEPTH, MIN_SIDEBAR_THREAD_PREVIEW_COUNT, MODEL_PICKER_JUMP_KEYBINDING_COMMANDS, MODEL_PICKER_KEYBINDING_COMMANDS, MODEL_SLUG_ALIASES_BY_PROVIDER, MessageId, ModelCapabilities, ModelSelection, NonNegativeInt, ORCHESTRATION_WS_METHODS, ObservabilitySettings, OpenCodeSettings, OrchestrationActorKind, OrchestrationAggregateKind, OrchestrationCheckpointFile, OrchestrationCheckpointStatus, OrchestrationCheckpointSummary, OrchestrationCommand, OrchestrationCommandReceiptStatus, OrchestrationDispatchCommandError, OrchestrationEvent, OrchestrationEventMetadata, OrchestrationEventType, OrchestrationGetFullThreadDiffError, OrchestrationGetFullThreadDiffInput, OrchestrationGetFullThreadDiffResult, OrchestrationGetSnapshotError, OrchestrationGetTurnDiffError, OrchestrationGetTurnDiffInput, OrchestrationGetTurnDiffResult, OrchestrationLatestTurn, OrchestrationMessage, OrchestrationMessageRole, OrchestrationProject, OrchestrationProjectShell, OrchestrationProposedPlan, OrchestrationProposedPlanId, OrchestrationReadModel, OrchestrationReplayEventsError, OrchestrationReplayEventsInput, OrchestrationRpcSchemas, OrchestrationSession, OrchestrationSessionStatus, OrchestrationShellSnapshot, OrchestrationShellStreamEvent, OrchestrationShellStreamItem, OrchestrationSubscribeThreadInput, OrchestrationThread, OrchestrationThreadActivity, OrchestrationThreadActivityTone, OrchestrationThreadDetailSnapshot, OrchestrationThreadGoal, OrchestrationThreadGoalStatus, OrchestrationThreadShell, OrchestrationThreadStreamItem, PROVIDER_DISPLAY_NAMES, PROVIDER_SEND_TURN_MAX_ATTACHMENTS, PROVIDER_SEND_TURN_MAX_IMAGE_BYTES, PROVIDER_SEND_TURN_MAX_INPUT_CHARS, PersistedSavedEnvironmentRecordSchema, PickFolderOptionsSchema, PortSchema, PositiveInt, ProjectCreateCommand, ProjectCreatedPayload, ProjectDeletedPayload, ProjectEntry, ProjectId, ProjectMetaUpdatedPayload, ProjectScript, ProjectScriptIcon, ProjectSearchEntriesError, ProjectSearchEntriesInput, ProjectSearchEntriesResult, ProjectWriteFileError, ProjectWriteFileInput, ProjectWriteFileResult, ProjectionPendingApprovalDecision, ProjectionPendingApprovalStatus, ProviderApprovalDecision, ProviderApprovalPolicy, ProviderDriverKind, ProviderEvent, ProviderGoalRequestInput, ProviderInstanceConfig, ProviderInstanceConfigMap, ProviderInstanceEnvironment, ProviderInstanceEnvironmentVariable, ProviderInstanceEnvironmentVariableName, ProviderInstanceId, ProviderInstanceRef, ProviderInteractionMode, ProviderInterruptTurnInput, ProviderItemId, ProviderOptionChoice, ProviderOptionDescriptor, ProviderOptionDescriptorType, ProviderOptionSelection, ProviderOptionSelectionValue, ProviderOptionSelections, ProviderRequestKind, ProviderRespondToRequestInput, ProviderRespondToUserInputInput, ProviderRuntimeEvent, ProviderRuntimeEventV2, ProviderRuntimeThreadGoalStatus, ProviderRuntimeTurnStatus, ProviderSandboxMode, ProviderSendTurnInput, ProviderSession, ProviderSessionRuntimeStatus, ProviderSessionStartInput, ProviderStopSessionInput, ProviderTurnStartResult, ProviderUserInputAnswers, RelayClientInstallFailedError, RelayClientInstallFailureReasonSchema, RelayClientInstallProgressEventSchema, RelayClientInstallProgressStageSchema, RelayClientStatusSchema, RepositoryIdentity, RepositoryIdentityLocator, ResolvedKeybindingRule, ResolvedKeybindingsConfig, ReviewDiffPreviewError, ReviewDiffPreviewInput, ReviewDiffPreviewResult, ReviewDiffPreviewSource, ReviewDiffPreviewSourceKind, RuntimeEventRaw, RuntimeItemId, RuntimeMode, RuntimeRequestId, RuntimeSessionId, RuntimeTaskId, SCRIPT_RUN_COMMAND_PATTERN, ScopedProjectRef, ScopedThreadRef, ScopedThreadSessionRef, SelectProviderOptionDescriptor, ServerAuthBootstrapMethod, ServerAuthDescriptor, ServerAuthPolicy, ServerAuthSessionMethod, ServerConfig, ServerConfigIssue, ServerConfigKeybindingsUpdatedPayload, ServerConfigProviderStatusesPayload, ServerConfigSettingsUpdatedPayload, ServerConfigStreamEvent, ServerConfigStreamKeybindingsUpdatedEvent, ServerConfigStreamProviderStatusesEvent, ServerConfigStreamSettingsUpdatedEvent, ServerConfigStreamSnapshotEvent, ServerConfigUpdatedPayload, ServerLifecycleReadyPayload, ServerLifecycleStreamEvent, ServerLifecycleStreamReadyEvent, ServerLifecycleStreamWelcomeEvent, ServerLifecycleWelcomePayload, ServerObservability, ServerProcessDiagnosticsEntry, ServerProcessDiagnosticsResult, ServerProcessResourceHistoryBucket, ServerProcessResourceHistoryInput, ServerProcessResourceHistoryResult, ServerProcessResourceHistorySummary, ServerProcessSignal, ServerProvider, ServerProviderAuth, ServerProviderAuthStatus, ServerProviderAvailability, ServerProviderContinuation, ServerProviderModel, ServerProviderSkill, ServerProviderSlashCommand, ServerProviderSlashCommandInput, ServerProviderState, ServerProviderUpdateError, ServerProviderUpdateInput, ServerProviderUpdateState, ServerProviderUpdateStatus, ServerProviderUpdatedPayload, ServerProviderVersionAdvisory, ServerProviderVersionAdvisoryStatus, ServerProviders, ServerRemoveKeybindingInput, ServerRemoveKeybindingResult, ServerSettings, ServerSettingsError, ServerSettingsPatch, ServerSignalProcessInput, ServerSignalProcessResult, ServerTraceDiagnosticsErrorKind, ServerTraceDiagnosticsFailureSummary, ServerTraceDiagnosticsLogEvent, ServerTraceDiagnosticsRecentFailure, ServerTraceDiagnosticsResult, ServerTraceDiagnosticsSpanOccurrence, ServerTraceDiagnosticsSpanSummary, ServerUpsertKeybindingInput, ServerUpsertKeybindingResult, SidebarProjectGroupingMode, SidebarProjectSortOrder, SidebarThreadPreviewCount, SidebarThreadSortOrder, SourceControlCloneProtocol, SourceControlCloneRepositoryInput, SourceControlCloneRepositoryResult, SourceControlDiscoveryResult, SourceControlDiscoveryStatus, SourceControlProviderAuth, SourceControlProviderAuthStatus, SourceControlProviderDiscoveryItem, SourceControlProviderError, SourceControlProviderInfo, SourceControlProviderKind, SourceControlPublishRepositoryInput, SourceControlPublishRepositoryResult, SourceControlPublishStatus, SourceControlRepositoryCloneUrls, SourceControlRepositoryError, SourceControlRepositoryInfo, SourceControlRepositoryLookupInput, SourceControlRepositoryVisibility, THREAD_JUMP_KEYBINDING_COMMANDS, THREAD_KEYBINDING_COMMANDS, TOOL_LIFECYCLE_ITEM_TYPES, TerminalAttachInput, TerminalAttachStreamEvent, TerminalClearInput, TerminalCloseInput, TerminalCwdError, TerminalError, TerminalEvent, TerminalHistoryError, TerminalMetadataStreamEvent, TerminalNotRunningError, TerminalOpenInput, TerminalResizeInput, TerminalRestartInput, TerminalSessionLookupError, TerminalSessionSnapshot, TerminalSessionStatus, TerminalSummary, TerminalThreadInput, TerminalWriteInput, TextGenerationError, ThreadActivityAppendedPayload, ThreadApprovalResponseRequestedPayload, ThreadArchivedPayload, ThreadCheckpointRevertRequestedPayload, ThreadCreatedPayload, ThreadDeletedPayload, ThreadEnvMode, ThreadGoalClearedPayload, ThreadGoalRequest, ThreadGoalRequestedPayload, ThreadGoalUpdatedPayload, ThreadId, ThreadInteractionModeSetPayload, ThreadMessageSentPayload, ThreadMetaUpdatedPayload, ThreadProposedPlanUpsertedPayload, ThreadRevertedPayload, ThreadRuntimeModeSetPayload, ThreadSessionSetPayload, ThreadSessionStopRequestedPayload, ThreadTokenUsageSnapshot, ThreadTurnDiff, ThreadTurnDiffCompletedPayload, ThreadTurnInterruptRequestedPayload, ThreadTurnStartCommand, ThreadTurnStartRequestedPayload, ThreadUnarchivedPayload, TimestampFormat, ToolLifecycleItemType, TrimmedNonEmptyString, TrimmedString, TurnCountRange, TurnId, UserInputQuestion, VcsCreateRefInput, VcsCreateRefResult, VcsCreateWorktreeInput, VcsCreateWorktreeResult, VcsDiscoveryItem, VcsDriverCapabilities, VcsDriverKind, VcsError, VcsFreshness, VcsFreshnessSource, VcsInitInput, VcsListRefsInput, VcsListRefsResult, VcsListRemotesResult, VcsListWorkspaceFilesResult, VcsOutputDecodeError, VcsProcessExitError, VcsProcessSpawnError, VcsProcessTimeoutError, VcsPullInput, VcsPullResult, VcsRef, VcsRemote, VcsRemoveWorktreeInput, VcsRepositoryDetectionError, VcsRepositoryIdentity, VcsStatusInput, VcsStatusLocalResult, VcsStatusRemoteResult, VcsStatusResult, VcsStatusStreamEvent, VcsSwitchRefInput, VcsSwitchRefResult, VcsUnsupportedOperationError, WS_METHODS, WsCloudGetRelayClientStatusRpc, WsCloudInstallRelayClientRpc, WsFilesystemBrowseRpc, WsGitPreparePullRequestThreadRpc, WsGitResolvePullRequestRpc, WsGitRunStackedActionRpc, WsOrchestrationDispatchCommandRpc, WsOrchestrationGetArchivedShellSnapshotRpc, WsOrchestrationGetFullThreadDiffRpc, WsOrchestrationGetTurnDiffRpc, WsOrchestrationReplayEventsRpc, WsOrchestrationSubscribeShellRpc, WsOrchestrationSubscribeThreadRpc, WsProjectsSearchEntriesRpc, WsProjectsWriteFileRpc, WsReviewGetDiffPreviewRpc, WsRpcGroup, WsServerDiscoverSourceControlRpc, WsServerGetConfigRpc, WsServerGetProcessDiagnosticsRpc, WsServerGetProcessResourceHistoryRpc, WsServerGetSettingsRpc, WsServerGetTraceDiagnosticsRpc, WsServerRefreshProvidersRpc, WsServerRemoveKeybindingRpc, WsServerSignalProcessRpc, WsServerUpdateProviderRpc, WsServerUpdateSettingsRpc, WsServerUpsertKeybindingRpc, WsShellOpenInEditorRpc, WsSourceControlCloneRepositoryRpc, WsSourceControlLookupRepositoryRpc, WsSourceControlPublishRepositoryRpc, WsSubscribeAuthAccessRpc, WsSubscribeServerConfigRpc, WsSubscribeServerLifecycleRpc, WsSubscribeTerminalEventsRpc, WsSubscribeTerminalMetadataRpc, WsSubscribeVcsStatusRpc, WsTerminalAttachRpc, WsTerminalClearRpc, WsTerminalCloseRpc, WsTerminalOpenRpc, WsTerminalResizeRpc, WsTerminalRestartRpc, WsTerminalWriteRpc, WsVcsCreateRefRpc, WsVcsCreateWorktreeRpc, WsVcsInitRpc, WsVcsListRefsRpc, WsVcsPullRpc, WsVcsRefreshStatusRpc, WsVcsRemoveWorktreeRpc, WsVcsSwitchRefRpc, defaultInstanceIdForDriver, isProviderAvailable, isProviderDriverKind, isToolLifecycleItemType, makeProviderSettingsSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "t3code-cli",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "CLI for t3code",
   "keywords": [
     "claude",

package/src/cli/app.ts

@@ -4,14 +4,26 @@ import { createAuthCommand } from "./auth.ts";
 import { createModelCommand } from "./model.ts";
 import { createProjectCommand } from "./project.ts";
 import { createThreadCommand } from "./thread.ts";
+import { listThreadsCommand } from "./threads/list.ts";
+import { sendThreadCommand } from "./threads/send.ts";
+import { showThreadCommand } from "./threads/show.ts";
+import { startThreadCommand } from "./threads/start.ts";
+import { getThreadTranscriptCommand } from "./threads/messages.ts";
+import { waitForThreadCommand } from "./threads/wait.ts";
 
 export function createCliCommand() {
   return Command.make("t3cli").pipe(
     Command.withDescription("non-interactive cli for running t3code server"),
     Command.withSubcommands([
       createAuthCommand(),
+      listThreadsCommand,
       createModelCommand(),
       createProjectCommand(),
+      startThreadCommand,
+      sendThreadCommand,
+      showThreadCommand,
+      getThreadTranscriptCommand,
+      waitForThreadCommand,
       createThreadCommand(),
     ]),
   );

package/src/cli/thread.ts

@@ -3,27 +3,15 @@ import { Command } from "effect/unstable/cli";
 import { approveThreadCommand } from "./threads/approve.ts";
 import { archiveThreadCommand } from "./threads/archive.ts";
 import { callbackThreadCommand } from "./threads/callback.ts";
-import { listThreadsCommand } from "./threads/list.ts";
-import { getThreadMessagesCommand } from "./threads/messages.ts";
 import { respondThreadCommand } from "./threads/respond.ts";
-import { sendThreadCommand } from "./threads/send.ts";
-import { showThreadCommand } from "./threads/show.ts";
-import { startThreadCommand } from "./threads/start.ts";
-import { waitForThreadCommand } from "./threads/wait.ts";
 
 export function createThreadCommand() {
   return Command.make("thread").pipe(
-    Command.withDescription("thread commands"),
+    Command.withDescription("advanced thread commands"),
     Command.withSubcommands([
-      listThreadsCommand,
-      startThreadCommand,
-      sendThreadCommand,
-      showThreadCommand,
       approveThreadCommand,
       respondThreadCommand,
       archiveThreadCommand,
-      getThreadMessagesCommand,
-      waitForThreadCommand,
       callbackThreadCommand,
     ]),
   );

package/src/cli/threads/messages.ts

@@ -12,8 +12,8 @@ import { Environment } from "../../environment/service.ts";
 import { resolveOutputFormat } from "../output-format.ts";
 import { T3Output } from "../output/service.ts";
 
-export const getThreadMessagesCommand = Command.make(
-  "messages",
+export const getThreadTranscriptCommand = Command.make(
+  "transcript",
   {
     thread: threadFlag,
     limit: Flag.integer("limit").pipe(Flag.withDefault(20)),
@@ -48,4 +48,4 @@ export const getThreadMessagesCommand = Command.make(
       }
       return yield* output.writeStdout(formatThreadMessagesHuman(detail, limit));
     }),
-).pipe(Command.withDescription("get latest thread messages"));
+).pipe(Command.withDescription("get latest thread transcript"));

package/src/domain/thread-lifecycle.test.ts

@@ -0,0 +1,35 @@
+import "vite-plus/test/config";
+
+import { describe, expect, it } from "vite-plus/test";
+import { fromPartial } from "@total-typescript/shoehorn";
+
+import type { OrchestrationThread } from "#t3tools/contracts";
+
+import { isThreadActive, isThreadCompleteEnough } from "./thread-lifecycle.ts";
+
+describe("thread lifecycle", () => {
+  it("treats a ready session with a stale running latestTurn as complete", () => {
+    const thread = fromPartial<OrchestrationThread>({
+      session: {
+        status: "ready",
+      },
+      latestTurn: {
+        state: "running",
+      },
+      messages: [
+        {
+          role: "user",
+          text: "run review",
+        },
+        {
+          role: "assistant",
+          text: "verdict: requested changes",
+          streaming: false,
+        },
+      ],
+    });
+
+    expect(isThreadCompleteEnough(thread)).toBe(true);
+    expect(isThreadActive(thread)).toBe(false);
+  });
+});

package/src/domain/thread-lifecycle.ts

@@ -8,12 +8,13 @@ import {
 import * as Schema from "effect/Schema";
 
 export function isThreadActive(thread: OrchestrationThreadShell | OrchestrationThread) {
-  return (
-    thread.session?.status === "starting" ||
-    thread.session?.status === "running" ||
-    thread.latestTurn?.state === "running" ||
-    isPendingStart(thread)
-  );
+  if (thread.session?.status === "starting" || thread.session?.status === "running") {
+    return true;
+  }
+  if (thread.latestTurn?.state === "running") {
+    return !("messages" in thread && hasTerminalSession(thread) && isThreadCompleteEnough(thread));
+  }
+  return isPendingStart(thread);
 }
 
 export type ThreadLifecycleStatus = ReturnType<typeof threadStatus>;
@@ -91,3 +92,11 @@ function isPendingStart(thread: OrchestrationThreadShell | OrchestrationThread)
   }
   return thread.messages.at(-1)?.role === "user";
 }
+
+function hasTerminalSession(thread: OrchestrationThreadShell | OrchestrationThread) {
+  return (
+    thread.session !== null &&
+    thread.session?.status !== "starting" &&
+    thread.session?.status !== "running"
+  );
+}