t3code-cli 0.7.0 → 0.9.0

package/dist/bin.js

@@ -1,15 +1,5 @@
 #!/usr/bin/env node
-import { A as none, C as isNone, Ft as BaseProto, Mn as pipe, Nt as withFiber, O as map, On as dual, S as getOrUndefined, T as isSome, X as Prototype, _ as flatMap, an as hasProperty, b as getOrElse, d as make$8, fn as isNotNull, hn as isNullish, i as empty, j as some, k as match, l as getUnsafe, mn as isNotUndefined, n as Service, t as Reference, v as fromNullishOr, xn as isUndefined, y as fromUndefinedOr } from "./Context-DueQ9iMH.js";
-import { $n as makeUnsafe, Ct as serviceOption, E as effectify, F as fnUntraced, Fn as succeed$2, Ft as tryPromise, G as interrupt, Ir as sync$1, It as try_, L as forEach, Ln as sync$2, Lt as uninterruptible, Mn as mergeAll, Mt as tapError, Nn as provide, Ot as suspend, P as fn, Pn as provideMerge, Pt as timeoutOrElse, Qn as isDone, Tt as succeed, U as gen, V as forkScoped, Vt as void_, W as ignore, X as map$1, Xn as doneUnsafe, Yn as _await, a as badArgument, b as catchTags, c as addFinalizer, cr as succeed$1, d as as, dr as ConsoleRef, dt as provideService, fn as fail$1, h as callback, ht as runFork, j as flatMap$1, k as fail, kn as effect, kt as sync, l as andThen, li as fail$2, lt as provide$1, n as TypeId$4, nt as matchEffect, o as systemError, p as asVoid, pi as succeed$3, pt as result, qn as MinimumLogLevel, r as BadArgument, s as acquireRelease, st as orDie, t as Path$1, ti as map$2, ut as provideContext, v as catchFilter, x as catch_, xt as scoped } from "./Path-D8WPdPwR.js";
-import { Bt as runCollect, Ht as runFold, Jt as splitLines, Kt as runLast, L as fromJsonString, Mt as merge, Nt as mkString, On as nominal, P as decodeUnknownEffect, Qt as tap, Sn as offerUnsafe, Tt as fromIterable, Vt as runDrain, Yt as succeed$4, an as drain, b as Struct, bn as offer, cn as isSink, dt as FileSystem, et as optionalKey, ft as FileTypeId, gn as endUnsafe, gt as callback$1, ht as make$9, in as make$10, kt as isStream, mt as WatchBackend, nn as unwrap, nt as tag, pt as Size, rn as get, s as ErrorClass, tn as transduce, u as Literal, ut as FileDescriptor, vn as failCauseUnsafe, vt as decodeText, x as TaggedErrorClass, y as String$1, yn as make$11, yt as empty$1, zt as run$1 } from "./Schema-DsQxYh6_.js";
-import { A as isBoolean, C as getParamMetadata, D as string$1, E as optional$1, F as ShowHelp, I as UnknownSubcommand, L as UnrecognizedOption, M as isTrueValue, N as DuplicateOption, O as getChoiceKeys, P as InvalidValue, R as isCliError, S as extractSingleParams, T as isParam, _ as string$2, a as threadFlag, b as withDescription$1, c as worktreeFlag, d as boolean, f as choice, g as optional$2, h as map$3, i as projectPathFlag, j as isFalseValue, k as getTypeName, l as canRenderLiveTerminal, m as integer, n as modelFlags, o as threadFormatFlag, p as choiceWithValue, r as projectFlag, s as waitFormatFlag, t as formatFlag, u as resolveOutputFormat, v as withAlias, w as isFlagParam, x as argumentKind, y as withDefault, z as makeRunMain } from "./flags-CM7_iGdA.js";
-import { c as fromReadable, l as fromWritable } from "./layer-DvHnKBYj.js";
-import { C as make$12, S as Crypto, x as T3Auth } from "./layer-CfC5qZol.js";
-import { n as T3Config, t as Environment } from "./service-CLmRO2Dp.js";
-import { t as T3Application } from "./service-ybOWV9pL.js";
-import { i as resolveWorktreePath, r as resolveThreadId, t as resolveCommandProjectRef } from "./scope-GycYiJ54.js";
-import { d as latestAssistantMessage, f as threadStatus, m as ThreadSessionError, p as ProjectLookupError, t as AppLayer } from "./layer-MqCKkIGD.js";
-import { t as NodeEnvironmentLive } from "./layer-DHhKS5jd.js";
+import { $d as string$2, $f as runFold, $p as timeoutOrElse, Af as tag, Am as getOrElse, Ap as fail, Bd as waitFormatFlag, Bf as Size, Bm as BaseProto, Bp as matchEffect, Cf as String$1, Cm as Service, Cp as as, 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 * as NodeChildProcess from "node:child_process";
 import * as NodeCrypto from "node:crypto";
 import * as NFS from "node:fs";
@@ -153,11 +143,11 @@ const makeHandle = (params) => Object.assign(Object.create(HandleProto), params)
 * @since 4.0.0
 */
 const make$7 = (spawn) => {
-	const streamString = (command, options) => spawn(command).pipe(map$1((handle) => decodeText(options?.includeStderr === true ? handle.all : handle.stdout)), unwrap);
+	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({
 		spawn,
-		exitCode: (command) => scoped(flatMap$1(spawn(command), (handle) => handle.exitCode)),
+		exitCode: (command) => scoped(flatMap(spawn(command), (handle) => handle.exitCode)),
 		streamString,
 		streamLines,
 		lines: (command, options) => runCollect(streamLines(command, options)),
@@ -534,7 +524,7 @@ const layer$11 = /*#__PURE__*/ effect(ChildProcessSpawner, /* @__PURE__ */ gen(f
 	const setupAdditionalFds = fnUntraced(function* (command, childProcess, additionalFds) {
 		if (additionalFds.length === 0) return {
 			getInputFd: () => drain,
-			getOutputFd: () => empty$1
+			getOutputFd: () => empty
 		};
 		const inputSinks = /* @__PURE__ */ new Map();
 		const outputStreams = /* @__PURE__ */ new Map();
@@ -552,7 +542,7 @@ const layer$11 = /*#__PURE__*/ effect(ChildProcessSpawner, /* @__PURE__ */ gen(f
 					break;
 				}
 				case "output": {
-					let stream = empty$1;
+					let stream = empty;
 					if (nodeStream && "read" in nodeStream) stream = fromReadable({
 						evaluate: () => nodeStream,
 						onError: (error) => toPlatformError(`fromReadable(fd${fd})`, toError(error), command)
@@ -565,7 +555,7 @@ const layer$11 = /*#__PURE__*/ effect(ChildProcessSpawner, /* @__PURE__ */ gen(f
 		}
 		return {
 			getInputFd: (fd) => inputSinks.get(fd) ?? drain,
-			getOutputFd: (fd) => outputStreams.get(fd) ?? empty$1
+			getOutputFd: (fd) => outputStreams.get(fd) ?? empty
 		};
 	});
 	const setupChildStdin = (command, childProcess, config) => suspend(() => {
@@ -583,11 +573,11 @@ const layer$11 = /*#__PURE__*/ effect(ChildProcessSpawner, /* @__PURE__ */ gen(f
 		let stdout = childProcess.stdout ? fromReadable({
 			evaluate: () => childProcess.stdout,
 			onError: (error) => toPlatformError("fromReadable(stdout)", toError(error), command)
-		}) : empty$1;
+		}) : empty;
 		let stderr = childProcess.stderr ? fromReadable({
 			evaluate: () => childProcess.stderr,
 			onError: (error) => toPlatformError("fromReadable(stderr)", toError(error), command)
-		}) : empty$1;
+		}) : empty;
 		if (isSink(stdoutConfig.stream)) stdout = transduce(stdout, stdoutConfig.stream);
 		if (isSink(stderrConfig.stream)) stderr = transduce(stderr, stderrConfig.stream);
 		const all = merge(stdout, stderr);
@@ -712,8 +702,8 @@ const layer$11 = /*#__PURE__*/ effect(ChildProcessSpawner, /* @__PURE__ */ gen(f
 				const stdin = yield* setupChildStdin(cmd, childProcess, stdinConfig);
 				const { all, stderr, stdout } = setupChildOutputStreams(cmd, childProcess, stdoutConfig, stderrConfig);
 				const { getInputFd, getOutputFd } = yield* setupAdditionalFds(cmd, childProcess, resolvedAdditionalFds);
-				const isRunning = map$1(isDone(exitSignal), (done) => !done);
-				const exitCode = flatMap$1(_await(exitSignal), ([code, signal]) => {
+				const isRunning = map(isDone(exitSignal), (done) => !done);
+				const exitCode = flatMap(_await(exitSignal), ([code, signal]) => {
 					if (isNotNull(code)) return succeed(ExitCode(code));
 					return fail(toPlatformError("exitCode", new globalThis.Error(`Process interrupted due to receipt of signal: '${signal}'`), cmd));
 				});
@@ -895,7 +885,7 @@ const digest = (algorithm, data) => try_({
 * @category layers
 * @since 1.0.0
 */
-const layer$9 = /* @__PURE__ */ succeed$2(Crypto, /* @__PURE__ */ make$12({
+const layer$9 = /* @__PURE__ */ succeed$2(Crypto, /* @__PURE__ */ make$8({
 	randomBytes: NodeCrypto.randomBytes,
 	digest
 }));
@@ -1005,7 +995,7 @@ const makeTempDirectoryScoped = /*#__PURE__*/ (() => {
 const openFactory = (method) => {
 	const nodeOpen = effectify(NFS.open, handleErrnoException("FileSystem", method), handleBadArgument(method));
 	const nodeClose = effectify(NFS.close, handleErrnoException("FileSystem", method), handleBadArgument(method));
-	return (path, options) => pipe(acquireRelease(nodeOpen(path, options?.flag ?? "r", options?.mode), (fd) => orDie(nodeClose(fd))), map$1((fd) => makeFile(FileDescriptor(fd), options?.flag?.startsWith("a") ?? false)));
+	return (path, options) => pipe(acquireRelease(nodeOpen(path, options?.flag ?? "r", options?.mode), (fd) => orDie(nodeClose(fd))), map((fd) => makeFile(FileDescriptor(fd), options?.flag?.startsWith("a") ?? false)));
 };
 const open = /*#__PURE__*/ openFactory("open");
 const makeFile = /*#__PURE__*/ (() => {
@@ -1029,7 +1019,7 @@ const makeFile = /*#__PURE__*/ (() => {
 			this.append = append;
 		}
 		get stat() {
-			return map$1(nodeStat(this.fd), makeFileInfo);
+			return map(nodeStat(this.fd), makeFileInfo);
 		}
 		get sync() {
 			return nodeSync(this.fd);
@@ -1045,7 +1035,7 @@ const makeFile = /*#__PURE__*/ (() => {
 		read(buffer) {
 			return suspend(() => {
 				const position = this.position;
-				return map$1(nodeRead(this.fd, {
+				return map(nodeRead(this.fd, {
 					buffer,
 					position
 				}), (bytesRead) => {
@@ -1060,7 +1050,7 @@ const makeFile = /*#__PURE__*/ (() => {
 			return suspend(() => {
 				const buffer = Buffer.allocUnsafeSlow(sizeNumber);
 				const position = this.position;
-				return map$1(nodeReadAlloc(this.fd, {
+				return map(nodeReadAlloc(this.fd, {
 					buffer,
 					position
 				}), (bytesRead) => {
@@ -1074,7 +1064,7 @@ const makeFile = /*#__PURE__*/ (() => {
 			});
 		}
 		truncate(length) {
-			return map$1(nodeTruncate(this.fd, length ? Number(length) : void 0), () => {
+			return map(nodeTruncate(this.fd, length ? Number(length) : void 0), () => {
 				if (!this.append) {
 					const len = BigInt(length ?? 0);
 					if (this.position > len) this.position = len;
@@ -1084,7 +1074,7 @@ const makeFile = /*#__PURE__*/ (() => {
 		write(buffer) {
 			return suspend(() => {
 				const position = this.position;
-				return map$1(nodeWrite(this.fd, buffer, void 0, void 0, this.append ? void 0 : Number(position)), (bytesWritten) => {
+				return map(nodeWrite(this.fd, buffer, void 0, void 0, this.append ? void 0 : Number(position)), (bytesWritten) => {
 					const sizeWritten = Size(bytesWritten);
 					if (!this.append) this.position = position + sizeWritten;
 					return sizeWritten;
@@ -1094,7 +1084,7 @@ const makeFile = /*#__PURE__*/ (() => {
 		writeAllChunk(buffer) {
 			return suspend(() => {
 				const position = this.position;
-				return flatMap$1(nodeWriteAll(this.fd, buffer, void 0, void 0, this.append ? void 0 : Number(position)), (bytesWritten) => {
+				return flatMap(nodeWriteAll(this.fd, buffer, void 0, void 0, this.append ? void 0 : Number(position)), (bytesWritten) => {
 					if (bytesWritten === 0) return fail(systemError({
 						module: "FileSystem",
 						method: "writeAll",
@@ -1173,7 +1163,7 @@ const makeFileInfo = (stat) => ({
 });
 const stat = /*#__PURE__*/ (() => {
 	const nodeStat = /*#__PURE__*/ effectify(NFS.stat, /*#__PURE__*/ handleErrnoException("FileSystem", "stat"), /*#__PURE__*/ handleBadArgument("stat"));
-	return (path) => map$1(nodeStat(path), makeFileInfo);
+	return (path) => map(nodeStat(path), makeFileInfo);
 })();
 const symlink = /*#__PURE__*/ (() => {
 	const nodeSymlink = /*#__PURE__*/ effectify(NFS.symlink, /*#__PURE__*/ handleErrnoException("FileSystem", "symlink"), /*#__PURE__*/ handleBadArgument("symlink"));
@@ -1225,7 +1215,7 @@ const watchNode = (path) => callback$1((queue) => acquireRelease(sync(() => {
 	});
 	return watcher;
 }), (watcher) => sync(() => watcher.close())));
-const watch = (backend, path) => stat(path).pipe(map$1((stat) => backend.pipe(flatMap((_) => _.register(path, stat)), getOrElse(() => watchNode(path)))), unwrap);
+const watch = (backend, path) => stat(path).pipe(map((stat) => backend.pipe(flatMap$1((_) => _.register(path, stat)), getOrElse(() => watchNode(path)))), unwrap);
 const writeFile = (path, data, options) => callback((resume, signal) => {
 	try {
 		NFS.writeFile(path, data, {
@@ -1240,7 +1230,7 @@ const writeFile = (path, data, options) => callback((resume, signal) => {
 		resume(fail(handleBadArgument("writeFile")(err)));
 	}
 });
-const makeFileSystem = /*#__PURE__*/ map$1(/*#__PURE__*/ serviceOption(WatchBackend), (backend) => make$9({
+const makeFileSystem = /*#__PURE__*/ map(/*#__PURE__*/ serviceOption(WatchBackend), (backend) => make$9({
 	access,
 	chmod,
 	chown,
@@ -1651,7 +1641,7 @@ const layer$2 = /*#__PURE__*/ effect(Terminal, /*#__PURE__*/ (/* @__PURE__ */ fn
 		stdin.on("keypress", handleKeypress);
 		return queue;
 	});
-	const readLine = scoped(flatMap$1(get(rlRef), (readlineInterface) => callback((resume) => {
+	const readLine = scoped(flatMap(get(rlRef), (readlineInterface) => callback((resume) => {
 		const onLine = (line) => resume(succeed(line));
 		readlineInterface.once("line", onLine);
 		return sync(() => readlineInterface.off("line", onLine));
@@ -2668,7 +2658,7 @@ const makeCommand = (options) => {
 	const config = options.config;
 	const contextConfig = options.contextConfig ?? emptyConfig;
 	const service = options.service ?? Service(`~effect/cli/Command/${options.name}`);
-	const annotations = options.annotations ?? empty();
+	const annotations = options.annotations ?? empty$1();
 	const globalFlags = options.globalFlags ?? [];
 	const subcommands = options.subcommands ?? [];
 	const handle = (input, commandPath) => isNotUndefined(options.handle) ? options.handle(input, commandPath) : fail(new ShowHelp({
@@ -2711,7 +2701,7 @@ const makeCommand = (options) => {
 			if (visible.length === 0) continue;
 			subcommandDocs.push({
 				group: group.group,
-				commands: map$2(visible, (subcommand) => ({
+				commands: map$1(visible, (subcommand) => ({
 					name: subcommand.name,
 					alias: subcommand.alias,
 					shortDescription: subcommand.shortDescription,
@@ -3135,7 +3125,7 @@ const Completions = /*#__PURE__*/ action({
 		"zsh",
 		"fish",
 		"sh"
-	]).pipe(optional$2, /*#__PURE__*/ map$3((v) => map(v, (s) => s === "sh" ? "bash" : s)), /*#__PURE__*/ withDescription$1("Print shell completion script")),
+	]).pipe(optional$2, /*#__PURE__*/ map$2((v) => map$3(v, (s) => s === "sh" ? "bash" : s)), /*#__PURE__*/ withDescription$1("Print shell completion script")),
 	run: (shell, { command }) => gen(function* () {
 		if (isNone(shell)) return;
 		const descriptor = fromCommand(command);
@@ -4083,7 +4073,7 @@ const showHelp = (command, error$1) => gen(function* () {
 * @category command execution
 * @since 4.0.0
 */
-const run = /*#__PURE__*/ dual(2, (command, config) => Stdio.use(({ args }) => flatMap$1(args, (args) => runWith(command, config)(args))));
+const run = /*#__PURE__*/ dual(2, (command, config) => Stdio.use(({ args }) => flatMap(args, (args) => runWith(command, config)(args))));
 /**
 * Runs a command with explicitly provided arguments instead of using arguments from `Stdio`.
 *
@@ -4187,8 +4177,8 @@ const runWith = (command, config) => {
 		const [, logLevel] = yield* LogLevel.flag.parse(emptyArgs);
 		program = provideService(program, LogLevel, logLevel);
 		const services = match(logLevel, {
-			onNone: () => empty(),
-			onSome: (level) => make$8(MinimumLogLevel, level)
+			onNone: () => empty$1(),
+			onSome: (level) => make$12(MinimumLogLevel, level)
 		});
 		yield* provideContext(program, services);
 	}, catchFilter((error) => isCliError(error) && error._tag === "ShowHelp" ? succeed$3(error) : fail$2(error), (error) => andThen(showHelp(command, error), fail(error))), catchFilter((e) => isQuitError(e) ? succeed$3(e) : fail$2(e), (_) => interrupt));
@@ -4380,12 +4370,50 @@ var InvalidLimitError = class extends TaggedErrorClass()("InvalidLimitError", {
 	value: String$1
 }) {};
 var MissingThreadError = class extends TaggedErrorClass()("MissingThreadError", { message: String$1 }) {};
+var SelfArchiveError = class extends TaggedErrorClass()("SelfArchiveError", {
+	message: String$1,
+	threadId: String$1
+}) {};
+var MissingRequestError = class extends TaggedErrorClass()("MissingRequestError", { 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, format }) => gen(function* () {
+}, ({ thread, force, format }) => gen(function* () {
 	const application = yield* T3Application;
 	const environment = yield* Environment;
 	const output = yield* T3Output;
@@ -4394,12 +4422,67 @@ const archiveThreadCommand = make("archive", {
 		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 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* (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/require.ts
 const requireCommandProjectRef = fn("requireCommandProjectRef")(function* (input) {
 	const resolved = yield* (yield* T3Config).resolve();
@@ -4417,6 +4500,50 @@ const requireCommandProjectRef = fn("requireCommandProjectRef")(function* (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,
+		archivedAt: thread.archivedAt,
+		createdAt: thread.createdAt,
+		updatedAt: thread.updatedAt,
+		messageCount: thread.messageCount,
+		hasPendingApprovals: thread.hasPendingApprovals,
+		hasPendingUserInput: thread.hasPendingUserInput,
+		hasActionableProposedPlan: thread.hasActionableProposedPlan,
+		pendingApprovals: thread.pendingApprovals,
+		pendingUserInputs: thread.pendingUserInputs
+	};
+}
+function formatThreadShowHuman(thread) {
+	const lines = [
+		`title: ${thread.title}`,
+		`id: ${thread.id}`,
+		`status: ${thread.status}`,
+		`model: ${thread.modelSelection.instanceId}/${thread.modelSelection.model}`,
+		...thread.branch !== null ? [`branch: ${thread.branch}`] : [],
+		...thread.worktreePath !== null ? [`worktree: ${thread.worktreePath}`] : [],
+		`messages: ${thread.messageCount}`
+	];
+	if (thread.pendingApprovals.length > 0) {
+		const requestIds = thread.pendingApprovals.map((approval) => approval.requestId).join(", ");
+		lines.push(`pending approvals: ${thread.pendingApprovals.length} (${requestIds})`);
+	}
+	if (thread.pendingUserInputs.length > 0) {
+		const requestIds = thread.pendingUserInputs.map((input) => input.requestId).join(", ");
+		lines.push(`pending user inputs: ${thread.pendingUserInputs.length} (${requestIds})`);
+	}
+	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("");
 }
@@ -4509,6 +4636,55 @@ function readInitialMessage(input) {
 	if (input.message === void 0 || input.message.length === 0) return fail(new MessageInputError({ message: "message required unless --stdin is used" }));
 	return succeed(input.message);
 }
+function readJsonAnswers(input) {
+	if (input.answers !== void 0 && input.answers.length > 0 && input.fromStdin) return fail(new MessageInputError({ message: "pass --answers or --stdin, not both" }));
+	if (input.fromStdin) return input.readStdin().pipe(flatMap(parseJsonAnswers));
+	if (input.answers === void 0 || input.answers.length === 0) return fail(new MessageInputError({ message: "answers required unless --stdin is used" }));
+	return parseJsonAnswers(input.answers);
+}
+function parseJsonAnswers(text) {
+	try {
+		const parsed = JSON.parse(text);
+		return succeed(decodeUnknownSync(ProviderUserInputAnswers)(parsed));
+	} catch {
+		return fail(new MessageInputError({ message: "invalid JSON in answers" }));
+	}
+}
+//#endregion
+//#region src/cli/input/service.ts
+var T3Input = class extends Service()("t3cli/T3Input") {};
+const respondThreadCommand = make("respond", {
+	thread: threadFlag,
+	request: string$2("request").pipe(withDescription$1("Pending user-input request id"), optional$2),
+	answers: string$2("answers").pipe(optional$2),
+	stdin: boolean("stdin"),
+	format: formatFlag
+}, ({ thread, request, answers, stdin, format }) => gen(function* () {
+	const inputService = yield* T3Input;
+	const parsedAnswers = yield* readJsonAnswers({
+		answers: getOrUndefined(answers),
+		fromStdin: stdin,
+		readStdin: inputService.readStdin
+	});
+	const application = yield* T3Application;
+	const environment = yield* Environment;
+	const output = yield* T3Output;
+	const threadId = resolveThreadId({
+		value: getOrUndefined(thread),
+		env: environment.env
+	});
+	if (threadId === void 0) return yield* fail(new MissingThreadError({ message: "thread id is required: pass --thread or set T3CODE_THREAD_ID" }));
+	const requestId = getOrUndefined(request);
+	if (requestId === void 0 || requestId.length === 0) return yield* fail(new MissingRequestError({ message: "request id is required: pass --request" }));
+	const resolvedFormat = resolveOutputFormat(format, environment, "json");
+	const result = yield* application.respondToThread({
+		threadId,
+		requestId,
+		answers: parsedAnswers
+	});
+	if (resolvedFormat === "json") return yield* output.printJson(result);
+	return yield* output.printInfo(`user input submitted: ${result.requestId}\nsequence: ${result.dispatch.sequence}`);
+})).pipe(withDescription("respond to a pending user-input request"));
 //#endregion
 //#region src/cli/model-options.ts
 function buildModelOptions(input) {
@@ -4543,9 +4719,6 @@ function setBooleanOption(options, id, value) {
 	});
 }
 //#endregion
-//#region src/cli/input/service.ts
-var T3Input = class extends Service()("t3cli/T3Input") {};
-//#endregion
 //#region src/cli/wait-events.ts
 function printWaitEventsNdjson(output, events) {
 	return events.pipe(tap((event) => output.printNdjson(formatWaitEventNdjson(event))), runDrain);
@@ -4582,7 +4755,7 @@ function printWaitEventsHuman(output, events, options) {
 				if (rendered) yield* output.writeStderr("\r\x1B[2K");
 				yield* output.writeStdout(formatWaitDoneHuman(event.thread));
 			});
-		}), runLast, flatMap$1((event) => {
+		}), runLast, flatMap((event) => {
 			if (isSome(event) && event.value.type === "done") return void_;
 			return fail(new ThreadSessionError({
 				message: `thread wait ended without done event: ${options.threadId}`,
@@ -4667,6 +4840,25 @@ const sendThreadCommand = make("send", {
 	return yield* output.printInfo(`message sent: ${result.threadId}`);
 })).pipe(withDescription("send message to existing thread"));
 //#endregion
+//#region src/cli/threads/show.ts
+const showThreadCommand = make("show", {
+	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 detail = yield* application.showThread(threadId);
+	if (resolvedFormat === "json") return yield* output.printJson(formatThreadShowJson(detail));
+	return yield* output.writeStdout(formatThreadShowHuman(detail));
+})).pipe(withDescription("show thread status and pending requests"));
+//#endregion
 //#region src/cli/threads/start.ts
 const startThreadCommand = make("start", {
 	project: projectFlag,
@@ -4782,9 +4974,13 @@ function createThreadCommand() {
 		listThreadsCommand,
 		startThreadCommand,
 		sendThreadCommand,
+		showThreadCommand,
+		approveThreadCommand,
+		respondThreadCommand,
 		archiveThreadCommand,
 		getThreadMessagesCommand,
-		waitForThreadCommand
+		waitForThreadCommand,
+		callbackThreadCommand
 	]));
 }
 //#endregion
@@ -4859,7 +5055,7 @@ var T3Version = class extends Service()("t3cli/T3Version") {};
 //#endregion
 //#region src/version/layer.ts
 const PackageJsonSchema = fromJsonString(Struct({ version: String$1 }));
-const T3VersionBundledLive = sync$2(T3Version, () => ({ version: "0.7.0" }));
+const T3VersionBundledLive = sync$2(T3Version, () => ({ version: "0.9.0" }));
 effect(T3Version, gen(function* () {
 	const packageJson = yield* (yield* FileSystem).readFileString(fileURLToPath(new URL("../../package.json", import.meta.url)));
 	return { version: (yield* decodeUnknownEffect(PackageJsonSchema)(packageJson)).version };

package/dist/cli.js

@@ -1,2 +1,2 @@
-import { a as threadFlag, c as worktreeFlag, i as projectPathFlag, n as modelFlags, o as threadFormatFlag, r as projectFlag, s as waitFormatFlag, t as formatFlag } from "./flags-CM7_iGdA.js";
+import { Bd as waitFormatFlag, Fd as modelFlags, Id as projectFlag, Ld as projectPathFlag, Pd as formatFlag, Rd as threadFlag, Vd as worktreeFlag, zd as threadFormatFlag } from "./shared.js";
 export { formatFlag, modelFlags, projectFlag, projectPathFlag, threadFlag, threadFormatFlag, waitFormatFlag, worktreeFlag };

package/dist/config.js

@@ -1,4 +1,2 @@
-import { n as T3Config } from "./service-CLmRO2Dp.js";
-import { n as UrlError, t as ConfigError } from "./error-BHRnjLux.js";
-import { n as makeT3Config, t as T3ConfigLive } from "./layer-DUv99vsS.js";
+import { Gd as T3Config, U as ConfigError, W as UrlError, h as makeT3Config, m as T3ConfigLive } from "./shared.js";
 export { ConfigError, T3Config, T3ConfigLive, UrlError, makeT3Config };

package/dist/connection.js

@@ -1,7 +1,4 @@
-import { Mn as mergeAll, Nn as provide } from "./Path-D8WPdPwR.js";
-import { n as T3AuthTransportLive } from "./transport-D3zBdZ1h.js";
-import { a as makeT3CodeConnectionProvider, i as T3CodeConnectionProviderLive, o as layerWebSocketConstructor, r as T3CodeConnectionProvider, s as layerUndici, t as T3RpcLive } from "./layer-DvHnKBYj.js";
-import { n as T3CodeConnectionError } from "./error-B2t1bAP9.js";
+import { F as T3CodeConnectionError, K as layerWebSocketConstructor, S as T3AuthTransportLive, d as T3CodeConnectionProvider, f as T3CodeConnectionProviderLive, om as mergeAll, p as makeT3CodeConnectionProvider, q as layerUndici, sm as provide, u as T3RpcLive } from "./shared.js";
 //#region src/connection/layer.ts
 function makeT3CodeRpcLayer() {
 	return T3RpcLive.pipe(provide(T3AuthTransportLive));

package/dist/index.js

@@ -1,5 +1,2 @@
-import { t as T3Application } from "./service-ybOWV9pL.js";
-import { n as AuthAppLayer, t as AppLayer } from "./layer-MqCKkIGD.js";
-import "./application.js";
-import "./runtime.js";
+import { Nd as T3Application, n as AuthAppLayer, t as AppLayer } from "./shared.js";
 export { AppLayer, AuthAppLayer, T3Application };

package/dist/layout.js

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

package/dist/orchestration.js

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

package/dist/rpc.js

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

package/dist/runtime.js

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

package/dist/scope.js

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