t3code-cli 0.14.2 → 0.15.0

package/dist/bin.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { a as __toESM, i as __require, t as __commonJSMin } from "./rolldown-runtime.js";
-import { $D as ExitCode, $E as red, $O as isSink, $T as loadT3CliEnv, AA as fail$1, AD as TaggedErrorClass, AE as getParamMetadata, AO as fromQueue, Aj as none, BA as succeed$2, BE as float, BO as runFold, BT as threadFlag, Bj as hasProperty, Bk as gen, Bs as CliPath, CD as Literal, CE as withDescription$1, CO as decodeText, DE as argumentKind, Dj as isSome, Dk as catch_, EE as log, EO as filter, Ej as isNone, Ek as catchTags, FD as decodeUnknownEffect, FE as optional$1, FO as merge, FT as modelFlags, Fk as fnUntraced, GA as isDone, GD as Crypto, GE as text, GO as succeed$5, GT as canRenderLiveTerminal, Gk as map, HA as MinimumLogLevel, HD as optionalKey, HE as password, HO as runHead, HT as waitFormatFlag, Hj as isNotUndefined, Hk as interrupt, Hs as threadStatus, Hw as cliEnvironmentSetting, IA as effect, IE as string$1, IT as projectFlag, Ik as forEach, Is as layerNode, JA as succeed$4, JD as fromWritable, JE as blackBright, JO as transduce, Jj as identity$1, Jk as matchEffect, Jw as ProjectLookupError, KA as make$13, KD as make$7, KE as toggle, Kj as isUndefined, Kk as mapError, Kw as resolveThreadId, LA as mergeAll, LD as decodeUnknownSync, LE as variadic$1, LT as projectPathFlag, ME as isFlagParam, MO as map$1, MT as envNameFlag, NE as isParam, NT as forceFlag, Nk as flatMap, Ns as layerNode$1, OD as String$1, OE as extractSingleParams, Ok as effectify, PE as mapEffect$1, PT as formatFlag, Pk as fn, QD as ChildProcessSpawner, QE as magenta, QO as drain, Qk as orDie, Qw as T3Config, RA as provide, RD as fromJsonString, RE as confirm, RO as run$2, RT as replaceFlag, Rs as layer$13, SE as withDefault, Sj as getOrElse, Sk as callback, TE as error, TO as empty, Tj as getOrUndefined, Tk as catchTag, UA as _await, UE as run$3, UO as runLast, UT as worktreeFlag, Uj as isNullish, Uw as T3Auth, VA as sync$1, VE as integer, VO as runForEach, VT as threadFormatFlag, Vj as isNotNull, Vk as ignore, Vs as latestAssistantMessage, WA as doneUnsafe, WD as value$2, WE as select, WT as yesFlag, Ww as resolveCommandProjectRef, XD as make$5, XE as cyanBright, XO as get$1, XT as isInteractiveHumanTerminal, Xj as pipeArguments, Xw as CliRuntime, YD as fdName, YE as bold, YO as unwrap, YT as isAgentEnvironment, Yj as pipe, Yw as ThreadSessionError, ZA as succeed$1, ZD as parseFdName, ZE as green, ZO as make$10, ZT as resolveOutputFormat, Zw as layer$12, _D as Terminal, _E as boolean, _O as WatchBackend, _j as make$12, aA as scoped, aD as isTrueValue, ak as offerUnsafe, bA as void_, bE as optional$2, bj as fromNullishOr, bk as as, cA as succeed, cD as ShowHelp, cE as Wizard, cj as isSuccess, dD as isCliError, dE as getHelpForCommandPath, dk as BadArgument, eA as provide$1, eD as white, eO as ProcessId, fE as TypeId$3, fO as Path$1, fk as badArgument, gA as try_, gD as QuitError, gE as parseConfig, gO as Size, gj as empty$1, gk as addFinalizer, hA as tryPromise, hE as toImpl, hO as FileTypeId, hj as Service, hk as acquireRelease, iA as runFork, iD as isFalseValue, ij as fail$2, ik as offer, jE as getUnderlyingSingleOrThrow, jO as isStream, jj as some, jk as fail, kD as Struct, kO as fromIterable, kj as match, lA as suspend, lD as UnknownSubcommand, lE as getGlobalFlagsForCommandPath, lj as succeed$3, lk as take, mA as timeoutOrElse, mE as makeCommand, mO as FileSystem, mj as Reference, mk as makeRunMain, nA as provideService, nD as getTypeName, nO as makeHandle, nS as ProviderUserInputAnswers, nk as failCauseUnsafe, oA as serviceOption, oE as BuiltIns, ok as poll, pE as checkForDuplicateFlags, pO as TypeId$2, pk as systemError, qA as makeUnsafe, qD as fromReadable, qE as annotate, qO as tap, qj as dual, qk as match$1, qw as resolveWorktreePath, rA as result$1, rD as isBoolean, rk as make$9, sD as InvalidValue, sE as LogLevel, sj as isResult, sk as shutdown, tA as provideContext, tD as getChoiceKeys, tE as T3Application, tO as make$6, tk as endUnsafe, uA as sync, uD as UnrecognizedOption, uE as getGlobalFlagsForCommandTree, uk as unbounded, vD as isQuitError, vE as choice, vO as make$8, vj as flatMap$1, vk as andThen, wE as Formatter, wk as catchFilter, xE as string$2, xj as fromUndefinedOr, xk as asVoid, yA as uninterruptible, yD as make$11, yE as integer$1, yO as callback$1, zA as provideMerge, zE as date, zO as runDrain, zT as selfActionForceFlag, zk as forkScoped, zn as BaseAppLayer } from "./shared.js";
+import { $A as runHead, $E as resolveThreadId, $M as succeed$2, $O as toggle, $j as ignore, $k as value$2, AA as callback$1, AN as Service, AO as withDescription$1, Aj as andThen, Ak as DurationFromString, BA as fromIterable, BD as forceFlag, BN as getOrUndefined, BO as isParam, Bj as effectify, CA as Path$1, CM as sync, CN as format, CO as parseConfig, Cj as BadArgument, Ck as QuitError, DA as Size, DM as timeoutOrElse, DO as optional$2, Dj as acquireRelease, EA as FileTypeId, EO as integer$1, Ej as makeRunMain, Ek as make$11, FN as fromNullishOr, FO as extractSingleParams, GD as replaceFlag, GN as none, GO as confirm, Gj as flatMap, Gk as decodeUnknownOption, HA as isStream, HD as modelFlags, HN as isSome, HO as optional$1, IA as empty, IN as fromUndefinedOr, Ij as catchFilter, Is as layerNode$1, JD as threadFormatFlag, JO as integer, Jj as forEach, KA as merge, KD as selfActionForceFlag, KN as some, KO as date, Kj as fn, Kk as decodeUnknownSync, LA as filter, LN as getOrElse, LO as getParamMetadata, Lj as catchTag, Lk as String$1, MM as uninterruptible, MN as make$12, MO as error, Mj as as, Mk as Literal, NM as void_, NN as flatMap$1, NO as log, Nj as asVoid, OA as WatchBackend, OM as tryPromise, ON as toMillis, OO as string$2, Oj as addFinalizer, Ok as DateTimeUtcFromString, PA as decodeText, PO as argumentKind, Pj as callback, QA as runForEach, QD as canRenderLiveTerminal, QM as provideMerge, QO as text, Qj as gen, RO as getUnderlyingSingleOrThrow, Rj as catchTags, Rk as Struct, SM as suspend, SN as succeed$3, SO as toImpl, Sj as unbounded, TA as FileSystem, TO as choice, Tj as systemError, Tk as isQuitError, UA as map$1, UD as projectFlag, UM as fail$1, UO as string$1, Uj as fail, VA as fromQueue, VD as formatFlag, VN as isNone, VO as mapEffect$1, Vs as layer$13, WD as projectPathFlag, WN as match, WO as variadic$1, Wk as decodeUnknownEffect, XA as runDrain, XD as worktreeFlag, XM as mergeAll, XO as run$3, Xs as resolveSnoozePresets, YA as run$2, YD as waitFormatFlag, YM as effect, YO as password, ZA as runFold, ZD as yesFlag, ZE as resolveCommandProjectRef, ZM as provide, ZO as select, Zj as forkScoped, Zk as optionalKey, _M as runFork, _N as fail$2, _O as getGlobalFlagsForCommandTree, _j as offerUnsafe, _k as UnrecognizedOption, aA as make$5, aD as T3Config, aM as match$1, aN as make$13, ac as derivePendingUserInputs, aj as tap, ak as magenta, bN as isResult, bO as checkForDuplicateFlags, cA as ExitCode, cO as T3Application, cP as dual, cc as threadStatus, cj as get$1, ck as getChoiceKeys, dA as makeHandle, dM as orDie, dP as pipeArguments, dj as isSink, dk as isFalseValue, dw as ProviderUserInputAnswers, eA as Crypto, eD as resolveWorktreePath, eM as interrupt, eN as sync$1, eO as humanJsonNdjsonFormatChoices, ej as runLast, ek as annotate, fk as isTrueValue, gM as result$1, gO as getGlobalFlagsForCommandPath, gj as offer, gk as UnknownSubcommand, hM as provideService, hO as Wizard, hj as make$9, hk as ShowHelp, iA as fdName, iD as layer$12, iM as mapError, iN as isDone, iO as resolveOutputFormat, iP as isNullish, ic as derivePendingApprovals, ij as takeUntil, ik as green, jN as empty$1, jO as Formatter, kA as make$8, kM as try_, kN as Reference, kO as withDefault, lA as ProcessId, lM as onInterrupt, lP as identity$1, lj as make$10, lk as getTypeName, mM as provideContext, mO as LogLevel, mj as failCauseUnsafe, mk as InvalidValue, nA as fromReadable, nD as ThreadSessionError, nN as _await, nO as isAgentEnvironment, nP as isNotNull, nc as cliEnvironmentSetting, nj as succeed$5, nk as bold, oA as parseFdName, oM as matchEffect, oN as makeUnsafe, oO as loadT3CliEnv, oc as isThreadActive, oj as transduce, ok as red, pM as provide$1, pO as BuiltIns, pj as endUnsafe, qD as threadFlag, qO as float, qj as fnUntraced, qk as fromJsonString, rA as fromWritable, rD as CliRuntime, rM as map, rN as doneUnsafe, rO as isInteractiveHumanTerminal, rP as isNotUndefined, rc as T3Auth, rk as cyanBright, sA as ChildProcessSpawner, sN as succeed$4, sP as isUndefined, sc as latestAssistantMessage, sj as unwrap, sk as white, tA as make$7, tD as ProjectLookupError, tN as MinimumLogLevel, tP as hasProperty, tc as CliPath, tk as blackBright, uA as make$6, uN as succeed$1, uP as pipe, uj as drain, uk as isBoolean, vA as formatIso, vM as scoped, vO as getHelpForCommandPath, vj as poll, vk as isCliError, wA as TypeId$2, wO as boolean, wj as badArgument, wk as Terminal, xM as succeed, xN as isSuccess, xO as makeCommand, xj as take, yA as nowAsDate, yM as serviceOption, yO as TypeId$3, yj as shutdown, zD as envNameFlag, zO as isFlagParam, zj as catch_, zk as TaggedErrorClass, zn as BaseAppLayer, zs as layerNode } from "./shared.js";
 import * as OS from "node:os";
 import os, { homedir } from "node:os";
 import * as NodeChildProcess from "node:child_process";
