t3code-cli 0.9.1 → 0.11.0

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 isAgentEnvironment, $f as FileSystem, $m as getUnsafe, $p as flatMap, Ad as ProjectLookupError, Af as InvalidValue, Am as mergeAll, Ap as endUnsafe, Bf as Struct, Bm as makeUnsafe, Bp as nominal, Cf as run$2, Ch as pipeArguments, Cm as timeoutOrElse, Cp as tap, Df as isFalseValue, Dm as void_, Dp as make$9, Ef as isBoolean, Em as uninterruptible, Ep as get, Fd as resolveWorktreePath, Ff as Terminal, Fm as MinimumLogLevel, Fp as shutdown, Gd as projectPathFlag, Gf as optionalKey, Gm as map$1, Gp as as, Hd as formatFlag, Hf as decodeUnknownEffect, Hm as succeed$1, Hp as acquireRelease, Id as T3Application, If as isQuitError, Im as _await, Ip as unbounded, Jd as threadFormatFlag, Jf as fromReadable, Jm as isSuccess, Jp as catchFilter, Kd as selfActionForceFlag, Kf as Crypto, Km as fail$2, Kp as asVoid, Lf as make$11, Lm as doneUnsafe, Lp as BadArgument, Md as resolveCommandProjectRef, Mf as UnknownSubcommand, Mm as provideMerge, Mp as make$10, Nf as UnrecognizedOption, Nm as succeed$2, Np as offer, Of as isTrueValue, Om as fail$1, Op as drain, Pd as resolveThreadId, Pf as isCliError, Pm as sync$2, Pp as offerUnsafe, Qd as canRenderLiveTerminal, Qf as FileDescriptor, Qm as empty$1, Qp as fail, Rf as Literal, Rm as isDone, Rp as badArgument, Sf as confirm, Sh as pipe, Sm as tapError, Sp as succeed$5, Tf as getTypeName, Tm as try_, Tp as unwrap, Ud as modelFlags, Uf as decodeUnknownSync, Um as ConsoleRef, Up as addFinalizer, Vd as forceFlag, Vf as TaggedErrorClass, Vm as succeed$4, Vp as makeRunMain, Wd as projectFlag, Wf as fromJsonString, Wm as sync$1, Wp as andThen, Xd as worktreeFlag, Xf as Path$1, Xm as Reference, Xp as catch_, Yd as waitFormatFlag, Yf as fromWritable, Ym as succeed$3, Yp as catchTags, Zd as yesFlag, Zf as TypeId$4, Zm as Service, Zp as effectify, _f as getParamMetadata, _h as isNotUndefined, _m as scoped, _p as runFold, af as boolean, ah as getOrUndefined, am as ignore, ap as decodeText, bf as optional$1, bh as dual, bm as suspend, bp as runLast, cf as integer, ch as map$3, cm as mapError, cp as fromIterable, ct as NodeEnvironmentLive, df as string$2, dh as some, dm as orDie, dp as map$4, ef as isInteractiveHumanTerminal, eh as make$12, em as fn, ep as FileTypeId, ff as withAlias, fh as Prototype, fm as provide$1, fp as merge, gf as extractSingleParams, gh as isNotNull, gm as runFork, gp as runDrain, hf as argumentKind, hh as hasProperty, hm as result$1, hp as runCollect, i as AppLayer, if as T3Auth, ih as getOrElse, im as gen, ip as callback$1, jd as ThreadSessionError, jf as ShowHelp, jm as provide, jp as failCauseUnsafe, kd as CliPath, kf as DuplicateOption, km as effect, kp as isSink, lf as map$2, lh as match, lm as match$1, lp as fromQueue, lt as latestAssistantMessage, mf as withDescription$1, mh as BaseProto, ml as ProviderUserInputAnswers, mm as provideService, mp as run$1, nf as Environment, nh as fromNullishOr, nm as forEach, np as WatchBackend, of as choice, oh as isNone, om as interrupt, op as empty, pf as withDefault, ph as withFiber, pm as provideContext, pp as mkString, qd as threadFlag, qf as make$7, qm as isResult, qp as callback, rf as T3Config, rh as fromUndefinedOr, rm as forkScoped, rp as make$8, sf as choiceWithValue, sh as isSome, sm as map, sp as filter, tf as resolveOutputFormat, th as flatMap$1, tm as fnUntraced, tp as Size, uf as optional$2, uh as none, um as matchEffect, up as isStream, ut as threadStatus, vf as isFlagParam, vh as isNullish, vm as serviceOption, vp as runForEach, wf as getChoiceKeys, wm as tryPromise, wp as transduce, xf as string$1, xh as identity, xm as sync, xp as splitLines, yf as isParam, yh as isUndefined, ym as succeed, yp as runHead, zf as String$1, zm as make$13, zp as systemError } from "./shared.js";
 import * as NodeChildProcess from "node:child_process";
 import * as NodeCrypto from "node:crypto";
 import * as NFS from "node:fs";
@@ -142,7 +142,7 @@ const makeHandle = (params) => Object.assign(Object.create(HandleProto), params)
 * @category models
 * @since 4.0.0
 */