@@ -86369,9 +86369,46 @@ var SelfActionError = class extends TaggedErrorClass()("SelfActionError", {
 }) {};
 var DestructiveConfirmationRequiredError = class extends TaggedErrorClass()("DestructiveConfirmationRequiredError", { message: String$1 }) {};
 var InvalidFlagCombinationError = class extends TaggedErrorClass()("InvalidFlagCombinationError", { message: String$1 }) {};
+var InvalidAskTimeoutError = class extends TaggedErrorClass()("InvalidAskTimeoutError", {
+	message: String$1,
+	value: String$1
+}) {};
+var AskThreadArchivedError = class extends TaggedErrorClass()("AskThreadArchivedError", {
+	message: String$1,
+	threadId: String$1
+}) {};
+var AskThreadBusyError = class extends TaggedErrorClass()("AskThreadBusyError", {
+	message: String$1,
+	threadId: String$1
+}) {};
+var AskThreadPendingRequestError = class extends TaggedErrorClass()("AskThreadPendingRequestError", {
+	message: String$1,
+	threadId: String$1
+}) {};
+var AskProjectMismatchError = class extends TaggedErrorClass()("AskProjectMismatchError", {
+	message: String$1,
+	threadId: String$1,
+	projectId: String$1
+}) {};
+var AskNoAnswerError = class extends TaggedErrorClass()("AskNoAnswerError", {
+	message: String$1,
+	threadId: String$1
+}) {};
+var AskTimeoutError = class extends TaggedErrorClass()("AskTimeoutError", {
+	message: String$1,
+	timeout: 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 }) {};
+var InvalidSnoozeUntilError = class extends TaggedErrorClass()("InvalidSnoozeUntilError", {
+	message: String$1,
+	value: String$1
+}) {};
+var UnavailableSnoozePresetError = class extends TaggedErrorClass()("UnavailableSnoozePresetError", {
+	message: String$1,
+	preset: String$1
+}) {};
 const extraArgsConfig = { extraArgs: string("extra").pipe(variadic(), mapEffect((extra) => extra.length === 0 ? void_ : fail(new InvalidValue({
 	option: "extra",
 	value: extra[0] ?? "",
@@ -87116,6 +87153,719 @@ function buildUpdatePatch(input) {
 	});
 }
 //#endregion
+//#region src/cli/format/thread.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 sections = [formatRecord([
+		{
+			field: "title",
+			value: thread.title
+		},
+		{
+			field: "id",
+			value: thread.id
+		},
+		{
+			field: "project",
+			value: thread.projectId
+		},
+		{
+			field: "status",
+			value: thread.status
+		},
+		{
+			field: "model",
+			value: `${thread.modelSelection.instanceId}/${thread.modelSelection.model}`
+		},
+		{
+			field: "runtime",
+			value: thread.runtimeMode
+		},
+		{
+			field: "interaction",
+			value: thread.interactionMode
+		},
+		...thread.branch !== null ? [{
+			field: "branch",
+			value: thread.branch
+		}] : [],
+		...thread.worktreePath !== null ? [{
+			field: "worktree",
+			value: thread.worktreePath
+		}] : [],
+		...thread.archivedAt !== null ? [{
+			field: "archived",
+			value: thread.archivedAt
+		}] : [],
+		{
+			field: "messages",
+			value: String(thread.messageCount)
+		},
+		{
+			field: "updated",
+			value: thread.updatedAt
+		}
+	])];
+	if (thread.pendingApprovals.length > 0) sections.push(`\npending approvals\n${formatTable([
+		{
+			header: "request",
+			value: (approval) => approval.requestId,
+			maxWidth: 40
+		},
+		{
+			header: "kind",
+			value: (approval) => approval.requestKind,
+			maxWidth: 16
+		},
+		{
+			header: "created",
+			value: (approval) => approval.createdAt,
+			maxWidth: 28
+		},
+		{
+			header: "detail",
+			value: (approval) => approval.detail ?? "-",
+			maxWidth: 72
+		}
+	], thread.pendingApprovals)}`);
+	if (thread.pendingUserInputs.length > 0) sections.push(`\npending user inputs\n${formatTable([
+		{
+			header: "request",
+			value: (input) => input.requestId,
+			maxWidth: 40
+		},
+		{
+			header: "questions",
+			value: (input) => String(input.questions.length),
+			maxWidth: 9
+		},
+		{
+			header: "created",
+			value: (input) => input.createdAt,
+			maxWidth: 28
+		},
+		{
+			header: "prompt",
+			value: (input) => input.questions.map((question) => question.question).join("\n"),
+			maxWidth: 72
+		}
+	], thread.pendingUserInputs)}`);
+	return `${sections.join("\n")}\n`;
+}
+function formatThreadsHuman(threads) {
+	if (threads.length === 0) return "no threads\n";
+	return `${formatTable([
+		{
+			header: "title",
+			value: (thread) => thread.title,
+			maxWidth: 36
+		},
+		{
+			header: "id",
+			value: (thread) => thread.id,
+			maxWidth: 40
+		},
+		{
+			header: "status",
+			value: (thread) => threadStatus(thread),
+			maxWidth: 18
+		},
+		{
+			header: "updated",
+			value: (thread) => thread.updatedAt,
+			maxWidth: 28
+		},
+		{
+			header: "flags",
+			value: formatThreadFlags,
+			maxWidth: 34
+		}
+	], threads)}\n`;
+}
+function formatThreadSearchHuman(matches) {
+	if (matches.length === 0) return "no matches\n";
+	return `${matches.map((match) => formatRecord([
+		{
+			field: "thread",
+			value: match.threadTitle ?? "-"
+		},
+		{
+			field: "thread id",
+			value: match.threadId
+		},
+		{
+			field: "project",
+			value: match.projectTitle ?? "-"
+		},
+		{
+			field: "project id",
+			value: match.projectId
+		},
+		{
+			field: "workspace",
+			value: match.workspaceRoot ?? "-"
+		},
+		{
+			field: "branch",
+			value: match.branch ?? "-"
+		},
+		{
+			field: "worktree",
+			value: match.worktreePath ?? "-"
+		},
+		{
+			field: "source",
+			value: match.source
+		},
+		{
+			field: "created",
+			value: match.messageCreatedAt ?? "-"
+		},
+		{
+			field: "snippet",
+			value: match.snippet
+		}
+	])).join("\n\n")}\n`;
+}
+function formatThreadDeletedHuman(input) {
+	return `thread deleted: ${input.threadId} (sequence ${input.dispatch.sequence})`;
+}
+function formatThreadStartedHuman(input) {
+	return `thread started\n${formatRecord([
+		{
+			field: "title",
+			value: input.thread.title
+		},
+		{
+			field: "id",
+			value: input.thread.id
+		},
+		{
+			field: "status",
+			value: threadStatus(input.thread)
+		},
+		{
+			field: "sequence",
+			value: String(input.sequence)
+		}
+	])}`;
+}
+function formatThreadMessagesHuman(snapshot, limit) {
+	const transcript = formatChatTranscript(limit === 0 ? snapshot.thread.messages : snapshot.thread.messages.slice(-limit));
+	return snapshot.page?.hasMore === true && snapshot.page.beforeCursor !== null ? `${transcript}\nearlier turns available\nbefore cursor: ${snapshot.page.beforeCursor}\n` : transcript;
+}
+function formatWaitDoneHuman(thread) {
+	const latest = latestAssistantMessage(thread);
+	return `status: ${threadStatus(thread)}\n${latest !== void 0 ? `\n${formatChatTranscript([latest])}` : ""}`;
+}
+function formatThreadMessagesJson(snapshot, full) {
+	return full ? {
+		...snapshot,
+		page: snapshot.page ?? null
+	} : {
+		snapshotSequence: snapshot.snapshotSequence,
+		thread: stripThreadMessages(snapshot.thread),
+		messages: snapshot.thread.messages,
+		page: snapshot.page ?? null
+	};
+}
+function formatWaitEventNdjson(event) {
+	if (event.type !== "thread" && event.type !== "done") return event;
+	const compactThread = stripThreadHeavy(event.thread);
+	return event.type === "done" ? {
+		type: "done",
+		thread: compactThread,
+		latestAssistantMessage: latestAssistantMessage(event.thread) ?? null
+	} : {
+		type: "thread",
+		thread: compactThread,
+		messageCount: event.thread.messages.length
+	};
+}
+function stripThreadMessages(thread) {
+	const { messages: _messages, ...rest } = thread;
+	return rest;
+}
+function formatThreadFlags(thread) {
+	const flags = [
+		thread.archivedAt !== null ? "archived" : null,
+		thread.hasPendingApprovals ? "approval" : null,
+		thread.hasPendingUserInput ? "input" : null,
+		thread.hasActionableProposedPlan ? "plan" : null
+	].filter((flag) => flag !== null);
+	return flags.length > 0 ? flags.join(", ") : "-";
+}
+function stripThreadHeavy(thread) {
+	const { messages: _messages, activities: _activities, proposedPlans: _proposedPlans, checkpoints: _checkpoints, ...rest } = thread;
+	return rest;
+}
+//#endregion
+//#region src/cli/ask-lifecycle.ts
+const archivePolicyChoices = [
+	"never",
+	"always",
+	"on-success",
+	"on-failure"
+];
+function resolveAskFormat(format, cliRuntime, t3CliEnv) {
+	if (format !== "auto") return format;
+	return isInteractiveHumanTerminal(cliRuntime, t3CliEnv) ? "human" : "json";
+}
+function ensureAskTargetAvailable(thread) {
+	if (thread.archivedAt !== null) return fail(new AskThreadArchivedError({
+		message: `thread is archived: ${thread.id}`,
+		threadId: thread.id
+	}));
+	if (thread.hasPendingApprovals || thread.hasPendingUserInput) return fail(new AskThreadPendingRequestError({
+		message: `thread has a pending approval or user-input request: ${thread.id}`,
+		threadId: thread.id
+	}));
+	return void_;
+}
+function waitForAskThread(application, output, input) {
+	let lastStatus = "";
+	let turnComplete = false;
+	const observeAskThread = (thread) => {
+		const observation = inspectAskTurn(thread, input.messageId, input.state.askTurnId);
+		input.state.askTurnId = observation.turnId;
+		if (observation.status === "failed") return fail(new ThreadSessionError({
+			threadId: input.threadId,
+			message: observation.message
+		}));
+		turnComplete = observation.status === "complete";
+		return void_;
+	};
+	return gen(function* () {
+		if (input.format === "human") yield* output.writeStderr(`waiting for ${input.threadId}...\n`);
+		const event = getOrUndefined(yield* application.watchThread(input.threadId).pipe(tap((event) => gen(function* () {
+			if (event.type === "thread" || event.type === "done") yield* observeAskThread(event.thread);
+			else if (event.type === "status") {
+				const thread = (yield* application.getThreadMessages({ threadId: input.threadId })).thread;
+				yield* observeAskThread(thread);
+				if (!turnComplete) yield* ensureNoPendingRequest({
+					id: thread.id,
+					hasPendingApprovals: derivePendingApprovals(thread.activities).length > 0,
+					hasPendingUserInput: derivePendingUserInputs(thread.activities).length > 0
+				});
+			}
+			if (input.format === "ndjson") {
+				yield* output.printNdjson(formatWaitEventNdjson(event));
+				return;
+			}
+			if (input.format === "human" && event.type === "status" && event.status !== lastStatus) {
+				lastStatus = event.status;
+				yield* output.writeStderr(`${input.threadId}: ${event.status}\n`);
+			}
+		})), takeUntil((event) => turnComplete || event.type === "done"), runLast));
+		if (!turnComplete && event?.type !== "done") return yield* fail(new ThreadSessionError({
+			message: `thread wait ended without a terminal event: ${input.threadId}`,
+			threadId: input.threadId
+		}));
+		return yield* void_;
+	});
+}
+function selectAskAnswer(thread, messageId, turnId) {
+	const userIndex = thread.messages.findIndex((message) => message.id === messageId && message.role === "user");
+	if (userIndex === -1) return;
+	const following = thread.messages.slice(userIndex + 1);
+	const nextUserIndex = following.findIndex((message) => message.role === "user");
+	return (nextUserIndex === -1 ? following : following.slice(0, nextUserIndex)).filter((message) => message.role === "assistant" && !message.streaming && message.text.trim().length > 0 && (turnId === null || message.turnId === turnId)).at(-1);
+}
+function inspectAskTurn(thread, messageId, knownTurnId) {
+	const userIndex = thread.messages.findIndex((message) => message.id === messageId && message.role === "user");
+	const userMessage = userIndex === -1 ? void 0 : thread.messages[userIndex];
+	if (userMessage === void 0) return {
+		status: "waiting",
+		turnId: knownTurnId
+	};
+	const following = thread.messages.slice(userIndex + 1);
+	const nextUserIndex = following.findIndex((message) => message.role === "user");
+	const messageTurnId = (nextUserIndex === -1 ? following : following.slice(0, nextUserIndex)).findLast((message) => message.role === "assistant" && message.turnId !== null)?.turnId ?? null;
+	const latestTurn = thread.latestTurn;
+	const requestedTurnId = latestTurn?.requestedAt === userMessage.createdAt ? latestTurn.turnId : null;
+	const turnId = knownTurnId ?? requestedTurnId ?? messageTurnId ?? thread.session?.activeTurnId ?? null;
+	if (turnId === null) return {
+		status: nextUserIndex === -1 ? "waiting" : "complete",
+		turnId
+	};
+	const askIsLatest = latestTurn?.turnId === turnId;
+	if (askIsLatest && (latestTurn.state === "error" || thread.session?.status === "error")) return {
+		status: "failed",
+		turnId,
+		message: thread.session?.lastError ?? "thread ended with error"
+	};
+	const sessionRunning = thread.session?.status === "starting" || thread.session?.status === "running";
+	return {
+		status: nextUserIndex !== -1 || askIsLatest && (latestTurn.state !== "running" || thread.session?.activeTurnId !== turnId && !sessionRunning) ? "complete" : "waiting",
+		turnId
+	};
+}
+function finalizeArchive(application, output, state, succeeded) {
+	if (state.archiveResult !== void 0) return succeed(state.archiveResult);
+	const shouldArchive = state.archivePolicy === "always" || state.archivePolicy === "on-success" && succeeded || state.archivePolicy === "on-failure" && !succeeded;
+	if (!state.createdThread && !state.dispatched || state.threadId === void 0 || !shouldArchive) {
+		const result = {
+			policy: state.archivePolicy,
+			status: "skipped"
+		};
+		state.archiveResult = result;
+		return succeed(result);
+	}
+	const threadId = state.threadId;
+	return application.archiveThread(threadId).pipe(matchEffect({
+		onFailure: (error) => gen(function* () {
+			const result = {
+				policy: state.archivePolicy,
+				status: "failed",
+				error: error.message
+			};
+			state.archiveResult = result;
+			yield* output.writeStderr(`warning: failed to archive thread ${threadId}: ${error.message}\n`).pipe(ignore);
+			return result;
+		}),
+		onSuccess: (dispatch) => {
+			const result = {
+				policy: state.archivePolicy,
+				status: "archived",
+				sequence: dispatch.sequence
+			};
+			state.archiveResult = result;
+			return succeed(result);
+		}
+	}));
+}
+function cleanupInterruptedAsk(application, output, state) {
+	if (state.threadId === void 0) return void_;
+	const threadId = state.threadId;
+	return gen(function* () {
+		if (state.dispatched && state.askTurnId !== null) yield* application.interruptThreadTurn(threadId, state.askTurnId).pipe(matchEffect({
+			onFailure: (error) => output.writeStderr(`warning: failed to interrupt thread ${threadId}: ${error.message}\n`).pipe(ignore),
+			onSuccess: () => void_
+		}));
+		yield* finalizeArchive(application, output, state, false);
+	}).pipe(asVoid);
+}
+function ensureTrailingNewline(text) {
+	return text.endsWith("\n") ? text : `${text}\n`;
+}
+function ensureNoPendingRequest(thread) {
+	if (!thread.hasPendingApprovals && !thread.hasPendingUserInput) return void_;
+	return fail(new AskThreadPendingRequestError({
+		message: `thread requested approval or user input instead of answering: ${thread.id}`,
+		threadId: thread.id
+	}));
+}
+//#endregion
+//#region src/cli/input/service.ts
+var T3Input = class extends Service()("t3cli/T3Input") {};
+//#endregion
+//#region src/cli/interaction/self-action.ts
+const requireSelfActionConfirmation = fn("requireSelfActionConfirmation")(function* (input) {
+	if (input.force) return;
+	if (!isAgentEnvironment(input.t3CliEnv)) return;
+	const callerThreadId = input.t3CliEnv.scope.t3codeThreadId;
+	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/message-input.ts
+function readInitialMessage(input) {
+	if (input.message !== void 0 && input.message.length > 0 && input.fromStdin) return fail(new MessageInputError({ message: "pass message argument or --stdin, not both" }));
+	if (input.fromStdin) return input.readStdin();
+	if (input.message === void 0 || input.message.length === 0) return fail(new MessageInputError({ message: "message required unless --stdin is used" }));
+	return succeed(input.message);
+}
+function readJsonAnswers(input) {
+	if (input.answers !== void 0 && input.answers.length > 0 && input.fromStdin) return fail(new MessageInputError({ message: "pass --answers or --stdin, not both" }));
+	if (input.fromStdin) return input.readStdin().pipe(flatMap(parseJsonAnswers));
+	if (input.answers === void 0 || input.answers.length === 0) return fail(new MessageInputError({ message: "answers required unless --stdin is used" }));
+	return parseJsonAnswers(input.answers);
+}
+function parseJsonAnswers(text) {
+	try {
+		const parsed = JSON.parse(text);
+		return succeed(decodeUnknownSync(ProviderUserInputAnswers)(parsed));
+	} catch {
+		return fail(new MessageInputError({ message: "invalid JSON in answers" }));
+	}
+}
+//#endregion
+//#region src/cli/model-options.ts
+function buildModelOptions(input) {
+	const options = /* @__PURE__ */ new Map();
+	const optionRecord = getOrUndefined(input.option);
+	if (optionRecord !== void 0) for (const [id, value] of Object.entries(optionRecord)) options.set(id, {
+		id,
+		value: parseModelOptionValue(value)
+	});
+	setStringOption(options, "reasoningEffort", getOrUndefined(input.reasoningEffort));
+	setStringOption(options, "effort", getOrUndefined(input.effort));
+	setBooleanOption(options, "fastMode", getOrUndefined(input.fastMode));
+	setBooleanOption(options, "thinking", getOrUndefined(input.thinking));
+	return [...options.values()];
+}
+function parseModelOptionValue(value) {
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "true") return true;
+	if (normalized === "false") return false;
+	return value;
+}
+function setStringOption(options, id, value) {
+	if (value !== void 0 && value.length > 0) options.set(id, {
+		id,
+		value
+	});
+}
+function setBooleanOption(options, id, value) {
+	if (value !== void 0) options.set(id, {
+		id,
+		value
+	});
+}
+//#endregion
+//#region src/cli/ask.ts
+const askThreadFlag = string$2("thread").pipe(withDescription$1("Existing thread id; T3CODE_THREAD_ID is not used"), optional$2);
+const archivePolicyFlag = choice("archive", archivePolicyChoices).pipe(withDescription$1("Archive policy (default: on-success for created threads, never for existing threads)"), optional$2);
+const timeoutFlag = string$2("timeout").pipe(withDescription$1("Response timeout, such as 30s, 5m, or 1h"), optional$2);
+const askFormatFlag = choice("format", humanJsonNdjsonFormatChoices).pipe(withDefault("human"));
+const askCommand = make("ask", {
+	project: projectFlag,
+	thread: askThreadFlag,
+	force: selfActionForceFlag,
+	message: string("message").pipe(optional),
+	stdin: boolean("stdin"),
+	title: string$2("title").pipe(optional$2),
+	worktree: worktreeFlag,
+	provider: string$2("provider").pipe(optional$2),
+	model: string$2("model").pipe(optional$2),
+	...modelFlags,
+	archive: archivePolicyFlag,
+	timeout: timeoutFlag,
+	format: askFormatFlag,
+	...extraArgsConfig
+}, ({ project, thread, force, message, stdin, title, worktree, provider, model, option, reasoningEffort, effort, fastMode, thinking, archive, timeout, format: format$1 }) => gen(function* () {
+	const explicitThreadId = getOrUndefined(thread);
+	const created = explicitThreadId === void 0;
+	const titleValue = getOrUndefined(title);
+	const providerValue = getOrUndefined(provider);
+	const modelValue = getOrUndefined(model);
+	const createOnlyFlags = [
+		isSome(title) ? "--title" : null,
+		isSome(worktree) ? "--worktree" : null,
+		isSome(provider) ? "--provider" : null,
+		isSome(model) ? "--model" : null
+	].filter((flag) => flag !== null);
+	if (!created && createOnlyFlags.length > 0) return yield* fail(new InvalidFlagCombinationError({ message: `${createOnlyFlags.join(", ")} cannot be used with --thread` }));
+	if (created && force) return yield* fail(new InvalidFlagCombinationError({ message: "--force can only be used with --thread" }));
+	const timeoutValue = getOrUndefined(timeout);
+	const timeoutDuration = timeoutValue === void 0 ? void 0 : yield* parseAskTimeout(timeoutValue);
+	const archivePolicy = getOrElse(archive, () => created ? "on-success" : "never");
+	const application = yield* T3Application;
+	const cliRuntime = yield* CliRuntime;
+	const t3CliEnv = yield* loadT3CliEnv;
+	const input = yield* T3Input;
+	const output = yield* T3Output;
+	const resolvedFormat = resolveAskFormat(format$1, cliRuntime, t3CliEnv);
+	const options = buildModelOptions({
+		option,
+		reasoningEffort,
+		effort,
+		fastMode,
+		thinking
+	});
+	const state = {
+		archivePolicy,
+		threadId: explicitThreadId,
+		createdThread: false,
+		dispatched: false,
+		askTurnId: null,
+		archiveResult: void 0
+	};
+	const responseWithCleanup = gen(function* () {
+		const text = yield* readInitialMessage({
+			message: getOrUndefined(message),
+			fromStdin: stdin,
+			readStdin: input.readStdin
+		});
+		let dispatch;
+		let askMessageId;
+		if (explicitThreadId === void 0) {
+			const projectRef = yield* requireCommandProjectRef({ project });
+			const resolvedProject = yield* application.resolveProject(projectRef);
+			const worktreePath = resolveWorktreePath({
+				value: getOrUndefined(worktree),
+				scope: t3CliEnv.scope
+			});
+			const result = yield* application.startThread({
+				message: text,
+				projectRef: resolvedProject.id,
+				...titleValue !== void 0 ? { title: titleValue } : {},
+				...worktreePath !== void 0 ? { worktreePath } : {},
+				...providerValue !== void 0 ? { provider: providerValue } : {},
+				...modelValue !== void 0 ? { model: modelValue } : {},
+				...options.length > 0 ? { options } : {}
+			}, {
+				until: "dispatch",
+				onThreadCreated: (threadId) => sync(() => {
+					state.threadId = threadId;
+					state.createdThread = true;
+				})
+			});
+			state.dispatched = true;
+			dispatch = result.dispatch;
+			askMessageId = result.messageId;
+		} else {
+			const summary = yield* application.getThreadSummary(explicitThreadId);
+			yield* ensureAskTargetAvailable(summary);
+			const projectRef = getOrUndefined(project);
+			if (projectRef !== void 0) {
+				const resolvedProject = yield* application.resolveProject(projectRef);
+				if (summary.projectId !== resolvedProject.id) return yield* fail(new AskProjectMismatchError({
+					message: `thread ${explicitThreadId} belongs to project ${summary.projectId}, not ${resolvedProject.id}`,
+					threadId: explicitThreadId,
+					projectId: resolvedProject.id
+				}));
+			}
+			yield* requireSelfActionConfirmation({
+				threadId: explicitThreadId,
+				force,
+				cliRuntime,
+				t3CliEnv,
+				action: "ask"
+			});
+			const targetThread = (yield* application.getThreadMessages({ threadId: explicitThreadId })).thread;
+			if (isThreadActive(targetThread)) return yield* fail(new AskThreadBusyError({
+				message: `thread is busy: ${explicitThreadId}`,
+				threadId: explicitThreadId
+			}));
+			const result = yield* application.sendThread({
+				threadId: explicitThreadId,
+				message: text,
+				...options.length > 0 ? { options } : {}
+			}, { until: "dispatch" });
+			state.dispatched = true;
+			dispatch = result.dispatch;
+			askMessageId = result.messageId;
+		}
+		const threadId = state.threadId;
+		if (threadId === void 0) return yield* fail(new AskNoAnswerError({
+			message: "ask did not resolve a thread id",
+			threadId: "unknown"
+		}));
+		if (resolvedFormat === "ndjson") yield* output.printNdjson({
+			type: "dispatch",
+			sequence: dispatch.sequence
+		});
+		yield* application.awaitShellSequence(dispatch.sequence);
+		yield* waitForAskThread(application, output, {
+			threadId,
+			format: resolvedFormat,
+			messageId: askMessageId,
+			state
+		});
+		const finalSnapshot = yield* application.getThreadMessages({ threadId });
+		const observation = inspectAskTurn(finalSnapshot.thread, askMessageId, state.askTurnId);
+		if (observation.status === "failed") return yield* fail(new ThreadSessionError({
+			threadId,
+			message: observation.message
+		}));
+		const answer = selectAskAnswer(finalSnapshot.thread, askMessageId, observation.turnId);
+		if (answer === void 0) return yield* fail(new AskNoAnswerError({
+			message: `thread completed without a new final answer: ${threadId}`,
+			threadId
+		}));
+		return {
+			answer: answer.text,
+			threadId,
+			turnId: answer.turnId,
+			created,
+			dispatch
+		};
+	}).pipe(onInterrupt(() => cleanupInterruptedAsk(application, output, state)));
+	return yield* (timeoutDuration === void 0 ? responseWithCleanup : responseWithCleanup.pipe(timeoutOrElse({
+		duration: timeoutDuration,
+		orElse: () => fail(new AskTimeoutError({
+			message: `ask timed out after ${timeoutValue ?? format(timeoutDuration)}`,
+			timeout: timeoutValue ?? format(timeoutDuration)
+		}))
+	}))).pipe(matchEffect({
+		onFailure: (error) => finalizeArchive(application, output, state, false).pipe(flatMap(() => fail(error))),
+		onSuccess: (result) => gen(function* () {
+			const archiveResult = yield* finalizeArchive(application, output, state, true);
+			const formatted = {
+				answer: result.answer,
+				threadId: result.threadId,
+				turnId: result.turnId,
+				created: result.created,
+				dispatch: result.dispatch,
+				archive: archiveResult
+			};
+			if (resolvedFormat === "json") return yield* output.printJson(formatted);
+			if (resolvedFormat === "ndjson") return yield* output.printNdjson({
+				type: "result",
+				...formatted
+			});
+			return yield* output.writeStdout(ensureTrailingNewline(result.answer));
+		})
+	}));
+})).pipe(withDescription("ask a project or existing thread and wait for one answer"));
+function parseAskTimeout(value) {
+	const trimmed = value.trim();
+	const shorthand = /^([0-9]+(?:\.[0-9]+)?)(ms|s|m|h|d|w)$/.exec(trimmed);
+	let input = trimmed;
+	if (shorthand !== null) {
+		const amount = shorthand[1];
+		const unit = shorthand[2];
+		const expandedUnit = unit === void 0 ? void 0 : {
+			ms: "millis",
+			s: "seconds",
+			m: "minutes",
+			h: "hours",
+			d: "days",
+			w: "weeks"
+		}[unit];
+		if (amount !== void 0 && expandedUnit !== void 0) input = `${amount} ${expandedUnit}`;
+	}
+	const parsed = decodeUnknownOption(DurationFromString)(input);
+	if (isNone(parsed)) return fail(new InvalidAskTimeoutError({
+		message: `invalid timeout: ${value}`,
+		value
+	}));
+	const millis = toMillis(parsed.value);
+	if (!Number.isFinite(millis) || millis <= 0) return fail(new InvalidAskTimeoutError({
+		message: `timeout must be a positive finite duration: ${value}`,
+		value
+	}));
+	return succeed(parsed.value);
+}
+//#endregion
 //#region src/cli/format/auth.ts
 function formatAuthPaired(result) {
 	return `paired\n${formatRecord([
@@ -87775,9 +88525,6 @@ function formatWaitHuman(input) {
 	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,
@@ -88038,270 +88785,6 @@ const addCommand = make("add", {
 	else yield* output.printInfo(formatProjectAddedHuman(result.project));
 })).pipe(withDescription("add project"));
 //#endregion
-//#region src/cli/format/thread.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 sections = [formatRecord([
-		{
-			field: "title",
-			value: thread.title
-		},
-		{
-			field: "id",
-			value: thread.id
-		},
-		{
-			field: "project",
-			value: thread.projectId
-		},
-		{
-			field: "status",
-			value: thread.status
-		},
-		{
-			field: "model",
-			value: `${thread.modelSelection.instanceId}/${thread.modelSelection.model}`
-		},
-		{
-			field: "runtime",
-			value: thread.runtimeMode
-		},
-		{
-			field: "interaction",
-			value: thread.interactionMode
-		},
-		...thread.branch !== null ? [{
-			field: "branch",
-			value: thread.branch
-		}] : [],
-		...thread.worktreePath !== null ? [{
-			field: "worktree",
-			value: thread.worktreePath
-		}] : [],
-		...thread.archivedAt !== null ? [{
-			field: "archived",
-			value: thread.archivedAt
-		}] : [],
-		{
-			field: "messages",
-			value: String(thread.messageCount)
-		},
-		{
-			field: "updated",
-			value: thread.updatedAt
-		}
-	])];
-	if (thread.pendingApprovals.length > 0) sections.push(`\npending approvals\n${formatTable([
-		{
-			header: "request",
-			value: (approval) => approval.requestId,
-			maxWidth: 40
-		},
-		{
-			header: "kind",
-			value: (approval) => approval.requestKind,
-			maxWidth: 16
-		},
-		{
-			header: "created",
-			value: (approval) => approval.createdAt,
-			maxWidth: 28
-		},
-		{
-			header: "detail",
-			value: (approval) => approval.detail ?? "-",
-			maxWidth: 72
-		}
-	], thread.pendingApprovals)}`);
-	if (thread.pendingUserInputs.length > 0) sections.push(`\npending user inputs\n${formatTable([
-		{
-			header: "request",
-			value: (input) => input.requestId,
-			maxWidth: 40
-		},
-		{
-			header: "questions",
-			value: (input) => String(input.questions.length),
-			maxWidth: 9
-		},
-		{
-			header: "created",
-			value: (input) => input.createdAt,
-			maxWidth: 28
-		},
-		{
-			header: "prompt",
-			value: (input) => input.questions.map((question) => question.question).join("\n"),
-			maxWidth: 72
-		}
-	], thread.pendingUserInputs)}`);
-	return `${sections.join("\n")}\n`;
-}
-function formatThreadsHuman(threads) {
-	if (threads.length === 0) return "no threads\n";
-	return `${formatTable([
-		{
-			header: "title",
-			value: (thread) => thread.title,
-			maxWidth: 36
-		},
-		{
-			header: "id",
-			value: (thread) => thread.id,
-			maxWidth: 40
-		},
-		{
-			header: "status",
-			value: (thread) => threadStatus(thread),
-			maxWidth: 18
-		},
-		{
-			header: "updated",
-			value: (thread) => thread.updatedAt,
-			maxWidth: 28
-		},
-		{
-			header: "flags",
-			value: formatThreadFlags,
-			maxWidth: 34
-		}
-	], threads)}\n`;
-}
-function formatThreadSearchHuman(matches) {
-	if (matches.length === 0) return "no matches\n";
-	return `${matches.map((match) => formatRecord([
-		{
-			field: "thread",
-			value: match.threadTitle ?? "-"
-		},
-		{
-			field: "thread id",
-			value: match.threadId
-		},
-		{
-			field: "project",
-			value: match.projectTitle ?? "-"
-		},
-		{
-			field: "project id",
-			value: match.projectId
-		},
-		{
-			field: "workspace",
-			value: match.workspaceRoot ?? "-"
-		},
-		{
-			field: "branch",
-			value: match.branch ?? "-"
-		},
-		{
-			field: "worktree",
-			value: match.worktreePath ?? "-"
-		},
-		{
-			field: "source",
-			value: match.source
-		},
-		{
-			field: "created",
-			value: match.messageCreatedAt ?? "-"
-		},
-		{
-			field: "snippet",
-			value: match.snippet
-		}
-	])).join("\n\n")}\n`;
-}
-function formatThreadDeletedHuman(input) {
-	return `thread deleted: ${input.threadId} (sequence ${input.dispatch.sequence})`;
-}
-function formatThreadStartedHuman(input) {
-	return `thread started\n${formatRecord([
-		{
-			field: "title",
-			value: input.thread.title
-		},
-		{
-			field: "id",
-			value: input.thread.id
-		},
-		{
-			field: "status",
-			value: threadStatus(input.thread)
-		},
-		{
-			field: "sequence",
-			value: String(input.sequence)
-		}
-	])}`;
-}
-function formatThreadMessagesHuman(thread, limit) {
-	return formatChatTranscript(limit === 0 ? thread.messages : thread.messages.slice(-limit));
-}
-function formatWaitDoneHuman(thread) {
-	const latest = latestAssistantMessage(thread);
-	return `status: ${threadStatus(thread)}\n${latest !== void 0 ? `\n${formatChatTranscript([latest])}` : ""}`;
-}
-function formatThreadMessagesJson(thread, full) {
-	return full ? thread : {
-		thread: stripThreadMessages(thread),
-		messages: thread.messages
-	};
-}
-function formatWaitEventNdjson(event) {
-	if (event.type !== "thread" && event.type !== "done") return event;
-	const compactThread = stripThreadHeavy(event.thread);
-	return event.type === "done" ? {
-		type: "done",
-		thread: compactThread,
-		latestAssistantMessage: latestAssistantMessage(event.thread) ?? null
-	} : {
-		type: "thread",
-		thread: compactThread,
-		messageCount: event.thread.messages.length
-	};
-}
-function stripThreadMessages(thread) {
-	const { messages: _messages, ...rest } = thread;
-	return rest;
-}
-function formatThreadFlags(thread) {
-	const flags = [
-		thread.archivedAt !== null ? "archived" : null,
-		thread.hasPendingApprovals ? "approval" : null,
-		thread.hasPendingUserInput ? "input" : null,
-		thread.hasActionableProposedPlan ? "plan" : null
-	].filter((flag) => flag !== null);
-	return flags.length > 0 ? flags.join(", ") : "-";
-}
-function stripThreadHeavy(thread) {
-	const { messages: _messages, activities: _activities, proposedPlans: _proposedPlans, checkpoints: _checkpoints, ...rest } = thread;
-	return rest;
-}
-//#endregion
 //#region src/cli/search.ts
 const searchThreadsCommand = make("search", {
 	query: string("query"),
@@ -88361,19 +88844,6 @@ const approveThreadCommand = make("approve", {
 	return yield* output.printInfo(`approval submitted: ${result.requestId} (sequence ${result.dispatch.sequence})`);
 })).pipe(withDescription("respond to a pending approval request"));
 //#endregion
-//#region src/cli/interaction/self-action.ts
-const requireSelfActionConfirmation = fn("requireSelfActionConfirmation")(function* (input) {
-	if (input.force) return;
-	if (!isAgentEnvironment(input.t3CliEnv)) return;
-	const callerThreadId = input.t3CliEnv.scope.t3codeThreadId;
-	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,
@@ -88525,27 +88995,26 @@ const interruptThreadCommand = make("interrupt", {
 	return yield* output.printInfo(`thread interrupted: ${threadId} (sequence ${dispatch.sequence})`);
 })).pipe(withDescription("interrupt running thread turn"));
 //#endregion
-//#region src/cli/message-input.ts
-function readInitialMessage(input) {
-	if (input.message !== void 0 && input.message.length > 0 && input.fromStdin) return fail(new MessageInputError({ message: "pass message argument or --stdin, not both" }));
-	if (input.fromStdin) return input.readStdin();
-	if (input.message === void 0 || input.message.length === 0) return fail(new MessageInputError({ message: "message required unless --stdin is used" }));
-	return succeed(input.message);
-}
-function readJsonAnswers(input) {
-	if (input.answers !== void 0 && input.answers.length > 0 && input.fromStdin) return fail(new MessageInputError({ message: "pass --answers or --stdin, not both" }));
-	if (input.fromStdin) return input.readStdin().pipe(flatMap(parseJsonAnswers));
-	if (input.answers === void 0 || input.answers.length === 0) return fail(new MessageInputError({ message: "answers required unless --stdin is used" }));
-	return parseJsonAnswers(input.answers);
-}
-function parseJsonAnswers(text) {
-	try {
-		const parsed = JSON.parse(text);
-		return succeed(decodeUnknownSync(ProviderUserInputAnswers)(parsed));
-	} catch {
-		return fail(new MessageInputError({ message: "invalid JSON in answers" }));
-	}
-}
+//#region src/cli/threads/pin.ts
+const pinThreadCommand = make("pin", {
+	thread: threadFlag,
+	format: formatFlag,
+	...extraArgsConfig
+}, ({ thread, format }) => gen(function* () {
+	const application = yield* T3Application;
+	const cliRuntime = yield* CliRuntime;
+	const t3CliEnv = yield* loadT3CliEnv;
+	const output = yield* T3Output;
+	const threadId = resolveThreadId({
+		value: getOrUndefined(thread),
+		scope: t3CliEnv.scope
+	});
+	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, cliRuntime, t3CliEnv, "json");
+	const dispatch = yield* application.pinThread(threadId);
+	if (resolvedFormat === "json") return yield* output.printJson(dispatch);
+	return yield* output.printInfo(`thread pinned: ${threadId} (sequence ${dispatch.sequence})`);
+})).pipe(withDescription("pin thread"));
 const respondThreadCommand = make("respond", {
 	thread: threadFlag,
 	request: string$2("request").pipe(withDescription$1("Pending user-input request id"), optional$2),
@@ -88581,6 +89050,74 @@ const respondThreadCommand = make("respond", {
 	return yield* output.printInfo(`user input submitted: ${result.requestId} (sequence ${result.dispatch.sequence})`);
 })).pipe(withDescription("respond to a pending user-input request"));
 //#endregion
+//#region src/cli/threads/settle.ts
+const settleThreadCommand = make("settle", {
+	thread: threadFlag,
+	format: formatFlag,
+	...extraArgsConfig
+}, ({ thread, format }) => gen(function* () {
+	const application = yield* T3Application;
+	const cliRuntime = yield* CliRuntime;
+	const t3CliEnv = yield* loadT3CliEnv;
+	const output = yield* T3Output;
+	const threadId = resolveThreadId({
+		value: getOrUndefined(thread),
+		scope: t3CliEnv.scope
+	});
+	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, cliRuntime, t3CliEnv, "json");
+	const dispatch = yield* application.settleThread(threadId);
+	if (resolvedFormat === "json") return yield* output.printJson(dispatch);
+	return yield* output.printInfo(`thread settled: ${threadId} (sequence ${dispatch.sequence})`);
+})).pipe(withDescription("settle thread"));
+const snoozeThreadCommand = make("snooze", {
+	thread: threadFlag,
+	until: string$2("until").pipe(optional$2),
+	preset: choice("preset", [
+		"hour",
+		"evening",
+		"tomorrow",
+		"next-week"
+	]).pipe(optional$2),
+	format: formatFlag,
+	...extraArgsConfig
+}, ({ thread, until, preset, format }) => gen(function* () {
+	const application = yield* T3Application;
+	const cliRuntime = yield* CliRuntime;
+	const t3CliEnv = yield* loadT3CliEnv;
+	const output = yield* T3Output;
+	const threadId = resolveThreadId({
+		value: getOrUndefined(thread),
+		scope: t3CliEnv.scope
+	});
+	if (threadId === void 0) return yield* fail(new MissingThreadError({ message: "thread id is required: pass --thread or set T3CODE_THREAD_ID" }));
+	const untilValue = getOrUndefined(until);
+	const presetValue = getOrUndefined(preset);
+	if (untilValue !== void 0 && presetValue !== void 0) return yield* fail(new InvalidFlagCombinationError({ message: "exactly one of --until or --preset is required" }));
+	let snoozedUntil;
+	if (untilValue !== void 0) snoozedUntil = yield* decodeUnknownEffect(DateTimeUtcFromString)(untilValue).pipe(map(formatIso), mapError(() => new InvalidSnoozeUntilError({
+		message: `invalid ISO-8601 snooze time: ${untilValue}`,
+		value: untilValue
+	})));
+	else if (presetValue !== void 0) snoozedUntil = yield* resolveSnoozePreset(presetValue);
+	else return yield* fail(new InvalidFlagCombinationError({ message: "exactly one of --until or --preset is required" }));
+	const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+	const dispatch = yield* application.snoozeThread({
+		threadId,
+		snoozedUntil
+	});
+	if (resolvedFormat === "json") return yield* output.printJson(dispatch);
+	return yield* output.printInfo(`thread snoozed: ${threadId} until ${snoozedUntil} (sequence ${dispatch.sequence})`);
+})).pipe(withDescription("snooze thread"));
+const resolveSnoozePreset = fn("resolveSnoozePreset")(function* (presetId) {
+	const preset = resolveSnoozePresets(yield* nowAsDate).find((candidate) => candidate.id === presetId);
+	if (preset === void 0) return yield* fail(new UnavailableSnoozePresetError({
+		message: `snooze preset is not available at this time: ${presetId}`,
+		preset: presetId
+	}));
+	return preset.snoozedUntil;
+});
+//#endregion
 //#region src/cli/threads/unarchive.ts
 const unarchiveThreadCommand = make("unarchive", {
 	thread: threadFlag,
@@ -88602,38 +89139,68 @@ const unarchiveThreadCommand = make("unarchive", {
 	return yield* output.printInfo(`thread unarchived: ${threadId} (sequence ${dispatch.sequence})`);
 })).pipe(withDescription("unarchive thread"));
 //#endregion
-//#region src/cli/model-options.ts
-function buildModelOptions(input) {
-	const options = /* @__PURE__ */ new Map();
-	const optionRecord = getOrUndefined(input.option);
-	if (optionRecord !== void 0) for (const [id, value] of Object.entries(optionRecord)) options.set(id, {
-		id,
-		value: parseModelOptionValue(value)
+//#region src/cli/threads/unpin.ts
+const unpinThreadCommand = make("unpin", {
+	thread: threadFlag,
+	format: formatFlag,
+	...extraArgsConfig
+}, ({ thread, format }) => gen(function* () {
+	const application = yield* T3Application;
+	const cliRuntime = yield* CliRuntime;
+	const t3CliEnv = yield* loadT3CliEnv;
+	const output = yield* T3Output;
+	const threadId = resolveThreadId({
+		value: getOrUndefined(thread),
+		scope: t3CliEnv.scope
 	});
-	setStringOption(options, "reasoningEffort", getOrUndefined(input.reasoningEffort));
-	setStringOption(options, "effort", getOrUndefined(input.effort));
-	setBooleanOption(options, "fastMode", getOrUndefined(input.fastMode));
-	setBooleanOption(options, "thinking", getOrUndefined(input.thinking));
-	return [...options.values()];
-}
-function parseModelOptionValue(value) {
-	const normalized = value.trim().toLowerCase();
-	if (normalized === "true") return true;
-	if (normalized === "false") return false;
-	return value;
-}
-function setStringOption(options, id, value) {
-	if (value !== void 0 && value.length > 0) options.set(id, {
-		id,
-		value
+	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, cliRuntime, t3CliEnv, "json");
+	const dispatch = yield* application.unpinThread(threadId);
+	if (resolvedFormat === "json") return yield* output.printJson(dispatch);
+	return yield* output.printInfo(`thread unpinned: ${threadId} (sequence ${dispatch.sequence})`);
+})).pipe(withDescription("unpin thread"));
+//#endregion
+//#region src/cli/threads/unsnooze.ts
+const unsnoozeThreadCommand = make("unsnooze", {
+	thread: threadFlag,
+	format: formatFlag,
+	...extraArgsConfig
+}, ({ thread, format }) => gen(function* () {
+	const application = yield* T3Application;
+	const cliRuntime = yield* CliRuntime;
+	const t3CliEnv = yield* loadT3CliEnv;
+	const output = yield* T3Output;
+	const threadId = resolveThreadId({
+		value: getOrUndefined(thread),
+		scope: t3CliEnv.scope
 	});
-}
-function setBooleanOption(options, id, value) {
-	if (value !== void 0) options.set(id, {
-		id,
-		value
+	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, cliRuntime, t3CliEnv, "json");
+	const dispatch = yield* application.unsnoozeThread(threadId);
+	if (resolvedFormat === "json") return yield* output.printJson(dispatch);
+	return yield* output.printInfo(`thread unsnoozed: ${threadId} (sequence ${dispatch.sequence})`);
+})).pipe(withDescription("unsnooze thread"));
+//#endregion
+//#region src/cli/threads/unsettle.ts
+const unsettleThreadCommand = make("unsettle", {
+	thread: threadFlag,
+	format: formatFlag,
+	...extraArgsConfig
+}, ({ thread, format }) => gen(function* () {
+	const application = yield* T3Application;
+	const cliRuntime = yield* CliRuntime;
+	const t3CliEnv = yield* loadT3CliEnv;
+	const output = yield* T3Output;
+	const threadId = resolveThreadId({
+		value: getOrUndefined(thread),
+		scope: t3CliEnv.scope
 	});
-}
+	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, cliRuntime, t3CliEnv, "json");
+	const dispatch = yield* application.unsettleThread(threadId);
+	if (resolvedFormat === "json") return yield* output.printJson(dispatch);
+	return yield* output.printInfo(`thread unsettled: ${threadId} (sequence ${dispatch.sequence})`);
+})).pipe(withDescription("unsettle thread"));
 //#endregion
 //#region src/cli/threads/update.ts
 const updateThreadCommand = make("update", {
@@ -88708,6 +89275,12 @@ function createThreadCommand() {
 		respondThreadCommand,
 		archiveThreadCommand,
 		interruptThreadCommand,
+		settleThreadCommand,
+		unsettleThreadCommand,
+		snoozeThreadCommand,
+		unsnoozeThreadCommand,
+		pinThreadCommand,
+		unpinThreadCommand,
 		unarchiveThreadCommand,
 		updateThreadCommand,
 		deleteThreadCommand,
@@ -88863,7 +89436,11 @@ const sendThreadCommand = make("send", {
 		return yield* void_;
 	}
 	const result = yield* application.sendThread(input, { until: "visible" });
-	if (resolvedFormat === "json") return yield* output.printJson(result);
+	if (resolvedFormat === "json") return yield* output.printJson({
+		dispatch: result.dispatch,
+		threadId: result.threadId,
+		thread: result.thread
+	});
 	return yield* output.printInfo(`message sent: ${result.threadId}`);
 })).pipe(withDescription("send message to existing thread"));
 //#endregion
@@ -88968,7 +89545,12 @@ const startThreadCommand = make("start", {
 		return;
 	}
 	const result = yield* application.startThread(input, { until: "visible" });
-	if (resolvedFormat === "json") yield* output.printJson(result);
+	if (resolvedFormat === "json") yield* output.printJson({
+		dispatch: result.dispatch,
+		project: result.project,
+		threadId: result.threadId,
+		thread: result.thread
+	});
 	else yield* output.printInfo(formatThreadStartedHuman({
 		thread: result.thread,
 		sequence: result.dispatch.sequence
@@ -88979,14 +89561,24 @@ const startThreadCommand = make("start", {
 const getThreadTranscriptCommand = make("transcript", {
 	thread: threadFlag,
 	limit: integer$1("limit").pipe(withDefault(20)),
+	turnLimit: integer$1("turn-limit").pipe(optional$2),
+	beforeCursor: string$2("before-cursor").pipe(optional$2),
+	all: boolean("all"),
 	full: boolean("full"),
 	format: formatFlag,
 	...extraArgsConfig
-}, ({ thread, limit, full, format }) => gen(function* () {
+}, ({ thread, limit, turnLimit, beforeCursor, all, full, format }) => gen(function* () {
 	if (limit < 0) return yield* fail(new InvalidLimitError({
 		message: `invalid limit: ${limit}`,
 		value: String(limit)
 	}));
+	const turnLimitValue = getOrUndefined(turnLimit);
+	const beforeCursorValue = getOrUndefined(beforeCursor);
+	if (turnLimitValue !== void 0 && turnLimitValue <= 0) return yield* fail(new InvalidLimitError({
+		message: `invalid turn limit: ${turnLimitValue}`,
+		value: String(turnLimitValue)
+	}));
+	if (all && (turnLimitValue !== void 0 || beforeCursorValue !== void 0)) return yield* fail(new InvalidFlagCombinationError({ message: "--all cannot be combined with --turn-limit or --before-cursor" }));
 	const application = yield* T3Application;
 	const cliRuntime = yield* CliRuntime;
 	const t3CliEnv = yield* loadT3CliEnv;
@@ -88997,7 +89589,13 @@ const getThreadTranscriptCommand = make("transcript", {
 	});
 	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, cliRuntime, t3CliEnv, "json");
-	const detail = yield* application.getThreadMessages(threadId);
+	const detail = yield* application.getThreadMessages({
+		threadId,
+		...!all ? { window: {
+			turnLimit: turnLimitValue ?? (beforeCursorValue === void 0 ? 10 : 20),
+			...beforeCursorValue !== void 0 ? { beforeCursor: beforeCursorValue } : {}
+		} } : {}
+	});
 	if (resolvedFormat === "json") return yield* output.printJson(formatThreadMessagesJson(detail, full));
 	return yield* output.writeStdout(formatThreadMessagesHuman(detail, limit));
 })).pipe(withDescription("get latest thread transcript"));
@@ -89028,6 +89626,7 @@ const waitForThreadCommand = make("wait", {
 function createCliCommand() {
 	return make("t3cli").pipe(withDescription("non-interactive cli for running t3code server"), withGlobalFlags([cliEnvironmentSetting]), withSubcommands([
 		createActionCommand(),
+		askCommand,
 		createAuthCommand(),
 		createEnvCommand(),
 		listThreadsCommand,
@@ -89175,7 +89774,7 @@ var T3Version = class extends Service()("t3cli/T3Version") {};
 //#endregion
 //#region src/version/layer.ts
 const PackageJsonSchema = fromJsonString(Struct({ version: String$1 }));
-const T3VersionBundledLive = sync$1(T3Version, () => ({ version: "0.14.2" }));
+const T3VersionBundledLive = sync$1(T3Version, () => ({ version: "0.15.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 };