-const make$7 = (spawn) => {
+const make$6 = (spawn) => {
 	const streamString = (command, options) => spawn(command).pipe(map((handle) => decodeText(options?.includeStderr === true ? handle.all : handle.stdout)), unwrap);
 	const streamLines = (command, options) => splitLines(streamString(command, options));
 	return ChildProcessSpawner.of({
@@ -253,7 +253,7 @@ const makeStandardCommand = (command, args, options) => Object.assign(Object.cre
 * @category constructors
 * @since 4.0.0
 */
-const make$6 = function make(...args) {
+const make$5 = function make(...args) {
 	if (isTemplateString(args[0])) {
 		const [templates, ...expressions] = args;
 		const tokens = parseTemplates(templates, expressions);
@@ -734,7 +734,7 @@ const layer$11 = /*#__PURE__*/ effect(ChildProcessSpawner, /* @__PURE__ */ gen(f
 					const stdinConfig = resolveStdinOption(command.options);
 					const sourceStream = unwrap(succeed(getSourceStream(handles[handles.length - 1], options.from)));
 					const toOption = options.to ?? "stdin";
-					if (toOption === "stdin") handles.push(yield* spawnCommand(make$6(command.command, command.args, {
+					if (toOption === "stdin") handles.push(yield* spawnCommand(make$5(command.command, command.args, {
 						...command.options,
 						stdin: {
 							...stdinConfig,
@@ -746,7 +746,7 @@ const layer$11 = /*#__PURE__*/ effect(ChildProcessSpawner, /* @__PURE__ */ gen(f
 						if (isNotUndefined(fd)) {
 							const fdName$1 = fdName(fd);
 							const existingFds = command.options.additionalFds ?? {};
-							handles.push(yield* spawnCommand(make$6(command.command, command.args, {
+							handles.push(yield* spawnCommand(make$5(command.command, command.args, {
 								...command.options,
 								additionalFds: {
 									...existingFds,
@@ -756,7 +756,7 @@ const layer$11 = /*#__PURE__*/ effect(ChildProcessSpawner, /* @__PURE__ */ gen(f
 									}
 								}
 							})));
-						} else handles.push(yield* spawnCommand(make$6(command.command, command.args, {
+						} else handles.push(yield* spawnCommand(make$5(command.command, command.args, {
 							...command.options,
 							stdin: {
 								...stdinConfig,
@@ -787,7 +787,7 @@ const layer$11 = /*#__PURE__*/ effect(ChildProcessSpawner, /* @__PURE__ */ gen(f
 			}
 		}
 	});
-	return make$7(spawnCommand);
+	return make$6(spawnCommand);
 }));
 /**
 * Flattens a `Command` into an array of `StandardCommand`s along with pipe
@@ -885,7 +885,7 @@ const digest = (algorithm, data) => try_({
 * @category layers
 * @since 1.0.0
 */
-const layer$9 = /* @__PURE__ */ succeed$2(Crypto, /* @__PURE__ */ make$8({
+const layer$9 = /* @__PURE__ */ succeed$2(Crypto, /* @__PURE__ */ make$7({
 	randomBytes: NodeCrypto.randomBytes,
 	digest
 }));
@@ -1169,7 +1169,7 @@ const symlink = /*#__PURE__*/ (() => {
 	const nodeSymlink = /*#__PURE__*/ effectify(NFS.symlink, /*#__PURE__*/ handleErrnoException("FileSystem", "symlink"), /*#__PURE__*/ handleBadArgument("symlink"));
 	return (target, path) => nodeSymlink(target, path);
 })();
-const truncate = /*#__PURE__*/ (() => {
+const truncate$1 = /*#__PURE__*/ (() => {
 	const nodeTruncate = /*#__PURE__*/ effectify(NFS.truncate, /*#__PURE__*/ handleErrnoException("FileSystem", "truncate"), /*#__PURE__*/ handleBadArgument("truncate"));
 	return (path, length) => nodeTruncate(path, length !== void 0 ? Number(length) : void 0);
 })();
@@ -1230,7 +1230,7 @@ const writeFile = (path, data, options) => callback((resume, signal) => {
 		resume(fail(handleBadArgument("writeFile")(err)));
 	}
 });
-const makeFileSystem = /*#__PURE__*/ map(/*#__PURE__*/ serviceOption(WatchBackend), (backend) => make$9({
+const makeFileSystem = /*#__PURE__*/ map(/*#__PURE__*/ serviceOption(WatchBackend), (backend) => make$8({
 	access,
 	chmod,
 	chown,
@@ -1251,7 +1251,7 @@ const makeFileSystem = /*#__PURE__*/ map(/*#__PURE__*/ serviceOption(WatchBacken
 	rename,
 	stat,
 	symlink,
-	truncate,
+	truncate: truncate$1,
 	utimes,
 	watch(path) {
 		return watch(backend, path);
@@ -1466,7 +1466,7 @@ const Stdio = /*#__PURE__*/ Service(TypeId$2);
 * @category constructors
 * @since 4.0.0
 */
-const make$3 = (options) => ({
+const make$2 = (options) => ({
 	[TypeId$2]: TypeId$2,
 	...options
 });
@@ -1506,7 +1506,7 @@ const make$3 = (options) => ({
 * @category layers
 * @since 4.0.0
 */
-const layer$3 = /* @__PURE__ */ succeed$2(Stdio, /*#__PURE__*/ make$3({
+const layer$3 = /* @__PURE__ */ succeed$2(Stdio, /*#__PURE__*/ make$2({
 	args: /*#__PURE__*/ sync(() => process.argv.slice(2)),
 	stdout: (options) => fromWritable({
 		evaluate: () => process.stdout,
@@ -1539,64 +1539,6 @@ const layer$3 = /* @__PURE__ */ succeed$2(Stdio, /*#__PURE__*/ make$3({
 		closeOnDone: false
 	})
 }));
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Terminal.js
-const TypeId$1 = "~effect/platform/Terminal";
-const QuitErrorTypeId = "effect/platform/Terminal/QuitError";
-ErrorClass("QuitError")({ _tag: /*#__PURE__*/ tag("QuitError") });
-/**
-* Returns `true` if the provided value is a `Terminal.QuitError`.
-*
-* **When to use**
-*
-* Use to narrow unknown failures to `QuitError` when handling terminal input
-* cancellation.
-*
-* **Details**
-*
-* Returns `true` when the value carries the `QuitError` runtime marker and
-* narrows it to `QuitError`.
-*
-* @see {@link QuitError} for the error value produced when terminal input is quit
-*
-* @category guards
-* @since 4.0.0
-*/
-const isQuitError = (u) => hasProperty(u, QuitErrorTypeId);
-/**
-* Service tag for command-line input and output services.
-*
-* **When to use**
-*
-* Use to access or provide platform terminal capabilities such as reading
-* input, writing output, and inspecting terminal dimensions.
-*
-* @category services
-* @since 4.0.0
-*/
-const Terminal = /*#__PURE__*/ Service("effect/platform/Terminal");
-/**
-* Creates a `Terminal` service implementation.
-*
-* **When to use**
-*
-* Use to construct a custom `Terminal` service implementation from concrete
-* terminal capabilities when writing a platform adapter, test implementation,
-* or custom runtime service.
-*
-* **Details**
-*
-* The implementation object supplies `columns`, `rows`, `readInput`,
-* `readLine`, and `display`; `make` attaches the `Terminal` service marker so
-* the result can be provided through the `Terminal` context service.
-*
-* @category constructors
-* @since 4.0.0
-*/
-const make$2 = (impl) => Terminal.of({
-	...impl,
-	[TypeId$1]: TypeId$1
-});
 /**
 * Provides the default process-backed `Terminal` service, ending key input on
 * Ctrl+C or Ctrl+D.
@@ -1607,7 +1549,7 @@ const make$2 = (impl) => Terminal.of({
 const layer$2 = /*#__PURE__*/ effect(Terminal, /*#__PURE__*/ (/* @__PURE__ */ fnUntraced(function* (shouldQuit = defaultShouldQuit) {
 	const stdin = process.stdin;
 	const stdout = process.stdout;
-	const rlRef = yield* make$10({ acquire: acquireRelease(sync(() => {
+	const rlRef = yield* make$9({ acquire: acquireRelease(sync(() => {
 		const rl = readline.createInterface({
 			input: stdin,
 			escapeCodeTimeout: 50
@@ -1623,7 +1565,7 @@ const layer$2 = /*#__PURE__*/ effect(Terminal, /*#__PURE__*/ (/* @__PURE__ */ fn
 	const rows = sync(() => stdout.rows ?? 0);
 	const readInput = gen(function* () {
 		yield* get(rlRef);
-		const queue = yield* make$11();
+		const queue = yield* make$10();
 		const handleKeypress = (s, k) => {
 			const userInput = {
 				input: fromUndefinedOr(s),
@@ -1654,7 +1596,7 @@ const layer$2 = /*#__PURE__*/ effect(Terminal, /*#__PURE__*/ (/* @__PURE__ */ fn
 			cause: err
 		}))));
 	}));
-	return make$2({
+	return make$11({
 		columns,
 		rows,
 		readInput,
@@ -1866,7 +1808,7 @@ const visualLength = (text) => stripAnsi(text).length;
 * Helper function to pad strings to a specified width.
 * @internal
 */
-const pad = (s, width) => {
+const pad$1 = (s, width) => {
 	const actualLength = visualLength(s);
 	const padding = Math.max(0, width - actualLength);
 	return s + " ".repeat(padding);
@@ -1878,7 +1820,7 @@ const pad = (s, width) => {
 const renderTable = (rows, widthCap) => {
 	const maxColumn = Math.max(...rows.map((r) => visualLength(r.left))) + 4;
 	const col = widthCap === void 0 ? maxColumn : Math.min(maxColumn, widthCap);
-	return rows.map(({ left, right }) => `  ${pad(left, col)}${right}`).join("\n");
+	return rows.map(({ left, right }) => `  ${pad$1(left, col)}${right}`).join("\n");
 };
 const formatSubcommandName = (name, alias) => alias ? `${name}, ${alias}` : name;
 /**
@@ -2639,7 +2581,7 @@ const reconstructTree = (tree, results) => {
 * Internal implementation details for CLI commands.
 * Public API is in ../Command.ts
 */
-const TypeId = "~effect/cli/Command";
+const TypeId$1 = "~effect/cli/Command";
 /**
 * Casts a Command to its internal implementation.
 * For use by internal modules that need access to config, parse, handle, etc.
@@ -2721,7 +2663,7 @@ const makeCommand = (options) => {
 		};
 	};
 	return Object.assign(Object.create(Proto), {
-		[TypeId]: TypeId,
+		[TypeId$1]: TypeId$1,
 		name: options.name,
 		examples: options.examples ?? [],
 		annotations,
@@ -3796,7 +3738,7 @@ const scanCommandLevel = (tokens, context) => {
 * @category guards
 * @since 4.0.0
 */
-const isCommand = (u) => hasProperty(u, TypeId);
+const isCommand = (u) => hasProperty(u, TypeId$1);
 /**
 * Creates a `Command` from a name, an optional configuration, and an optional
 * handler.
@@ -4163,7 +4105,7 @@ const runWith = (command, config) => {
 			commandPath,
 			errors: parsedArgs.errors
 		});
-		const parseResult = yield* result(commandImpl.parse(parsedArgs));
+		const parseResult = yield* result$1(commandImpl.parse(parsedArgs));
 		if (parseResult._tag === "Failure") return yield* new ShowHelp({
 			commandPath,
 			errors: [parseResult.failure]
@@ -4291,78 +4233,6 @@ const statusCommand = make("status", { format: formatFlag }, ({ format }) => gen
 	}));
 })).pipe(withDescription("show auth status"));
 //#endregion
-//#region src/cli/model-format.ts
-function formatModelsHuman(providers) {
-	if (providers.length === 0) return "no models found\n";
-	return providers.map((provider) => {
-		const models = provider.models;
-		const header = `${provider.displayName ?? provider.instanceId} (${provider.instanceId}) - ${provider.status}`;
-		if (models.length === 0) return `${header}\n  no models`;
-		return [header, ...models.map((model) => `  ${model.slug} - ${model.name}`)].join("\n");
-	}).join("\n\n");
-}
-//#endregion
-//#region src/cli/model.ts
-function createModelCommand() {
-	return make("model").pipe(withDescription("model commands"), withSubcommands([listCommand$1]));
-}
-const listCommand$1 = make("list", {
-	all: boolean("all"),
-	provider: string$2("provider").pipe(optional$2),
-	format: formatFlag
-}, ({ all, provider, format }) => gen(function* () {
-	const application = yield* T3Application;
-	const environment = yield* Environment;
-	const output = yield* T3Output;
-	const providerValue = getOrUndefined(provider);
-	const resolvedFormat = resolveOutputFormat(format, environment, "json");
-	const providers = yield* application.listModels({
-		all,
-		...providerValue !== void 0 && providerValue.length > 0 ? { provider: providerValue } : {}
-	});
-	if (resolvedFormat === "json") yield* output.printJson(providers);
-	else yield* output.writeStdout(formatModelsHuman(providers));
-})).pipe(withDescription("list provider models"));
-//#endregion
-//#region src/cli/project-format.ts
-function formatProjectsHuman(projects) {
-	return projects.map((project) => `- ${project.title}\n  id: ${project.id}\n  path: ${project.workspaceRoot}\n`).join("");
-}
-function formatProjectAddedHuman(project) {
-	return `project added: ${project.title}\nid: ${project.id}\npath: ${project.workspaceRoot}`;
-}
-//#endregion
-//#region src/cli/project.ts
-function createProjectCommand() {
-	return make("project").pipe(withDescription("project commands"), withSubcommands([listCommand, addCommand]));
-}
-const listCommand = make("list", { format: formatFlag }, ({ format }) => gen(function* () {
-	const application = yield* T3Application;
-	const environment = yield* Environment;
-	const output = yield* T3Output;
-	const resolvedFormat = resolveOutputFormat(format, environment, "json");
-	const snapshot = yield* application.loadShell();
-	if (resolvedFormat === "json") yield* output.printJson(snapshot.projects);
-	else yield* output.writeStdout(formatProjectsHuman(snapshot.projects));
-})).pipe(withDescription("list projects"));
-const addCommand = make("add", {
-	path: projectPathFlag,
-	title: string$2("title").pipe(optional$2),
-	format: formatFlag
-}, ({ path, title, format }) => gen(function* () {
-	const application = yield* T3Application;
-	const environment = yield* Environment;
-	const output = yield* T3Output;
-	const resolvedFormat = resolveOutputFormat(format, environment, "json");
-	const titleValue = getOrUndefined(title);
-	const result = yield* application.addProject({
-		path,
-		...titleValue !== void 0 && titleValue.length > 0 ? { title: titleValue } : {}
-	});
-	if (resolvedFormat === "json") yield* output.printJson(result);
-	else yield* output.printInfo(formatProjectAddedHuman(result.project));
-})).pipe(withDescription("add project"));
-//#endregion
 //#region src/cli/error.ts
 var MessageInputError = class extends TaggedErrorClass()("MessageInputError", { message: String$1 }) {};
 var InvalidLimitError = class extends TaggedErrorClass()("InvalidLimitError", {
@@ -4370,149 +4240,1262 @@ var InvalidLimitError = class extends TaggedErrorClass()("InvalidLimitError", {
 	value: String$1
 }) {};
 var MissingThreadError = class extends TaggedErrorClass()("MissingThreadError", { message: String$1 }) {};
-var SelfArchiveError = class extends TaggedErrorClass()("SelfArchiveError", {
+var SelfActionError = class extends TaggedErrorClass()("SelfActionError", {
 	message: String$1,
 	threadId: String$1
 }) {};
+var DestructiveConfirmationRequiredError = class extends TaggedErrorClass()("DestructiveConfirmationRequiredError", { message: String$1 }) {};
+var InvalidFlagCombinationError = class extends TaggedErrorClass()("InvalidFlagCombinationError", { message: String$1 }) {};
 var MissingRequestError = class extends TaggedErrorClass()("MissingRequestError", { message: String$1 }) {};
+var MissingUpdateFieldsError = class extends TaggedErrorClass()("MissingUpdateFieldsError", { message: String$1 }) {};
+var ConflictingUpdateFlagsError = class extends TaggedErrorClass()("ConflictingUpdateFlagsError", { message: String$1 }) {};
 //#endregion
-//#region src/cli/threads/approve.ts
-const approvalDecisionFlag = choice("decision", [
-	"accept",
-	"decline",
-	"cancel"
-]).pipe(withDescription$1("Approval decision"));
-const approveThreadCommand = make("approve", {
-	thread: threadFlag,
-	request: string$2("request").pipe(withDescription$1("Pending approval request id"), optional$2),
-	decision: approvalDecisionFlag,
-	format: formatFlag
-}, ({ thread, request, decision, format }) => gen(function* () {
-	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.approveThread({
-		threadId,
-		requestId,
-		decision
-	});
-	if (resolvedFormat === "json") return yield* output.printJson(result);
-	return yield* output.printInfo(`approval submitted: ${result.requestId}\nsequence: ${result.dispatch.sequence}`);
-})).pipe(withDescription("respond to a pending approval request"));
-//#endregion
-//#region src/cli/threads/archive.ts
-const archiveThreadCommand = make("archive", {
-	thread: threadFlag,
-	force: boolean("force").pipe(withAlias("f")),
-	format: formatFlag
-}, ({ thread, force, format }) => gen(function* () {
-	const application = yield* T3Application;
-	const environment = yield* Environment;
-	const output = yield* T3Output;
-	const threadId = resolveThreadId({
-		value: getOrUndefined(thread),
-		env: environment.env
+//#region src/cli/terminal/scope.ts
+function resolveCommandThreadId(input) {
+	return resolveThreadId({
+		value: getOrUndefined(input.thread),
+		env: input.env
 	});
+}
+const requireCommandThreadId = fn("requireCommandThreadId")(function* (input) {
+	const threadId = resolveCommandThreadId(input);
 	if (threadId === void 0) return yield* fail(new MissingThreadError({ message: "thread id is required: pass --thread or set T3CODE_THREAD_ID" }));
-	const envThreadId = environment.env.T3CODE_THREAD_ID;
-	if (envThreadId !== void 0 && envThreadId.length > 0 && threadId === envThreadId && !force) return yield* fail(new SelfArchiveError({
-		threadId,
-		message: `cannot archive thread ${threadId}: matches T3CODE_THREAD_ID (are you trying to archive yourself?). Use --force to override.`
-	}));
-	const resolvedFormat = resolveOutputFormat(format, environment, "json");
-	const dispatch = yield* application.archiveThread(threadId);
-	if (resolvedFormat === "json") return yield* output.printJson(dispatch);
-	return yield* output.printInfo(`thread archived: ${threadId}\nsequence: ${dispatch.sequence}`);
-})).pipe(withDescription("archive thread"));
-//#endregion
-//#region src/cli/threads/callback.ts
-const callbackThreadCommand = make("callback", {
-	from: string$2("from").pipe(withDescription$1("Thread ID to watch for completion")),
-	thread: threadFlag,
-	prompt: string$2("prompt").pipe(withDescription$1("Message to send to target thread")),
-	background: boolean("background").pipe(withDescription$1("Fork and detach as background process"), optional$2)
-}, ({ from, thread, prompt, background }) => gen(function* () {
-	const application = yield* T3Application;
-	const environment = yield* Environment;
-	const output = yield* T3Output;
-	const cliPath = yield* CliPath;
-	const spawner = yield* ChildProcessSpawner;
-	const fromThreadId = from;
-	const targetThreadId = resolveThreadId({
-		value: getOrUndefined(thread),
-		env: environment.env
-	});
-	if (targetThreadId === void 0) return yield* fail(new MissingThreadError({ message: "target thread id is required: pass --thread or set T3CODE_THREAD_ID" }));
-	if (getOrElse(background, () => false)) {
-		const args = [
-			cliPath.path,
-			"thread",
-			"callback",
-			"--from",
-			fromThreadId,
-			"--thread",
-			targetThreadId,
-			"--prompt",
-			prompt
-		];
-		const proc = make$6(process.execPath, args, {
-			detached: true,
-			stdin: "ignore",
-			stdout: "ignore",
-			stderr: "ignore"
-		});
-		const handle = yield* spawner.spawn(proc);
-		yield* handle.unref.pipe(ignore);
-		yield* output.printInfo(`background callback scheduled: ${fromThreadId} -> ${targetThreadId} (pid: ${handle.pid})`);
-		return;
+	return threadId;
+});
+const ValueMatcherProto = {
+	["~effect/match/Match/Matcher"]: {
+		_input: identity,
+		_filters: identity,
+		_result: identity,
+		_return: identity
+	},
+	_tag: "ValueMatcher",
+	add(_case) {
+		if (isSuccess(this.value)) return this;
+		if (_case._tag === "When" && _case.guard(this.provided) === true) return makeValueMatcher(this.provided, succeed$3(_case.evaluate(this.provided)));
+		else if (_case._tag === "Not" && _case.guard(this.provided) === false) return makeValueMatcher(this.provided, succeed$3(_case.evaluate(this.provided)));
+		return this;
+	},
+	pipe() {
+		return pipeArguments(this, arguments);
 	}
-	yield* output.printInfo(`watching thread ${fromThreadId} for completion...`);
-	const result = yield* application.callbackThread({
-		fromThreadId,
-		targetThreadId,
-		prompt
-	});
-	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/require.ts
-const requireCommandProjectRef = fn("requireCommandProjectRef")(function* (input) {
-	const resolved = yield* (yield* T3Config).resolve();
-	const ref = resolveCommandProjectRef({
-		value: getOrUndefined(input.project),
-		env: input.env,
-		cwd: input.cwd,
-		isLocal: resolved.local
-	});
-	if (ref === void 0) return yield* fail(new ProjectLookupError({
-		message: "project is required: pass --project, set T3CODE_PROJECT_ROOT / T3CODE_PROJECT_ID, or use local auth",
-		ref: input.cwd
-	}));
-	return ref;
+};
+function makeValueMatcher(provided, value) {
+	const matcher = Object.create(ValueMatcherProto);
+	matcher.provided = provided;
+	matcher.value = value;
+	return matcher;
+}
+const makeWhen = (guard, evaluate) => ({
+	_tag: "When",
+	guard,
+	evaluate
 });
+const makePredicate = (pattern) => {
+	if (typeof pattern === "function") return pattern;
+	else if (Array.isArray(pattern)) {
+		const predicates = pattern.map(makePredicate);
+		const len = predicates.length;
+		return (u) => {
+			if (!Array.isArray(u)) return false;
+			for (let i = 0; i < len; i++) if (predicates[i](u[i]) === false) return false;
+			return true;
+		};
+	} else if (pattern !== null && typeof pattern === "object") {
+		const keysAndPredicates = Object.entries(pattern).map(([k, p]) => [k, makePredicate(p)]);
+		const len = keysAndPredicates.length;
+		return (u) => {
+			if (typeof u !== "object" || u === null) return false;
+			for (let i = 0; i < len; i++) {
+				const [key, predicate] = keysAndPredicates[i];
+				if (!(key in u) || predicate(u[key]) === false) return false;
+			}
+			return true;
+		};
+	}
+	return (u) => u === pattern;
+};
+/** @internal */
+const value$1 = (i) => makeValueMatcher(i, fail$2(i));
+/** @internal */
+const when$1 = (pattern, f) => (self) => self.add(makeWhen(makePredicate(pattern), f));
+/** @internal */
+const discriminator = (field) => (...pattern) => {
+	const f = pattern[pattern.length - 1];
+	const values = pattern.slice(0, -1);
+	const pred = values.length === 1 ? (_) => _ != null && _[field] === values[0] : (_) => _ != null && values.includes(_[field]);
+	return (self) => self.add(makeWhen(pred, f));
+};
+/** @internal */
+const tag$1 = /*#__PURE__*/ discriminator("_tag");
+/** @internal */
+const orElse$1 = (f) => (self) => {
+	const toResult = result(self);
+	if (isResult(toResult)) return toResult._tag === "Success" ? toResult.success : f(toResult.failure);
+	return (input) => {
+		const a = toResult(input);
+		return isSuccess(a) ? a.success : f(a.failure);
+	};
+};
+/** @internal */
+const result = (self) => {
+	if (self._tag === "ValueMatcher") return self.value;
+	const len = self.cases.length;
+	if (len === 1) {
+		const _case = self.cases[0];
+		return (input) => {
+			if (_case._tag === "When" && _case.guard(input) === true) return succeed$3(_case.evaluate(input));
+			else if (_case._tag === "Not" && _case.guard(input) === false) return succeed$3(_case.evaluate(input));
+			return fail$2(input);
+		};
+	}
+	return (input) => {
+		for (let i = 0; i < len; i++) {
+			const _case = self.cases[i];
+			if (_case._tag === "When" && _case.guard(input) === true) return succeed$3(_case.evaluate(input));
+			else if (_case._tag === "Not" && _case.guard(input) === false) return succeed$3(_case.evaluate(input));
+		}
+		return fail$2(input);
+	};
+};
 //#endregion
-//#region src/cli/thread-format.ts
-function formatThreadShowJson(thread) {
-	return {
-		id: thread.id,
-		projectId: thread.projectId,
-		title: thread.title,
-		status: thread.status,
-		session: thread.session,
-		latestTurn: thread.latestTurn,
-		modelSelection: thread.modelSelection,
-		runtimeMode: thread.runtimeMode,
-		interactionMode: thread.interactionMode,
-		branch: thread.branch,
-		worktreePath: thread.worktreePath,
+//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Match.js
+/**
+* Pattern matching for TypeScript values, predicates, and tagged unions.
+*
+* `Match` turns branching logic into a matcher that is built from ordered
+* cases and finished with an explicit finalizer. Use `Match.type` to define a
+* reusable matcher for a type, or `Match.value` to classify one value
+* immediately. Cases can match literal values, predicates, object patterns,
+* discriminators, tags, or negated patterns.
+*
+* **Mental model**
+*
+* A matcher checks cases in the order they are added and evaluates the handler
+* for the first match. Type matchers produce a function that can be reused with
+* different inputs, while value matchers already contain the input value. As
+* cases are added, the type system tracks which inputs remain unmatched, so
+* `Match.exhaustive` is only available when every remaining case has been
+* handled.
+*
+* **Common tasks**
+*
+* - Use `Match.type<Union>()` when a branch table should be reusable and
+*   exhaustiveness-checked.
+* - Use `Match.value(value)` when a single value should be matched immediately.
+* - Use `Match.tag`, `Match.tags`, or `Match.discriminator` for discriminated
+*   unions and domain objects with tag fields.
+* - Use `Match.orElse`, `Match.option`, or `Match.result` when unmatched input
+*   should be handled explicitly instead of requiring full exhaustiveness.
+*
+* **Example** (Matching a tagged union)
+*
+* ```ts
+* import { Match } from "effect"
+*
+* type Event =
+*   | { readonly _tag: "UserCreated"; readonly id: string }
+*   | { readonly _tag: "UserDeleted"; readonly id: string }
+*
+* const describe = Match.type<Event>().pipe(
+*   Match.tag("UserCreated", (event) => `created ${event.id}`),
+*   Match.tag("UserDeleted", (event) => `deleted ${event.id}`),
+*   Match.exhaustive
+* )
+* ```
+*
+* @since 4.0.0
+*/
+/**
+* Creates a matcher from a specific value.
+*
+* **When to use**
+*
+* Use to match one concrete input immediately.
+*
+* **Details**
+*
+* This function allows you to define a `Matcher` directly from a given value,
+* rather than from a type. This is useful when working with known values,
+* enabling structured pattern matching on objects, primitives, or any data
+* structure.
+*
+* Once the matcher is created, you can use pattern-matching functions like
+* {@link when} to define how different cases should be handled.
+*
+* **Example** (Matching an Object by Property)
+*
+* ```ts
+* import { Match } from "effect"
+*
+* const input = { name: "John", age: 30 }
+*
+* // Create a matcher for the specific object
+* const result = Match.value(input).pipe(
+*   // Match when the 'name' property is "John"
+*   Match.when(
+*     { name: "John" },
+*     (user) => `${user.name} is ${user.age} years old`
+*   ),
+*   // Provide a fallback if no match is found
+*   Match.orElse(() => "Oh, not John")
+* )
+*
+* console.log(result)
+* // Output: "John is 30 years old"
+* ```
+*
+* @see {@link type} for creating a matcher from a specific type.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const value = value$1;
+/**
+* Defines a condition for matching values.
+*
+* **When to use**
+*
+* Use to add one positive pattern case to a `Match.type` or `Match.value`
+* pipeline when a direct value, predicate, or structured object pattern should
+* run a handler for matching input.
+*
+* **Details**
+*
+* Supports both direct value comparisons and predicate functions. If the
+* pattern matches, the associated function is executed and the matched input is
+* removed from the remaining cases tracked by the matcher.
+*
+* **Example** (Matching with Values and Predicates)
+*
+* ```ts
+* import { Match } from "effect"
+*
+* // Create a matcher for objects with an "age" property
+* const match = Match.type<{ age: number }>().pipe(
+*   // Match when age is greater than 18
+*   Match.when(
+*     { age: (age: number) => age > 18 },
+*     (user: { age: number }) => `Age: ${user.age}`
+*   ),
+*   // Match when age is exactly 18
+*   Match.when({ age: 18 }, () => "You can vote"),
+*   // Fallback case for all other ages
+*   Match.orElse((user: { age: number }) => `${user.age} is too young`)
+* )
+*
+* console.log(match({ age: 20 }))
+* // Output: "Age: 20"
+*
+* console.log(match({ age: 18 }))
+* // Output: "You can vote"
+*
+* console.log(match({ age: 4 }))
+* // Output: "4 is too young"
+* ```
+*
+* @see {@link whenOr} for handling any one of several patterns with the same handler
+* @see {@link whenAnd} for requiring all provided patterns to match before running a handler
+* @see {@link not} for handling inputs that do not match a pattern
+* @see {@link orElse} for providing a fallback when no pattern case matches
+*
+* @category Defining patterns
+* @since 4.0.0
+*/
+const when = when$1;
+/**
+* Matches discriminated union members by their `_tag` field.
+*
+* **When to use**
+*
+* Use to handle one or more `_tag` cases with the same matcher branch.
+*
+* **Details**
+*
+* This helper follows the Effect convention that discriminated unions use
+* `"_tag"` as their discriminator field. Use {@link discriminator} for a
+* different discriminator field.
+*
+* **Example** (Matching a Discriminated Union by Tag)
+*
+* ```ts
+* import { Match } from "effect"
+*
+* type Event =
+*   | { readonly _tag: "fetch" }
+*   | { readonly _tag: "success"; readonly data: string }
+*   | { readonly _tag: "error"; readonly error: Error }
+*   | { readonly _tag: "cancel" }
+*
+* const match = Match.type<Event>().pipe(
+*   // Match either "fetch" or "success"
+*   Match.tag("fetch", "success", () => `Ok!`),
+*   // Match "error" and extract the error message
+*   Match.tag("error", (event) => `Error: ${event.error.message}`),
+*   // Match "cancel"
+*   Match.tag("cancel", () => "Cancelled"),
+*   Match.exhaustive
+* )
+*
+* console.log(match({ _tag: "success", data: "Hello" }))
+* // Output: "Ok!"
+*
+* console.log(match({ _tag: "error", error: new Error("Oops!") }))
+* // Output: "Error: Oops!"
+* ```
+*
+* @category Defining patterns
+* @since 4.0.0
+*/
+const tag = tag$1;
+/**
+* Provides a fallback value when no patterns match.
+*
+* **When to use**
+*
+* Use to finalize a matcher with a fallback for unmatched input.
+*
+* **Details**
+*
+* This function ensures that a matcher always returns a valid result, even if
+* no defined patterns match. It acts as a default case, similar to the
+* `default` clause in a `switch` statement or the final `else` in an `if-else`
+* chain.
+*
+* **Example** (Providing a Default Value When No Patterns Match)
+*
+* ```ts
+* import { Match } from "effect"
+*
+* // Create a matcher for string or number values
+* const match = Match.type<string | number>().pipe(
+*   // Match when the value is "a"
+*   Match.when("a", () => "ok"),
+*   // Fallback when no patterns match
+*   Match.orElse(() => "fallback")
+* )
+*
+* console.log(match("a"))
+* // Output: "ok"
+*
+* console.log(match("b"))
+* // Output: "fallback"
+* ```
+*
+* @see {@link option} for finalizing unmatched input as `Option.none`
+* @see {@link result} for returning unmatched input as a `Result` failure
+* @see {@link orElseAbsurd} for finalizing when unmatched input should be impossible
+*
+* @category completion
+* @since 4.0.0
+*/
+const orElse = orElse$1;
+//#endregion
+//#region src/cli/terminal/encoding.ts
+function bytesToLatin1String(bytes) {
+	return Buffer.from(bytes).toString("latin1");
+}
+function decodeHexPayload(value) {
+	const normalized = value.trim();
+	if (normalized.length === 0 || normalized.length % 2 !== 0 || !/^[0-9a-fA-F]+$/.test(normalized)) return;
+	return Buffer.from(normalized, "hex").toString("latin1");
+}
+function decodeBase64Payload(value) {
+	const normalized = value.trim();
+	if (normalized.length === 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(normalized)) return;
+	return Buffer.from(normalized, "base64").toString("latin1");
+}
+//#endregion
+//#region src/cli/terminal/error.ts
+var TerminalCliError = class extends TaggedErrorClass()("TerminalCliError", {
+	message: String$1,
+	threadId: optionalKey(String$1),
+	terminalId: optionalKey(String$1)
+}) {};
+var TerminalIoError = class extends TaggedErrorClass()("TerminalIoError", { message: String$1 }) {};
+//#endregion
+//#region src/cli/terminal/io-service.ts
+var TerminalIo = class extends Service()("t3cli/T3TerminalIo") {};
+//#endregion
+//#region src/cli/terminal/shared.ts
+const DETACH_BYTE = 29;
+const ANSI_CLEAR_SCREEN = "\x1Bc";
+function runAttachedTerminalSession(input) {
+	return scoped(gen(function* () {
+		const application = yield* T3Application;
+		const io = yield* TerminalIo;
+		const { cols, rows } = yield* io.getWindowSize.pipe(mapError((error) => mapTerminalIoError(error, input.terminal)));
+		const session = yield* io.openRawSession.pipe(mapError((error) => mapTerminalIoError(error, input.terminal)));
+		const completion = yield* make$13();
+		yield* runForEach(application.attachTerminal({
+			terminal: input.terminal,
+			cols,
+			rows
+		}), applyAttachEvent).pipe(match$1({
+			onFailure: (error) => completeAttachSession(completion, {
+				_tag: "Failure",
+				error
+			}),
+			onSuccess: () => completeAttachSession(completion, { _tag: "Success" })
+		}), forkScoped);
+		yield* runForEach(session.resize, ({ cols: nextCols, rows: nextRows }) => application.resizeTerminal({
+			terminal: input.terminal,
+			cols: nextCols,
+			rows: nextRows
+		})).pipe(match$1({
+			onFailure: (error) => completeAttachSession(completion, {
+				_tag: "Failure",
+				error
+			}),
+			onSuccess: () => completeAttachSession(completion, { _tag: "Success" })
+		}), forkScoped);
+		yield* runForEach(session.input, (chunk) => handleSessionInput({
+			completion,
+			terminal: input.terminal,
+			chunk
+		})).pipe(match$1({
+			onFailure: (error) => completeAttachSession(completion, {
+				_tag: "Failure",
+				error
+			}),
+			onSuccess: () => completeAttachSession(completion, { _tag: "Success" })
+		}), forkScoped);
+		const result = yield* _await(completion);
+		if (result.message !== void 0) yield* writeSystemMessage(result.message);
+		return yield* value(result).pipe(tag("Failure", ({ error }) => fail(error)), orElse(() => void_));
+	}));
+}
+function completeAttachSession(completion, result) {
+	return succeed$4(completion, result).pipe(ignore);
+}
+function handleSessionInput(input) {
+	const detachOffset = input.chunk.indexOf(DETACH_BYTE);
+	const payload = detachOffset === -1 ? input.chunk : input.chunk.slice(0, detachOffset);
+	if (payload.length === 0 && detachOffset === -1) return void_;
+	return gen(function* () {
+		const application = yield* T3Application;
+		if (payload.length > 0) yield* application.writeTerminal({
+			terminal: input.terminal,
+			data: bytesToLatin1String(payload)
+		});
+		if (detachOffset !== -1) yield* completeAttachSession(input.completion, {
+			_tag: "Success",
+			message: "detached"
+		});
+	});
+}
+function mapTerminalIoError(error, terminal) {
+	return new TerminalCliError({
+		message: error.message,
+		threadId: terminal.threadId,
+		terminalId: terminal.terminalId
+	});
+}
+function applyAttachEvent(event) {
+	return gen(function* () {
+		const io = yield* TerminalIo;
+		yield* value(event).pipe(when({ type: "activity" }, () => void_), when({ type: "snapshot" }, ({ snapshot }) => writeSnapshot(snapshot.history)), when({ type: "restarted" }, ({ snapshot }) => writeSnapshot(snapshot.history)), when({ type: "output" }, ({ data }) => io.writeOutput(data)), when({ type: "cleared" }, () => io.writeOutput(ANSI_CLEAR_SCREEN)), when({ type: "error" }, ({ message }) => writeSystemMessage(message)), when({ type: "closed" }, () => writeSystemMessage("Terminal closed")), orElse((next) => {
+			const details = [typeof next.exitCode === "number" ? `code ${next.exitCode}` : null, typeof next.exitSignal === "number" ? `signal ${next.exitSignal}` : null].filter((value) => value !== null).join(", ");
+			return writeSystemMessage(details.length > 0 ? `Process exited (${details})` : "Process exited");
+		}));
+	});
+}
+function writeSnapshot(history) {
+	return gen(function* () {
+		const io = yield* TerminalIo;
+		yield* io.writeOutput(ANSI_CLEAR_SCREEN);
+		if (history.length > 0) yield* io.writeOutput(history);
+	});
+}
+function writeSystemMessage(message) {
+	return gen(function* () {
+		yield* (yield* TerminalIo).writeOutput(`\r\n[terminal] ${message}\r\n`);
+	});
+}
+function toTerminalAttachTarget(terminal) {
+	return {
+		threadId: terminal.threadId,
+		terminalId: terminal.terminalId,
+		cwd: terminal.cwd,
+		worktreePath: terminal.worktreePath
+	};
+}
+function snapshotToTerminalAttachTarget(snapshot) {
+	return {
+		threadId: snapshot.threadId,
+		terminalId: snapshot.terminalId,
+		cwd: snapshot.cwd,
+		worktreePath: snapshot.worktreePath
+	};
+}
+function filterAttachStreamEvent(event, options) {
+	if (event.type === "snapshot" || event.type === "restarted") {
+		if (options.fromSequence !== void 0 && event.type === "restarted" && typeof event.snapshot.sequence === "number" && event.snapshot.sequence < options.fromSequence) return null;
+		return {
+			...event,
+			snapshot: {
+				...event.snapshot,
+				history: options.includeHistory ? event.snapshot.history : ""
+			}
+		};
+	}
+	if (options.fromSequence !== void 0 && typeof event.sequence === "number" && event.sequence < options.fromSequence) return null;
+	return event;
+}
+//#endregion
+//#region src/cli/terminal/attach.ts
+const attachTerminalCommand = make("attach", {
+	thread: threadFlag,
+	terminalId: string("terminal-id")
+}, ({ thread, terminalId }) => gen(function* () {
+	const application = yield* T3Application;
+	const threadId = yield* requireCommandThreadId({
+		thread,
+		env: (yield* Environment).env
+	});
+	yield* runAttachedTerminalSession({ terminal: toTerminalAttachTarget(yield* application.getTerminal({
+		threadId,
+		terminalId
+	})) });
+})).pipe(withDescription("attach to a terminal"));
+//#endregion
+//#region src/cli/terminal-format.ts
+function formatTerminalListHuman(terminals) {
+	if (terminals.length === 0) return "no terminals\n";
+	return `${formatTerminalTable(terminals.map(toSummaryRow))}\n`;
+}
+function formatTerminalCreatedHuman(snapshot) {
+	return `terminal created\n${formatTerminalTable([toSnapshotRow(snapshot)])}`;
+}
+function formatTerminalWrittenHuman(input) {
+	return `wrote ${input.bytes} bytes to ${input.terminalId} (${input.threadId})`;
+}
+function formatTerminalDestroyedHuman(input) {
+	return `destroyed ${input.terminalId} (${input.threadId})`;
+}
+function formatTerminalTable(rows) {
+	const headers = {
+		id: "id",
+		status: "status",
+		label: "label",
+		cwd: "cwd",
+		updated: "updated",
+		process: "process"
+	};
+	const widths = {
+		id: columnWidth(headers.id, rows.map((row) => row.id), 44),
+		status: columnWidth(headers.status, rows.map((row) => row.status), 8),
+		label: columnWidth(headers.label, rows.map((row) => row.label), 24),
+		cwd: columnWidth(headers.cwd, rows.map((row) => row.cwd), 40),
+		updated: columnWidth(headers.updated, rows.map((row) => row.updated), 24),
+		process: columnWidth(headers.process, rows.map((row) => row.process), 20)
+	};
+	return `${[
+		pad(headers.id, widths.id),
+		pad(headers.status, widths.status),
+		pad(headers.label, widths.label),
+		pad(headers.cwd, widths.cwd),
+		pad(headers.updated, widths.updated),
+		pad(headers.process, widths.process)
+	].join("  ")}\n${[
+		"-".repeat(widths.id),
+		"-".repeat(widths.status),
+		"-".repeat(widths.label),
+		"-".repeat(widths.cwd),
+		"-".repeat(widths.updated),
+		"-".repeat(widths.process)
+	].join("  ")}\n${rows.map((row) => [
+		pad(row.id, widths.id),
+		pad(row.status, widths.status),
+		pad(row.label, widths.label),
+		pad(row.cwd, widths.cwd),
+		pad(row.updated, widths.updated),
+		pad(row.process, widths.process)
+	].join("  ")).join("\n")}`;
+}
+function toSummaryRow(terminal) {
+	return {
+		id: terminal.terminalId,
+		status: terminal.status,
+		label: terminal.label,
+		cwd: terminal.cwd,
+		updated: terminal.updatedAt,
+		process: formatProcessInfo(terminal)
+	};
+}
+function toSnapshotRow(snapshot) {
+	return {
+		id: snapshot.terminalId,
+		status: snapshot.status,
+		label: snapshot.label,
+		cwd: snapshot.cwd,
+		updated: snapshot.updatedAt,
+		process: formatProcessInfo(snapshot)
+	};
+}
+function formatProcessInfo(input) {
+	const parts = [
+		typeof input.pid === "number" ? `pid ${input.pid}` : null,
+		typeof input.exitCode === "number" ? `exit ${input.exitCode}` : null,
+		typeof input.exitSignal === "number" ? `sig ${input.exitSignal}` : null
+	].filter((part) => part !== null);
+	return parts.length > 0 ? parts.join(", ") : "-";
+}
+function columnWidth(header, values, maxWidth) {
+	const widest = values.reduce((width, value) => Math.max(width, value.length), header.length);
+	return Math.min(widest, maxWidth);
+}
+function pad(value, width) {
+	return truncate(value, width).padEnd(width, " ");
+}
+function truncate(value, width) {
+	if (value.length <= width) return value;
+	if (width <= 3) return value.slice(0, width);
+	return `${value.slice(0, width - 3)}...`;
+}
+//#endregion
+//#region src/cli/terminal/create.ts
+const createTerminalCommand = make("create", {
+	thread: threadFlag,
+	command: string("command").pipe(optional),
+	id: string$2("id").pipe(optional$2),
+	attach: boolean("attach"),
+	format: formatFlag
+}, ({ thread, command, id, attach, format }) => gen(function* () {
+	const application = yield* T3Application;
+	const environment = yield* Environment;
+	const output = yield* T3Output;
+	const threadId = yield* requireCommandThreadId({
+		thread,
+		env: environment.env
+	});
+	const terminalId = getOrUndefined(id);
+	const commandValue = getOrUndefined(command);
+	const snapshot = yield* application.createTerminal({
+		threadId,
+		...terminalId !== void 0 ? { terminalId } : {},
+		...commandValue !== void 0 ? { command: commandValue } : {}
+	});
+	if (attach) {
+		yield* runAttachedTerminalSession({ terminal: snapshotToTerminalAttachTarget(snapshot) });
+		return;
+	}
+	if (resolveOutputFormat(format, environment, "json") === "json") yield* output.printJson(snapshot);
+	else yield* output.printInfo(formatTerminalCreatedHuman(snapshot));
+})).pipe(withDescription("create a terminal for a thread"));
+//#endregion
+//#region src/cli/confirm.ts
+const requireDestructiveConfirmation = fn("requireDestructiveConfirmation")(function* (input) {
+	if (input.yes) return;
+	if (!isInteractiveHumanTerminal(input.environment)) {
+		yield* fail(new DestructiveConfirmationRequiredError({ message: "destructive action requires --yes in non-interactive mode" }));
+		return;
+	}
+	if (yield* run$2(confirm({
+		message: input.message,
+		initial: false
+	}))) return;
+	yield* fail(new DestructiveConfirmationRequiredError({ message: "aborted" }));
+});
+//#endregion
+//#region src/cli/terminal/destroy.ts
+const destroyTerminalCommand = make("destroy", {
+	thread: threadFlag,
+	terminalId: string("terminal-id"),
+	quiet: boolean("quiet"),
+	yes: yesFlag,
+	format: formatFlag
+}, ({ thread, terminalId, quiet, yes, format }) => gen(function* () {
+	const application = yield* T3Application;
+	const environment = yield* Environment;
+	const output = yield* T3Output;
+	const threadId = yield* requireCommandThreadId({
+		thread,
+		env: environment.env
+	});
+	yield* requireDestructiveConfirmation({
+		message: `Destroy terminal ${terminalId} in thread ${threadId} and delete its history?`,
+		yes,
+		environment
+	});
+	const terminal = {
+		threadId,
+		terminalId
+	};
+	yield* application.destroyTerminal(terminal);
+	if (quiet) return;
+	if (resolveOutputFormat(format, environment, "json") === "json") {
+		yield* output.printJson({
+			threadId: terminal.threadId,
+			terminalId: terminal.terminalId,
+			destroyed: true
+		});
+		return;
+	}
+	yield* output.printInfo(formatTerminalDestroyedHuman({
+		terminalId,
+		threadId
+	}));
+})).pipe(withDescription("destroy a terminal and its history"));
+//#endregion
+//#region src/cli/terminal/list.ts
+const listTerminalCommand = make("list", {
+	thread: threadFlag,
+	format: formatFlag
+}, ({ thread, format }) => gen(function* () {
+	const application = yield* T3Application;
+	const environment = yield* Environment;
+	const output = yield* T3Output;
+	const threadId = yield* requireCommandThreadId({
+		thread,
+		env: environment.env
+	});
+	const resolvedFormat = resolveOutputFormat(format, environment, "json");
+	const terminals = yield* application.listTerminals(threadId);
+	if (resolvedFormat === "json") yield* output.printJson(terminals);
+	else yield* output.writeStdout(formatTerminalListHuman(terminals));
+})).pipe(withDescription("list terminals for a thread"));
+const readTerminalCommand = make("read", {
+	thread: threadFlag,
+	terminalId: string("terminal-id"),
+	history: boolean("history"),
+	follow: boolean("follow"),
+	fromSequence: integer("from-sequence").pipe(optional$2),
+	format: choice("format", ["json", "ndjson"]).pipe(withDefault("json"))
+}, ({ thread, terminalId, history, follow, fromSequence, format }) => gen(function* () {
+	const output = yield* T3Output;
+	const application = yield* T3Application;
+	const threadId = yield* requireCommandThreadId({
+		thread,
+		env: (yield* Environment).env
+	});
+	const fromSequenceValue = getOrUndefined(fromSequence);
+	if (fromSequenceValue !== void 0 && fromSequenceValue < 0) yield* fail(new InvalidLimitError({
+		message: "from-sequence must be a non-negative integer",
+		value: String(fromSequenceValue)
+	}));
+	if (fromSequenceValue !== void 0 && !follow) yield* fail(new InvalidFlagCombinationError({ message: "--from-sequence requires --follow" }));
+	if (follow && format !== "ndjson") yield* fail(new InvalidFlagCombinationError({ message: "--follow requires --format ndjson" }));
+	const terminal = yield* application.getTerminal({
+		threadId,
+		terminalId
+	});
+	const stream = application.attachTerminal({ terminal: toTerminalAttachTarget(terminal) }).pipe(map$4((event) => filterAttachStreamEvent(event, {
+		includeHistory: history,
+		...fromSequenceValue !== void 0 ? { fromSequence: fromSequenceValue } : {}
+	})), filter((event) => event !== null));
+	if (follow) {
+		yield* runForEach(stream, (event) => output.printNdjson(event));
+		return;
+	}
+	const event = getOrUndefined(yield* runHead(stream));
+	if (event === void 0 || event.type !== "snapshot") yield* fail(new TerminalCliError({
+		message: "server did not return terminal snapshot",
+		threadId,
+		terminalId
+	}));
+	else if (format === "ndjson") yield* output.printNdjson(event);
+	else yield* output.printJson(event.snapshot);
+})).pipe(withDescription("read terminal state and optional history"));
+const streamTerminalCommand = make("stream", {
+	thread: threadFlag,
+	terminalId: string("terminal-id"),
+	fromSequence: integer("from-sequence").pipe(optional$2),
+	format: choice("format", ["ndjson"]).pipe(withDefault("ndjson"))
+}, ({ thread, terminalId, fromSequence }) => gen(function* () {
+	const output = yield* T3Output;
+	const application = yield* T3Application;
+	const threadId = yield* requireCommandThreadId({
+		thread,
+		env: (yield* Environment).env
+	});
+	const fromSequenceValue = getOrUndefined(fromSequence);
+	if (fromSequenceValue !== void 0 && fromSequenceValue < 0) yield* fail(new InvalidLimitError({
+		message: "from-sequence must be a non-negative integer",
+		value: String(fromSequenceValue)
+	}));
+	const terminal = yield* application.getTerminal({
+		threadId,
+		terminalId
+	});
+	yield* runForEach(application.attachTerminal({ terminal: toTerminalAttachTarget(terminal) }).pipe(map$4((event) => filterAttachStreamEvent(event, {
+		includeHistory: true,
+		...fromSequenceValue !== void 0 ? { fromSequence: fromSequenceValue } : {}
+	})), filter((event) => event !== null)), (event) => output.printNdjson(event));
+})).pipe(withDescription("stream terminal attach events as ndjson"));
+const waitTerminalCommand = make("wait", {
+	thread: threadFlag,
+	terminalId: string("terminal-id"),
+	target: choice("for", [
+		"exited",
+		"closed",
+		"ended"
+	]).pipe(withDefault("exited")),
+	format: formatFlag
+}, ({ thread, terminalId, target, format }) => gen(function* () {
+	const application = yield* T3Application;
+	const environment = yield* Environment;
+	const output = yield* T3Output;
+	const threadId = yield* requireCommandThreadId({
+		thread,
+		env: environment.env
+	});
+	const resolvedFormat = resolveOutputFormat(format, environment, "json");
+	const resolution = yield* application.watchTerminalMetadata().pipe(map$4((event) => resolveMetadataWait(event, target, threadId, terminalId)), filter((value) => value !== null), runHead);
+	if (isNone(resolution)) yield* fail(new TerminalCliError({
+		message: "terminal wait stream ended unexpectedly",
+		threadId,
+		terminalId
+	}));
+	else if (resolution.value.kind === "fail") yield* fail(resolution.value.error);
+	else {
+		const result = resolution.value.value;
+		if (resolvedFormat === "json") yield* output.printJson(result);
+		else yield* output.printInfo(formatWaitHuman(result));
+	}
+})).pipe(withDescription("wait for terminal lifecycle events"));
+function terminalClosedBeforeExitError(threadId, terminalId) {
+	return new TerminalCliError({
+		message: `terminal closed before an exited event was observed: ${terminalId}`,
+		threadId,
+		terminalId
+	});
+}
+function resolveMetadataWait(event, target, threadId, terminalId) {
+	if (event.type === "snapshot") {
+		const terminal = event.terminals.find((candidate) => candidate.threadId === threadId && candidate.terminalId === terminalId);
+		if (terminal !== void 0) {
+			if (targetSatisfiedBySummary(target, terminal)) return {
+				kind: "result",
+				value: {
+					threadId: terminal.threadId,
+					terminalId: terminal.terminalId,
+					target,
+					status: terminal.status,
+					exitCode: terminal.exitCode,
+					exitSignal: terminal.exitSignal,
+					updatedAt: terminal.updatedAt,
+					alreadySatisfied: true
+				}
+			};
+			return null;
+		}
+		if (target === "closed" || target === "ended") return {
+			kind: "result",
+			value: {
+				threadId,
+				terminalId,
+				target,
+				status: "closed",
+				alreadySatisfied: true,
+				missingTreatedAsClosed: true
+			}
+		};
+		return {
+			kind: "fail",
+			error: terminalClosedBeforeExitError(threadId, terminalId)
+		};
+	}
+	if (event.type === "upsert") {
+		if (event.terminal.threadId !== threadId || event.terminal.terminalId !== terminalId) return null;
+		if ((target === "exited" || target === "ended") && event.terminal.status === "exited") return {
+			kind: "result",
+			value: {
+				threadId,
+				terminalId,
+				target,
+				status: "exited",
+				exitCode: event.terminal.exitCode,
+				exitSignal: event.terminal.exitSignal,
+				alreadySatisfied: false
+			}
+		};
+		return null;
+	}
+	if (event.threadId !== threadId || event.terminalId !== terminalId) return null;
+	if (target === "exited") return {
+		kind: "fail",
+		error: terminalClosedBeforeExitError(threadId, terminalId)
+	};
+	if (target === "closed" || target === "ended") return {
+		kind: "result",
+		value: {
+			threadId,
+			terminalId,
+			target,
+			status: "closed",
+			alreadySatisfied: false
+		}
+	};
+	return null;
+}
+function targetSatisfiedBySummary(target, terminal) {
+	if (target === "exited") return terminal.status === "exited";
+	if (target === "closed") return false;
+	return terminal.status === "exited";
+}
+function formatWaitHuman(input) {
+	const details = [typeof input.exitCode === "number" ? `code ${input.exitCode}` : null, typeof input.exitSignal === "number" ? `signal ${input.exitSignal}` : null].filter((value) => value !== null).join(", ");
+	return details.length > 0 ? `terminal ${input.status}: ${input.terminalId} (${input.threadId}) ${details}` : `terminal ${input.status}: ${input.terminalId} (${input.threadId})`;
+}
+//#endregion
+//#region src/cli/input/service.ts
+var T3Input = class extends Service()("t3cli/T3Input") {};
+//#endregion
+//#region src/cli/terminal/write.ts
+const writeTerminalCommand = make("write", {
+	thread: threadFlag,
+	terminalId: string("terminal-id"),
+	data: string("data").pipe(optional),
+	stdin: boolean("stdin"),
+	hex: string$2("hex").pipe(optional$2),
+	base64: string$2("base64").pipe(optional$2),
+	quiet: boolean("quiet"),
+	format: formatFlag
+}, ({ thread, terminalId, data, stdin, hex, base64, quiet, format }) => gen(function* () {
+	const output = yield* T3Output;
+	const inputService = yield* T3Input;
+	const application = yield* T3Application;
+	const environment = yield* Environment;
+	const threadId = yield* requireCommandThreadId({
+		thread,
+		env: environment.env
+	});
+	const argumentData = getOrUndefined(data);
+	const hexData = getOrUndefined(hex);
+	const base64Data = getOrUndefined(base64);
+	if ([
+		stdin,
+		argumentData !== void 0,
+		hexData !== void 0,
+		base64Data !== void 0
+	].filter(Boolean).length !== 1) yield* fail(new InvalidFlagCombinationError({ message: "provide exactly one of <data>, --stdin, --hex <data>, or --base64 <data>" }));
+	const payload = hexData !== void 0 ? yield* decodeHexPayloadOrFail(hexData, threadId, terminalId) : base64Data !== void 0 ? yield* decodeBase64PayloadOrFail(base64Data, threadId, terminalId) : stdin ? yield* inputService.readStdinBinary() : argumentData;
+	if (payload.length === 0) yield* fail(new TerminalCliError({
+		message: "terminal write payload is empty",
+		threadId,
+		terminalId
+	}));
+	yield* application.writeTerminal({
+		terminal: {
+			threadId,
+			terminalId
+		},
+		data: payload
+	});
+	if (quiet) return;
+	const bytes = Buffer.byteLength(payload, "latin1");
+	if (resolveOutputFormat(format, environment, "json") === "json") {
+		yield* output.printJson({
+			threadId,
+			terminalId,
+			bytes,
+			encoding: hexData !== void 0 ? "hex" : base64Data !== void 0 ? "base64" : "latin1"
+		});
+		return;
+	}
+	yield* output.printInfo(formatTerminalWrittenHuman({
+		terminalId,
+		threadId,
+		bytes
+	}));
+})).pipe(withDescription("write raw data to a terminal"));
+function decodeHexPayloadOrFail(value, threadId, terminalId) {
+	const decoded = decodeHexPayload(value);
+	if (decoded === void 0) return fail(new TerminalCliError({
+		message: "invalid hex payload",
+		threadId,
+		terminalId
+	}));
+	return succeed(decoded);
+}
+function decodeBase64PayloadOrFail(value, threadId, terminalId) {
+	const decoded = decodeBase64Payload(value);
+	if (decoded === void 0) return fail(new TerminalCliError({
+		message: "invalid base64 payload",
+		threadId,
+		terminalId
+	}));
+	return succeed(decoded);
+}
+//#endregion
+//#region src/cli/terminal.ts
+function createTerminalCommandGroup() {
+	return make("terminal").pipe(withDescription("terminal commands"), withSubcommands([
+		listTerminalCommand,
+		createTerminalCommand,
+		attachTerminalCommand,
+		readTerminalCommand,
+		streamTerminalCommand,
+		waitTerminalCommand,
+		writeTerminalCommand,
+		destroyTerminalCommand
+	]));
+}
+//#endregion
+//#region src/cli/model-format.ts
+function formatModelsHuman(providers) {
+	if (providers.length === 0) return "no models found\n";
+	return providers.map((provider) => {
+		const models = provider.models;
+		const header = `${provider.displayName ?? provider.instanceId} (${provider.instanceId}) - ${provider.status}`;
+		if (models.length === 0) return `${header}\n  no models`;
+		return [header, ...models.map((model) => `  ${model.slug} - ${model.name}`)].join("\n");
+	}).join("\n\n");
+}
+//#endregion
+//#region src/cli/model.ts
+function createModelCommand() {
+	return make("model").pipe(withDescription("model commands"), withSubcommands([listCommand$1]));
+}
+const listCommand$1 = make("list", {
+	all: boolean("all"),
+	provider: string$2("provider").pipe(optional$2),
+	format: formatFlag
+}, ({ all, provider, format }) => gen(function* () {
+	const application = yield* T3Application;
+	const environment = yield* Environment;
+	const output = yield* T3Output;
+	const providerValue = getOrUndefined(provider);
+	const resolvedFormat = resolveOutputFormat(format, environment, "json");
+	const providers = yield* application.listModels({
+		all,
+		...providerValue !== void 0 && providerValue.length > 0 ? { provider: providerValue } : {}
+	});
+	if (resolvedFormat === "json") yield* output.printJson(providers);
+	else yield* output.writeStdout(formatModelsHuman(providers));
+})).pipe(withDescription("list provider models"));
+//#endregion
+//#region src/cli/project-format.ts
+function formatProjectsHuman(projects) {
+	return projects.map((project) => `- ${project.title}\n  id: ${project.id}\n  path: ${project.workspaceRoot}\n`).join("");
+}
+function formatProjectAddedHuman(project) {
+	return `project added: ${project.title}\nid: ${project.id}\npath: ${project.workspaceRoot}`;
+}
+function formatProjectDeletedHuman(input) {
+	return `project deleted: ${input.projectId}\nsequence: ${input.dispatch.sequence}`;
+}
+//#endregion
+//#region src/cli/require.ts
+const requireCommandProjectRef = fn("requireCommandProjectRef")(function* (input) {
+	const resolved = yield* (yield* T3Config).resolve();
+	const ref = resolveCommandProjectRef({
+		value: getOrUndefined(input.project),
+		env: input.env,
+		cwd: input.cwd,
+		isLocal: resolved.local
+	});
+	if (ref === void 0) return yield* fail(new ProjectLookupError({
+		message: "project is required: pass --project, set T3CODE_PROJECT_ROOT / T3CODE_PROJECT_ID, or use local auth",
+		ref: input.cwd
+	}));
+	return ref;
+});
+//#endregion
+//#region src/cli/projects/delete.ts
+const deleteProjectCommand = make("delete", {
+	project: projectFlag,
+	force: forceFlag,
+	yes: yesFlag,
+	format: formatFlag
+}, ({ project, force, yes, format }) => gen(function* () {
+	const application = yield* T3Application;
+	const environment = yield* Environment;
+	const output = yield* T3Output;
+	const projectRef = yield* requireCommandProjectRef({
+		project,
+		env: environment.env,
+		cwd: environment.cwd
+	});
+	const resolvedProject = yield* application.resolveProject(projectRef);
+	yield* requireDestructiveConfirmation({
+		message: `Delete project ${resolvedProject.title} (${resolvedProject.id})?`,
+		yes,
+		environment
+	});
+	const resolvedFormat = resolveOutputFormat(format, environment, "json");
+	const result = yield* application.deleteProject({
+		projectId: resolvedProject.id,
+		...force ? { force: true } : {}
+	});
+	if (resolvedFormat === "json") return yield* output.printJson({
+		projectId: result.projectId,
+		dispatch: result.dispatch
+	});
+	return yield* output.printInfo(formatProjectDeletedHuman(result));
+})).pipe(withDescription("delete project"));
+//#endregion
+//#region src/cli/project.ts
+function createProjectCommand() {
+	return make("project").pipe(withDescription("project commands"), withSubcommands([
+		listCommand,
+		addCommand,
+		deleteProjectCommand
+	]));
+}
+const listCommand = make("list", { format: formatFlag }, ({ format }) => gen(function* () {
+	const application = yield* T3Application;
+	const environment = yield* Environment;
+	const output = yield* T3Output;
+	const resolvedFormat = resolveOutputFormat(format, environment, "json");
+	const snapshot = yield* application.loadShell();
+	if (resolvedFormat === "json") yield* output.printJson(snapshot.projects);
+	else yield* output.writeStdout(formatProjectsHuman(snapshot.projects));
+})).pipe(withDescription("list projects"));
+const addCommand = make("add", {
+	path: projectPathFlag,
+	title: string$2("title").pipe(optional$2),
+	format: formatFlag
+}, ({ path, title, format }) => gen(function* () {
+	const application = yield* T3Application;
+	const environment = yield* Environment;
+	const output = yield* T3Output;
+	const resolvedFormat = resolveOutputFormat(format, environment, "json");
+	const titleValue = getOrUndefined(title);
+	const result = yield* application.addProject({
+		path,
+		...titleValue !== void 0 && titleValue.length > 0 ? { title: titleValue } : {}
+	});
+	if (resolvedFormat === "json") yield* output.printJson(result);
+	else yield* output.printInfo(formatProjectAddedHuman(result.project));
+})).pipe(withDescription("add project"));
+//#endregion
+//#region src/cli/threads/approve.ts
+const approvalDecisionFlag = choice("decision", [
+	"accept",
+	"decline",
+	"cancel"
+]).pipe(withDescription$1("Approval decision"));
+const approveThreadCommand = make("approve", {
+	thread: threadFlag,
+	request: string$2("request").pipe(withDescription$1("Pending approval request id"), optional$2),
+	decision: approvalDecisionFlag,
+	format: formatFlag
+}, ({ thread, request, decision, format }) => gen(function* () {
+	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.approveThread({
+		threadId,
+		requestId,
+		decision
+	});
+	if (resolvedFormat === "json") return yield* output.printJson(result);
+	return yield* output.printInfo(`approval submitted: ${result.requestId}\nsequence: ${result.dispatch.sequence}`);
+})).pipe(withDescription("respond to a pending approval request"));
+//#endregion
+//#region src/cli/self-action.ts
+const requireSelfActionConfirmation = fn("requireSelfActionConfirmation")(function* (input) {
+	if (input.force) return;
+	if (!isAgentEnvironment(input.environment)) return;
+	const callerThreadId = input.environment.env.T3CODE_THREAD_ID;
+	if (callerThreadId === void 0 || callerThreadId.length === 0) return;
+	if (input.threadId !== callerThreadId) return;
+	yield* fail(new SelfActionError({
+		threadId: input.threadId,
+		message: `cannot ${input.action} thread ${input.threadId}: command targets the calling thread. Pass --force to confirm.`
+	}));
+});
+//#endregion
+//#region src/cli/threads/archive.ts
+const archiveThreadCommand = make("archive", {
+	thread: threadFlag,
+	force: selfActionForceFlag,
+	format: formatFlag
+}, ({ thread, force, format }) => gen(function* () {
+	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" }));
+	yield* requireSelfActionConfirmation({
+		threadId,
+		force,
+		environment,
+		action: "archive"
+	});
+	const resolvedFormat = resolveOutputFormat(format, environment, "json");
+	const dispatch = yield* application.archiveThread(threadId);
+	if (resolvedFormat === "json") return yield* output.printJson(dispatch);
+	return yield* output.printInfo(`thread archived: ${threadId}\nsequence: ${dispatch.sequence}`);
+})).pipe(withDescription("archive thread"));
+//#endregion
+//#region src/cli/threads/callback.ts
+const callbackThreadCommand = make("callback", {
+	from: string$2("from").pipe(withDescription$1("Thread ID to watch for completion")),
+	thread: threadFlag,
+	prompt: string$2("prompt").pipe(withDescription$1("Message to send to target thread")),
+	background: boolean("background").pipe(withDescription$1("Fork and detach as background process"), optional$2)
+}, ({ from, thread, prompt, background }) => gen(function* () {
+	const application = yield* T3Application;
+	const environment = yield* Environment;
+	const output = yield* T3Output;
+	const cliPath = yield* CliPath;
+	const spawner = yield* ChildProcessSpawner;
+	const fromThreadId = from;
+	const targetThreadId = resolveThreadId({
+		value: getOrUndefined(thread),
+		env: environment.env
+	});
+	if (targetThreadId === void 0) return yield* fail(new MissingThreadError({ message: "target thread id is required: pass --thread or set T3CODE_THREAD_ID" }));
+	if (getOrElse(background, () => false)) {
+		const args = [
+			cliPath.path,
+			"thread",
+			"callback",
+			"--from",
+			fromThreadId,
+			"--thread",
+			targetThreadId,
+			"--prompt",
+			prompt
+		];
+		const proc = make$5(process.execPath, args, {
+			detached: true,
+			stdin: "ignore",
+			stdout: "ignore",
+			stderr: "ignore"
+		});
+		const handle = yield* spawner.spawn(proc);
+		yield* handle.unref.pipe(ignore);
+		yield* output.printInfo(`background callback scheduled: ${fromThreadId} -> ${targetThreadId} (pid: ${handle.pid})`);
+		return;
+	}
+	yield* output.printInfo(`watching thread ${fromThreadId} for completion...`);
+	const result = yield* application.callbackThread({
+		fromThreadId,
+		targetThreadId,
+		prompt
+	});
+	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/thread-format.ts
+function formatThreadShowJson(thread) {
+	return {
+		id: thread.id,
+		projectId: thread.projectId,
+		title: thread.title,
+		status: thread.status,
+		session: thread.session,
+		latestTurn: thread.latestTurn,
+		modelSelection: thread.modelSelection,
+		runtimeMode: thread.runtimeMode,
+		interactionMode: thread.interactionMode,
+		branch: thread.branch,
+		worktreePath: thread.worktreePath,
 		archivedAt: thread.archivedAt,
 		createdAt: thread.createdAt,
 		updatedAt: thread.updatedAt,
@@ -4545,7 +5528,10 @@ function formatThreadShowHuman(thread) {
 	return `${lines.join("\n")}\n`;
 }
 function formatThreadsHuman(threads) {
-	return threads.map((thread) => `- ${thread.title}\n  id: ${thread.id}\n  status: ${threadStatus(thread)}\n  updated: ${thread.updatedAt}\n`).join("");
+	return threads.map((thread) => `- ${thread.title}${thread.archivedAt !== null ? " (archived)" : ""}\n  id: ${thread.id}\n  status: ${threadStatus(thread)}\n  updated: ${thread.updatedAt}\n`).join("");
+}
+function formatThreadDeletedHuman(input) {
+	return `thread deleted: ${input.threadId}\nsequence: ${input.dispatch.sequence}`;
 }
 function formatThreadStartedHuman(input) {
 	return `thread started: ${input.thread.title}\nid: ${input.thread.id}\nstatus: ${threadStatus(input.thread)}\nsequence: ${input.sequence}`;
@@ -4585,36 +5571,47 @@ function stripThreadHeavy(thread) {
 	return rest;
 }
 //#endregion
-//#region src/cli/threads/list.ts
-const listThreadsCommand = make("list", {
-	project: projectFlag,
+//#region src/cli/threads/delete.ts
+const deleteThreadCommand = make("delete", {
+	thread: threadFlag,
+	force: selfActionForceFlag,
+	yes: yesFlag,
 	format: formatFlag
-}, ({ project, format }) => gen(function* () {
+}, ({ thread, force, yes, format }) => gen(function* () {
 	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" }));
+	yield* requireSelfActionConfirmation({
+		threadId,
+		force,
+		environment,
+		action: "delete"
+	});
+	yield* requireDestructiveConfirmation({
+		message: `Delete thread ${threadId}?`,
+		yes,
+		environment
+	});
 	const resolvedFormat = resolveOutputFormat(format, environment, "json");
-	const projectRef = yield* requireCommandProjectRef({
-		project,
-		env: environment.env,
-		cwd: environment.cwd
+	const result = yield* application.deleteThread(threadId);
+	if (resolvedFormat === "json") return yield* output.printJson({
+		threadId: result.threadId,
+		dispatch: result.dispatch
 	});
-	const result = yield* application.listThreads(projectRef);
-	if (resolvedFormat === "json") yield* output.printJson(result.threads);
-	else yield* output.writeStdout(formatThreadsHuman(result.threads));
-})).pipe(withDescription("list project threads"));
+	return yield* output.printInfo(formatThreadDeletedHuman(result));
+})).pipe(withDescription("delete thread"));
 //#endregion
-//#region src/cli/threads/messages.ts
-const getThreadMessagesCommand = make("messages", {
+//#region src/cli/threads/interrupt.ts
+const interruptThreadCommand = make("interrupt", {
 	thread: threadFlag,
-	limit: integer("limit").pipe(withDefault(20)),
-	full: boolean("full"),
+	force: selfActionForceFlag,
 	format: formatFlag
-}, ({ thread, limit, full, format }) => gen(function* () {
-	if (limit < 0) return yield* fail(new InvalidLimitError({
-		message: `invalid limit: ${limit}`,
-		value: String(limit)
-	}));
+}, ({ thread, force, format }) => gen(function* () {
 	const application = yield* T3Application;
 	const environment = yield* Environment;
 	const output = yield* T3Output;
@@ -4623,11 +5620,20 @@ const getThreadMessagesCommand = make("messages", {
 		env: environment.env
 	});
 	if (threadId === void 0) return yield* fail(new MissingThreadError({ message: "thread id is required: pass --thread or set T3CODE_THREAD_ID" }));
+	yield* requireSelfActionConfirmation({
+		threadId,
+		force,
+		environment,
+		action: "interrupt"
+	});
 	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"));
+	const dispatch = yield* application.interruptThread(threadId);
+	if (resolvedFormat === "json") return yield* output.printJson({
+		threadId,
+		dispatch
+	});
+	return yield* output.printInfo(`thread interrupted: ${threadId}\nsequence: ${dispatch.sequence}`);
+})).pipe(withDescription("interrupt running thread turn"));
 //#endregion
 //#region src/cli/message-input.ts
 function readInitialMessage(input) {
@@ -4650,9 +5656,6 @@ function parseJsonAnswers(text) {
 		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),
@@ -4686,6 +5689,25 @@ const respondThreadCommand = make("respond", {
 	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/threads/unarchive.ts
+const unarchiveThreadCommand = make("unarchive", {
+	thread: threadFlag,
+	format: formatFlag
+}, ({ thread, format }) => gen(function* () {
+	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 dispatch = yield* application.unarchiveThread(threadId);
+	if (resolvedFormat === "json") return yield* output.printJson(dispatch);
+	return yield* output.printInfo(`thread unarchived: ${threadId}\nsequence: ${dispatch.sequence}`);
+})).pipe(withDescription("unarchive thread"));
+//#endregion
 //#region src/cli/model-options.ts
 function buildModelOptions(input) {
 	const options = /* @__PURE__ */ new Map();
@@ -4719,6 +5741,106 @@ function setBooleanOption(options, id, value) {
 	});
 }
 //#endregion
+//#region src/cli/threads/update.ts
+const updateThreadCommand = make("update", {
+	thread: threadFlag,
+	force: selfActionForceFlag,
+	title: string$2("title").pipe(optional$2),
+	provider: string$2("provider").pipe(optional$2),
+	model: string$2("model").pipe(optional$2),
+	...modelFlags,
+	branch: string$2("branch").pipe(optional$2),
+	clearBranch: boolean("clear-branch").pipe(optional$2),
+	worktree: string$2("worktree").pipe(optional$2),
+	clearWorktree: boolean("clear-worktree").pipe(optional$2),
+	format: formatFlag
+}, ({ thread, force, title, provider, model, option, reasoningEffort, effort, fastMode, thinking, branch, clearBranch, worktree, clearWorktree, format }) => gen(function* () {
+	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" }));
+	yield* requireSelfActionConfirmation({
+		threadId,
+		force,
+		environment,
+		action: "update"
+	});
+	const titleValue = getOrUndefined(title);
+	const providerValue = getOrUndefined(provider);
+	const modelValue = getOrUndefined(model);
+	const branchValue = getOrUndefined(branch);
+	const worktreeValue = getOrUndefined(worktree);
+	const clearBranchValue = getOrUndefined(clearBranch);
+	const clearWorktreeValue = getOrUndefined(clearWorktree);
+	const options = buildModelOptions({
+		option,
+		reasoningEffort,
+		effort,
+		fastMode,
+		thinking
+	});
+	if (clearBranchValue === true && branchValue !== void 0) return yield* fail(new ConflictingUpdateFlagsError({ message: "--branch and --clear-branch are mutually exclusive" }));
+	if (clearWorktreeValue === true && worktreeValue !== void 0) return yield* fail(new ConflictingUpdateFlagsError({ message: "--worktree and --clear-worktree are mutually exclusive" }));
+	const hasTitle = titleValue !== void 0 && titleValue.length > 0;
+	const hasProvider = providerValue !== void 0 && providerValue.length > 0;
+	const hasModel = modelValue !== void 0 && modelValue.length > 0;
+	const hasBranch = branchValue !== void 0 && branchValue.length > 0;
+	const hasWorktree = worktreeValue !== void 0 && worktreeValue.length > 0;
+	if (!hasTitle && !hasProvider && !hasModel && options.length === 0 && !hasBranch && clearBranchValue !== true && !hasWorktree && clearWorktreeValue !== true) return yield* fail(new MissingUpdateFieldsError({ message: "at least one update field is required: --title, model flags, --branch, --clear-branch, --worktree, or --clear-worktree" }));
+	const dispatch = yield* application.updateThread({
+		threadId,
+		...hasTitle ? { title: titleValue } : {},
+		...hasProvider ? { provider: providerValue } : {},
+		...hasModel ? { model: modelValue } : {},
+		...options.length > 0 ? { options } : {},
+		...clearBranchValue === true ? { branch: null } : hasBranch ? { branch: branchValue } : {},
+		...clearWorktreeValue === true ? { worktreePath: null } : hasWorktree ? { worktreePath: worktreeValue } : {}
+	});
+	if (resolveOutputFormat(format, environment, "json") === "json") return yield* output.printJson(dispatch);
+	return yield* output.printInfo(`thread updated: ${threadId}\nsequence: ${dispatch.sequence}`);
+})).pipe(withDescription("update thread metadata"));
+//#endregion
+//#region src/cli/thread.ts
+function createThreadCommand() {
+	return make("thread").pipe(withDescription("advanced thread commands"), withSubcommands([
+		approveThreadCommand,
+		respondThreadCommand,
+		archiveThreadCommand,
+		interruptThreadCommand,
+		unarchiveThreadCommand,
+		updateThreadCommand,
+		deleteThreadCommand,
+		callbackThreadCommand
+	]));
+}
+//#endregion
+//#region src/cli/threads/list.ts
+const listThreadsCommand = make("list", {
+	project: projectFlag,
+	archived: boolean("archived").pipe(withDescription$1("List archived threads only")),
+	all: boolean("all").pipe(withDescription$1("List active and archived threads")),
+	format: formatFlag
+}, ({ project, archived, all, format }) => gen(function* () {
+	const application = yield* T3Application;
+	const environment = yield* Environment;
+	const output = yield* T3Output;
+	if (archived && all) yield* fail(new InvalidFlagCombinationError({ message: "--archived and --all are mutually exclusive" }));
+	const include = archived ? "archived" : all ? "all" : "active";
+	const resolvedFormat = resolveOutputFormat(format, environment, "json");
+	const projectRef = yield* requireCommandProjectRef({
+		project,
+		env: environment.env,
+		cwd: environment.cwd
+	});
+	const result = yield* application.listThreads(projectRef, { include });
+	if (resolvedFormat === "json") yield* output.printJson(result.threads);
+	else yield* output.writeStdout(formatThreadsHuman(result.threads));
+})).pipe(withDescription("list project threads"));
+//#endregion
 //#region src/cli/wait-events.ts
 function printWaitEventsNdjson(output, events) {
 	return events.pipe(tap((event) => output.printNdjson(formatWaitEventNdjson(event))), runDrain);
@@ -4777,12 +5899,13 @@ function fitLine(text, columns) {
 //#region src/cli/threads/send.ts
 const sendThreadCommand = make("send", {
 	thread: threadFlag,
+	force: selfActionForceFlag,
 	message: string("message").pipe(optional),
 	stdin: boolean("stdin"),
 	...modelFlags,
 	wait: boolean("wait"),
 	format: threadFormatFlag
-}, ({ thread, message, stdin, option, reasoningEffort, effort, fastMode, thinking, wait, format }) => gen(function* () {
+}, ({ thread, force, message, stdin, option, reasoningEffort, effort, fastMode, thinking, wait, format }) => gen(function* () {
 	const inputService = yield* T3Input;
 	const text = yield* readInitialMessage({
 		message: getOrUndefined(message),
@@ -4804,6 +5927,12 @@ const sendThreadCommand = make("send", {
 		env: environment.env
 	});
 	if (threadId === void 0) return yield* fail(new MissingThreadError({ message: "thread id is required: pass --thread or set T3CODE_THREAD_ID" }));
+	yield* requireSelfActionConfirmation({
+		threadId,
+		force,
+		environment,
+		action: "send a message to"
+	});
 	const input = {
 		message: text,
 		threadId,
@@ -4948,6 +6077,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 +6122,19 @@ 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(),
+		createTerminalCommandGroup(),
+		startThreadCommand,
+		sendThreadCommand,
+		showThreadCommand,
+		getThreadTranscriptCommand,
+		waitForThreadCommand,
 		createThreadCommand()
 	]));
 }
@@ -5005,12 +6150,25 @@ var InputError = class extends TaggedErrorClass()("InputError", {
 }) {};
 const T3InputLive = effect(T3Input, fn("makeT3Input")(function* () {
 	const stdio = yield* Stdio;
-	return { readStdin: fn("T3InputLive.readStdin")(function* () {
-		return yield* stdio.stdin.pipe(decodeText(), runFold(() => "", (acc, chunk) => acc + chunk), catchTags({ PlatformError: (error) => fail(new InputError({
-			message: "failed to read stdin",
-			cause: error
-		})) }));
-	}) };
+	return {
+		readStdin: fn("T3InputLive.readStdin")(function* () {
+			return yield* stdio.stdin.pipe(decodeText(), runFold(() => "", (acc, chunk) => acc + chunk), catchTags({ PlatformError: (error) => fail(new InputError({
+				message: "failed to read stdin",
+				cause: error
+			})) }));
+		}),
+		readStdinBinary: fn("T3InputLive.readStdinBinary")(function* () {
+			return yield* stdio.stdin.pipe(runFold(() => new Uint8Array(0), (acc, chunk) => {
+				const merged = new Uint8Array(acc.length + chunk.length);
+				merged.set(acc);
+				merged.set(chunk, acc.length);
+				return merged;
+			}), map((bytes) => Buffer.from(bytes).toString("latin1")), catchTags({ PlatformError: (error) => fail(new InputError({
+				message: "failed to read stdin",
+				cause: error
+			})) }));
+		})
+	};
 })());
 //#endregion
 //#region src/cli/output/error.ts
@@ -5025,7 +6183,7 @@ var OutputError = class extends TaggedErrorClass()("OutputError", {
 const T3OutputLive = effect(T3Output, fn("makeT3Output")(function* () {
 	const stdio = yield* Stdio;
 	const writeStdout = fn("T3OutputLive.writeStdout")(function* (text) {
-		yield* succeed$4(text).pipe(run$1(stdio.stdout()), catchTags({ PlatformError: (error) => fail(new OutputError({
+		yield* succeed$5(text).pipe(run$1(stdio.stdout()), catchTags({ PlatformError: (error) => fail(new OutputError({
 			message: "failed to write output",
 			cause: error
 		})) }));
@@ -5033,7 +6191,7 @@ const T3OutputLive = effect(T3Output, fn("makeT3Output")(function* () {
 	return {
 		writeStdout,
 		writeStderr: fn("T3OutputLive.writeStderr")(function* (text) {
-			yield* succeed$4(text).pipe(run$1(stdio.stderr()), catchTags({ PlatformError: (error) => fail(new OutputError({
+			yield* succeed$5(text).pipe(run$1(stdio.stderr()), catchTags({ PlatformError: (error) => fail(new OutputError({
 				message: "failed to write output",
 				cause: error
 			})) }));
@@ -5050,12 +6208,69 @@ const T3OutputLive = effect(T3Output, fn("makeT3Output")(function* () {
 	};
 })());
 //#endregion
+//#region src/cli/terminal/io-node-layer.ts
+const DEFAULT_COLS = 80;
+const DEFAULT_ROWS = 24;
+const INTERACTIVE_TTY_MESSAGE = "terminal attach requires an interactive TTY on stdin and stdout";
+const requireInteractiveTty = gen(function* () {
+	if (!process.stdin.isTTY || !process.stdout.isTTY || process.stdin.setRawMode === void 0) return yield* fail(new TerminalIoError({ message: INTERACTIVE_TTY_MESSAGE }));
+	return {
+		stdin: process.stdin,
+		stdout: process.stdout
+	};
+});
+const NodeTerminalIoLive = succeed$2(TerminalIo, {
+	getWindowSize: requireInteractiveTty.pipe(map(readWindowSize)),
+	writeOutput: (text) => sync(() => {
+		process.stdout.write(text);
+	}),
+	openRawSession: acquireRelease(gen(function* () {
+		const tty = yield* requireInteractiveTty;
+		const input = yield* unbounded();
+		const resize = yield* unbounded();
+		const onResize = () => {
+			runFork(offer(resize, readWindowSize(tty)).pipe(ignore));
+		};
+		const onData = (chunk) => {
+			runFork(offer(input, typeof chunk === "string" ? Buffer.from(chunk) : chunk).pipe(ignore));
+		};
+		tty.stdin.resume();
+		tty.stdin.setRawMode(true);
+		process.on("SIGWINCH", onResize);
+		tty.stdin.on("data", onData);
+		return {
+			tty,
+			input,
+			resize,
+			onData,
+			onResize,
+			session: {
+				input: fromQueue(input),
+				resize: fromQueue(resize)
+			}
+		};
+	}), ({ tty, input, resize, onData, onResize }) => gen(function* () {
+		tty.stdin.off("data", onData);
+		process.off("SIGWINCH", onResize);
+		tty.stdin.setRawMode(false);
+		tty.stdin.pause();
+		yield* shutdown(input);
+		yield* shutdown(resize);
+	})).pipe(map(({ session }) => session))
+});
+function readWindowSize(tty) {
+	return {
+		cols: tty.stdout.columns ?? DEFAULT_COLS,
+		rows: tty.stdout.rows ?? DEFAULT_ROWS
+	};
+}
+//#endregion
 //#region src/version/service.ts
 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.11.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 };
@@ -5064,7 +6279,7 @@ effect(T3Version, gen(function* () {
 //#region src/bin.ts
 const VersionLive = T3VersionBundledLive;
 const PlatformLayer = mergeAll(layer, NodeEnvironmentLive);
-const CliLayer = mergeAll(AppLayer.pipe(provide(PlatformLayer)), layer, NodeEnvironmentLive, T3InputLive.pipe(provide(layer)), T3OutputLive.pipe(provide(layer)), VersionLive.pipe(provide(layer)));
+const CliLayer = mergeAll(AppLayer.pipe(provide(PlatformLayer)), layer, NodeEnvironmentLive, T3InputLive.pipe(provide(layer)), T3OutputLive.pipe(provide(layer)), NodeTerminalIoLive, VersionLive.pipe(provide(layer)));
 runMain(gen(function* () {
 	const version = yield* T3Version;
 	return yield* run(createCliCommand(), { version: version.version });