t3code-cli 0.7.0 → 0.8.0

package/dist/auth.js

@@ -1,3 +1,3 @@
-import { a as makeT3AuthPairing, b as makeT3LocalAuthOrigin, c as T3LocalAuthLive, d as T3LocalAuthTokenLive, f as makeT3LocalAuthToken, i as T3AuthPairingLive, l as makeT3LocalAuth, n as makeT3Auth, o as parsePairingUrl, r as T3AuthPairing, s as T3LocalAuth, t as T3AuthLive, u as T3LocalAuthToken, v as T3LocalAuthOrigin, x as T3Auth, y as T3LocalAuthOriginLive } from "./layer-CfC5qZol.js";
-import { a as AuthLocalSigningError, i as AuthLocalSecretError, n as AuthLocalDatabaseError, o as AuthPairingUrlError, r as AuthLocalError, s as AuthTransportError, t as AuthConfigError } from "./error-jwMt3VoW.js";
+import { a as makeT3AuthPairing, b as makeT3LocalAuthOrigin, c as T3LocalAuthLive, d as T3LocalAuthTokenLive, f as makeT3LocalAuthToken, i as T3AuthPairingLive, l as makeT3LocalAuth, n as makeT3Auth, o as parsePairingUrl, r as T3AuthPairing, s as T3LocalAuth, t as T3AuthLive, u as T3LocalAuthToken, v as T3LocalAuthOrigin, x as T3Auth, y as T3LocalAuthOriginLive } from "./layer-Do8wK1t6.js";
+import { a as AuthLocalSigningError, i as AuthLocalSecretError, n as AuthLocalDatabaseError, o as AuthPairingUrlError, r as AuthLocalError, s as AuthTransportError, t as AuthConfigError } from "./error-CjADNVm8.js";
 export { AuthConfigError, AuthLocalDatabaseError, AuthLocalError, AuthLocalSecretError, AuthLocalSigningError, AuthPairingUrlError, AuthTransportError, T3Auth, T3AuthLive, T3AuthPairing, T3AuthPairingLive, T3LocalAuth, T3LocalAuthLive, T3LocalAuthOrigin, T3LocalAuthOriginLive, T3LocalAuthToken, T3LocalAuthTokenLive, makeT3Auth, makeT3AuthPairing, makeT3LocalAuth, makeT3LocalAuthOrigin, makeT3LocalAuthToken, parsePairingUrl };

package/dist/bin.js

@@ -3,12 +3,12 @@ import { A as none, C as isNone, Ft as BaseProto, Mn as pipe, Nt as withFiber, O
 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 { c as fromReadable, l as fromWritable } from "./layer-CMo36MrX.js";
+import { C as make$12, S as Crypto, x as T3Auth } from "./layer-Do8wK1t6.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 { d as latestAssistantMessage, f as threadStatus, h as CliPath, m as ThreadSessionError, p as ProjectLookupError, t as AppLayer } from "./layer-DwI3Skkh.js";
 import { t as NodeEnvironmentLive } from "./layer-DHhKS5jd.js";
 import * as NodeChildProcess from "node:child_process";
 import * as NodeCrypto from "node:crypto";
@@ -4400,6 +4400,56 @@ const archiveThreadCommand = make("archive", {
 	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();
@@ -4784,7 +4834,8 @@ function createThreadCommand() {
 		sendThreadCommand,
 		archiveThreadCommand,
 		getThreadMessagesCommand,
-		waitForThreadCommand
+		waitForThreadCommand,
+		callbackThreadCommand
 	]));
 }
 //#endregion
@@ -4859,7 +4910,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.8.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/connection.js

@@ -1,7 +1,7 @@
 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 { n as T3AuthTransportLive } from "./transport-MI0Z3d2T.js";
+import { a as makeT3CodeConnectionProvider, i as T3CodeConnectionProviderLive, o as layerWebSocketConstructor, r as T3CodeConnectionProvider, s as layerUndici, t as T3RpcLive } from "./layer-CMo36MrX.js";
+import { n as T3CodeConnectionError } from "./error-ChTsLQTu.js";
 //#region src/connection/layer.ts
 function makeT3CodeRpcLayer() {
 	return T3RpcLive.pipe(provide(T3AuthTransportLive));

package/dist/{error-B2t1bAP9.js → error-ChTsLQTu.js}

@@ -1,7 +1,7 @@
 import { $ as optional, E as Unknown, R as instanceOf, T as Union, a as Defect, et as optionalKey, nt as tag, s as ErrorClass, st as SchemaError, x as TaggedErrorClass, y as String } from "./Schema-DsQxYh6_.js";
-import { Dl as HttpClientErrorSchema, Mu as EnvironmentAuthorizationError, Oi as KeybindingsConfigError, fs as OrchestrationDispatchCommandError, si as ServerSettingsError, sl as SocketErrorReason, ys as OrchestrationGetSnapshotError } from "./src-KdbHqrex.js";
+import { Rl as HttpClientErrorSchema, Uu as EnvironmentAuthorizationError, _s as OrchestrationDispatchCommandError, ji as KeybindingsConfigError, ui as ServerSettingsError, vl as SocketErrorReason, ws as OrchestrationGetSnapshotError } from "./src-aiFPmAG7.js";
 import { n as UrlError } from "./error-BHRnjLux.js";
-import { s as AuthTransportError } from "./error-jwMt3VoW.js";
+import { s as AuthTransportError } from "./error-CjADNVm8.js";
 //#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/unstable/workers/WorkerError.js
 const TypeId$1 = "~effect/workers/WorkerError";
 /**

package/dist/{error-jwMt3VoW.js → error-CjADNVm8.js}

@@ -1,6 +1,6 @@
 import { cn as IllegalArgumentError, i as PlatformError } from "./Path-D8WPdPwR.js";
 import { R as instanceOf, T as Union, d as Literals, et as optionalKey, st as SchemaError, x as TaggedErrorClass, y as String } from "./Schema-DsQxYh6_.js";
-import { Dl as HttpClientErrorSchema } from "./src-KdbHqrex.js";
+import { Rl as HttpClientErrorSchema } from "./src-aiFPmAG7.js";
 import { n as UrlError, t as ConfigError } from "./error-BHRnjLux.js";
 //#region src/auth/error.ts
 var AuthPairingUrlError = class extends TaggedErrorClass()("AuthPairingUrlError", {

package/dist/index.js

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

package/dist/{layer-DvHnKBYj.js → layer-CMo36MrX.js}

@@ -2,11 +2,11 @@ import { a as __toESM, i as __require, n as __exportAll, r as __reExport, t as _
 import { A as none, An as identity, C as isNone, En as constVoid, It as Class, O as map, On as dual, Pn as pipeArguments, T as isSome, a as get, d as make$2, i as empty, it as PipeInspectableProto, j as some, l as getUnsafe$1, n as Service, r as add, t as Reference, x as getOrThrow } from "./Context-DueQ9iMH.js";
 import { $ as mapError, $t as catchDone, An as effectContext, B as forkIn, Bn as addFinalizerExit, Bt as useSpan, C as context, Ct as serviceOption, D as ensuring, F as fnUntraced, Fn as succeed$1, Ft as tryPromise, G as interrupt$1, Hn as fork, Ht as whileLoop, It as try_, J as logError, Jt as either, K as interruptible, L as forEach, Ln as sync$1, Nn as provide, Nt as timeout, On as buildWithScope, Ot as suspend, P as fn, R as forever, Rn as Scope, T as delay, Tn as squash, Tt as succeed, U as gen, Ut as withFiber, V as forkScoped, Vn as close, Vt as void_, W as ignore, Wt as withParentSpan, X as map$1, Xt as spaced, Y as makeSpanScoped, Yt as exponential, Zt as take, at as onExit, ct as promise, d as as, di as isSuccess$1, dn as done, dt as provideService, er as die, ft as raceFirst, g as catchCause, gt as runForkWith, h as callback, ht as runFork, ir as interrupt, it as onError, j as flatMap, jt as tapCause, k as fail, kn as effect, kt as sync, l as andThen, lr as void_$1, lt as provide$1, m as cached, mn as findError, mt as retry, ni as of, nr as failCause, or as isFailure, ot as onInterrupt, rt as never, s as acquireRelease, sn as Done, sr as isSuccess, st as orDie, tr as fail$1, tt as matchCauseEffect, u as annotateLogs, un as UnknownError, ut as provideContext, vn as interruptors, vt as runSync, w as contextWith, zn as addFinalizer } from "./Path-D8WPdPwR.js";
 import { Cn as makeUnsafe$1, Dt as fromQueue, I as encodeEffect, M as decodeSync, P as decodeUnknownEffect, T as Union, Tn as interrupt$2, Wt as runForEachArray, _n as failCause$1, a as Defect, b as Struct, dn as mapDone, hn as end, mn as bounded, nn as unwrap, on as fromChannel, p as NonEmptyArray, pn as makeUnsafe$2, rt as toCodecJson, un as fromTransform, wn as getCurrent, wt as fromChannel$1, xn as offerAll } from "./Schema-DsQxYh6_.js";
-import { a as make$4, c as make$3, i as layerMergedContext, o as getAndSet$1, s as makeUnsafe$3, t as T3AuthTransport } from "./transport-D3zBdZ1h.js";
-import { Al as empty$1, Bn as ServerConfig, Cl as setUrlParam, Dr as ServerProviders, El as HttpClientError, Fl as merge, Mu as EnvironmentAuthorizationError, Nl as empty$2, Oi as KeybindingsConfigError, Pl as fromInput, Tl as DecodeError, al as SocketCloseError, at as getStreamSchemas, c as WsOrchestrationDispatchCommandRpc, cl as SocketOpenError, dl as TypeId$2, hl as inspect$1, il as Socket, it as make$5, jl as fromSetCookie, kl as TransportError, ll as WebSocketConstructor, m as WsOrchestrationSubscribeThreadRpc, ml as TypeId$1, nt as make$6, ol as SocketError, ot as isStreamSchema, p as WsOrchestrationSubscribeShellRpc, rt as exitSchema, si as ServerSettingsError, t as WS_METHODS, ul as layerWebSocket, wl as toUrl, yl as get$1 } from "./src-KdbHqrex.js";
+import { a as make$4, c as make$3, i as layerMergedContext, o as getAndSet$1, s as makeUnsafe$3, t as T3AuthTransport } from "./transport-MI0Z3d2T.js";
+import { Al as get$1, Bl as TransportError, Bn as ServerConfig, Dr as ServerProviders, El as inspect$1, Fl as toUrl, Gl as fromInput, Hl as fromSetCookie, Il as DecodeError, Kl as merge, Ll as HttpClientError, Pl as setUrlParam, Sl as TypeId$2, Tl as TypeId$1, Uu as EnvironmentAuthorizationError, Vl as empty$1, Wl as empty$2, _l as SocketError, at as getStreamSchemas, bl as WebSocketConstructor, c as WsOrchestrationDispatchCommandRpc, gl as SocketCloseError, hl as Socket, it as make$5, ji as KeybindingsConfigError, m as WsOrchestrationSubscribeThreadRpc, nt as make$6, ot as isStreamSchema, p as WsOrchestrationSubscribeShellRpc, rt as exitSchema, t as WS_METHODS, ui as ServerSettingsError, xl as layerWebSocket, yl as SocketOpenError } from "./src-aiFPmAG7.js";
 import { n as fromInput$1 } from "./UrlParams-BA6gBvaY.js";
 import { r as toWebSocketEndpointUrl, t as normalizeHttpBaseUrl } from "./url-SlsaG8nY.js";
-import { i as RpcClientError, r as RpcClientDefect, t as RpcError } from "./error-B2t1bAP9.js";
+import { i as RpcClientError, r as RpcClientDefect, t as RpcError } from "./error-ChTsLQTu.js";
 import { createRequire } from "node:module";
 import { Readable } from "node:stream";
 //#region node_modules/.pnpm/@effect+platform-node-shared@4.0.0-beta.78_effect@4.0.0-beta.78/node_modules/@effect/platform-node-shared/dist/NodeSink.js

package/dist/{layer-CfC5qZol.js → layer-Do8wK1t6.js}

@@ -1,11 +1,11 @@
 import { $t as hash, Tn as constUndefined, X as Prototype, a as get, an as hasProperty, bn as isTagged, h as mutate, k as match, kn as flow, n as Service, o as getOption, r as add, t as Reference } from "./Context-DueQ9iMH.js";
 import { $ as mapError, Ar as makeSpanUnsafe, At as tap, Br as ParentSpan, Bt as useSpan, C as context, Ct as serviceOption, D as ensuring, F as fnUntraced, H as fromResult, Jn as TracerTimingEnabled, Kn as provide, O as exit, Ot as suspend, P as fn, Rn as Scope, Rt as uninterruptibleMask, S as clockWith, Tt as succeed, U as gen, Ur as reason, Ut as withFiber, Vn as close, Vt as void_, Wn as make$4, X as map, Y as makeSpanScoped, _r as endSpan, a as badArgument, at as onExit, b as catchTags, dt as provideService, gt as runForkWith, j as flatMap, k as fail, kn as effect, kt as sync, sr as isSuccess, st as orDie, t as Path, ut as provideContext, v as catchFilter, w as contextWith, xt as scoped, y as catchTag, zn as addFinalizer } from "./Path-D8WPdPwR.js";
 import { Bn as Clock, Dn as runIn, Dt as fromQueue, Fn as encodeBase64Url, In as add$1, Ln as formatIso, Rn as now, Sn as offerUnsafe, dt as FileSystem, nn as unwrap, vn as failCauseUnsafe, yn as make$5, zn as toEpochMillis } from "./Schema-DsQxYh6_.js";
-import { r as decodeAuthLocalRuntimeStateFromJson, t as T3AuthTransport } from "./transport-D3zBdZ1h.js";
-import { ou as AuthAdministrativeScopes, zu as AuthSessionId } from "./src-KdbHqrex.js";
+import { r as decodeAuthLocalRuntimeStateFromJson, t as T3AuthTransport } from "./transport-MI0Z3d2T.js";
+import { Xu as AuthSessionId, _u as AuthAdministrativeScopes } from "./src-aiFPmAG7.js";
 import { n as T3Config, t as Environment } from "./service-CLmRO2Dp.js";
 import { a as mutate$1, i as fromString, t as normalizeHttpBaseUrl } from "./url-SlsaG8nY.js";
-import { a as AuthLocalSigningError, i as AuthLocalSecretError, n as AuthLocalDatabaseError, o as AuthPairingUrlError, r as AuthLocalError, t as AuthConfigError } from "./error-jwMt3VoW.js";
+import { a as AuthLocalSigningError, i as AuthLocalSecretError, n as AuthLocalDatabaseError, o as AuthPairingUrlError, r as AuthLocalError, t as AuthConfigError } from "./error-CjADNVm8.js";
 import { n as resolveT3BaseDir } from "./base-dir-R12OMDso.js";
 //#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Crypto.js
 /**

package/dist/{layer-MqCKkIGD.js → layer-DwI3Skkh.js}

@@ -1,15 +1,18 @@
 import { An as identity, C as isNone, S as getOrUndefined, T as isSome, an as hasProperty, n as Service } from "./Context-DueQ9iMH.js";
 import { $ as mapError, Fn as succeed$1, It as try_, Mn as mergeAll, Mt as tapError, Nn as provide$1, P as fn, Tt as succeed, U as gen, Vt as void_, X as map, Yt as exponential, Zt as take, b as catchTags, bt as scope, dt as provideService, j as flatMap, k as fail, kn as effect, kt as sync, lt as provide, mt as retry, qt as collectWhile, st as orDie, t as Path, xt as scoped, zn as addFinalizer } from "./Path-D8WPdPwR.js";
 import { $ as optional, $t as tapError$1, At as map$1, Ct as flatMap$1, Et as fromIterableEffect, F as decodeUnknownSync, Ft as peel, Gt as runHead, Kt as runLast, Ln as formatIso, Rn as now, Rt as retry$1, St as filter, T as Union, Tt as fromIterable, Zt as takeUntil, _t as catchTags$1, a as Defect, g as Number, nn as unwrap, qt as scoped$1, sn as head, x as TaggedErrorClass, xt as fail$1, y as String } from "./Schema-DsQxYh6_.js";
-import { n as T3AuthTransportLive } from "./transport-D3zBdZ1h.js";
-import { a as makeT3CodeConnectionProvider, n as T3Rpc, o as layerWebSocketConstructor, r as T3CodeConnectionProvider, s as layerUndici, t as T3RpcLive } from "./layer-DvHnKBYj.js";
-import { S as Crypto, _ as layer, c as T3LocalAuthLive, d as T3LocalAuthTokenLive, g as makeCompilerSqlite, h as defaultTransforms, i as T3AuthPairingLive, m as make, p as SqlClientFactory, t as T3AuthLive, y as T3LocalAuthOriginLive } from "./layer-CfC5qZol.js";
-import { $c as ProviderInstanceId, Gu as MessageId, Vu as CommandId, Yu as ProjectId, is as ORCHESTRATION_WS_METHODS, rs as ModelSelection, t as WS_METHODS, td as ThreadId, ws as OrchestrationMessage } from "./src-KdbHqrex.js";
+import { n as T3AuthTransportLive } from "./transport-MI0Z3d2T.js";
+import { a as makeT3CodeConnectionProvider, n as T3Rpc, o as layerWebSocketConstructor, r as T3CodeConnectionProvider, s as layerUndici, t as T3RpcLive } from "./layer-CMo36MrX.js";
+import { S as Crypto, _ as layer, c as T3LocalAuthLive, d as T3LocalAuthTokenLive, g as makeCompilerSqlite, h as defaultTransforms, i as T3AuthPairingLive, m as make, p as SqlClientFactory, t as T3AuthLive, y as T3LocalAuthOriginLive } from "./layer-Do8wK1t6.js";
+import { Qu as CommandId, cs as ModelSelection, fd as ThreadId, ks as OrchestrationMessage, ls as ORCHESTRATION_WS_METHODS, nd as MessageId, od as ProjectId, t as WS_METHODS, ul as ProviderInstanceId } from "./src-aiFPmAG7.js";
 import { n as T3Config, t as Environment } from "./service-CLmRO2Dp.js";
 import { t as T3Application } from "./service-ybOWV9pL.js";
-import { i as RpcClientError, n as T3CodeConnectionError, t as RpcError } from "./error-B2t1bAP9.js";
+import { i as RpcClientError, n as T3CodeConnectionError, t as RpcError } from "./error-ChTsLQTu.js";
 import { t as T3ConfigLive } from "./layer-DUv99vsS.js";
 import { DatabaseSync } from "node:sqlite";
+//#region src/cli-path/service.ts
+var CliPath = class extends Service()("t3cli/CliPath") {};
+//#endregion
 //#region src/domain/error.ts
 var ProjectLookupError = class extends TaggedErrorClass()("ProjectLookupError", {
 	message: String,
@@ -572,6 +575,19 @@ const makeThreadApplication = fn("makeThreadApplication")(function* () {
 			});
 			yield* failIfThreadError(thread);
 			return thread;
+		}),
+		callbackThread: fn("T3ApplicationLive.callbackThread")(function* (input) {
+			yield* waitForThread({
+				orchestration,
+				threadId: input.fromThreadId
+			});
+			return {
+				dispatch: (yield* sendThread({
+					threadId: input.targetThreadId,
+					message: input.prompt
+				}, { until: "dispatch" })).dispatch,
+				targetThreadId: input.targetThreadId
+			};
 		})
 	};
 });
@@ -1180,6 +1196,7 @@ function toSqlInputValue(value) {
 	}
 	return JSON.stringify(value) ?? null;
 }
+const NodeCliPathLayer = effect(CliPath, sync(() => ({ path: process.argv[1] ?? "dist/bin.js" })));
 //#endregion
 //#region src/runtime/layer.ts
 const T3AuthTransportLayer = T3AuthTransportLive.pipe(provide$1(layerUndici));
@@ -1201,6 +1218,6 @@ const T3RpcLayer = T3RpcLive.pipe(provide$1(mergeAll(T3ConfigConnectionProviderL
 const T3OrchestrationLayer = T3OrchestrationLive.pipe(provide$1(T3RpcLayer));
 const T3ApplicationLayer = T3ApplicationLive.pipe(provide$1(T3OrchestrationLayer));
 const AuthAppLayer = mergeAll(T3ConfigLive, T3AuthLayer);
-const AppLayer = mergeAll(T3ConfigLive, T3AuthLayer, T3RpcLayer, T3OrchestrationLayer, T3ApplicationLayer);
+const AppLayer = mergeAll(T3ConfigLive, T3AuthLayer, T3RpcLayer, T3OrchestrationLayer, T3ApplicationLayer, NodeCliPathLayer);
 //#endregion
-export { T3AuthTransportLayer as a, T3LocalAuthTokenLayer as c, latestAssistantMessage as d, threadStatus as f, T3AuthPairingLayer as i, T3OrchestrationLayer as l, ThreadSessionError as m, AuthAppLayer as n, T3LocalAuthLayer as o, ProjectLookupError as p, T3AuthLayer as r, T3LocalAuthOriginLayer as s, AppLayer as t, T3Orchestration as u };
+export { T3AuthTransportLayer as a, T3LocalAuthTokenLayer as c, latestAssistantMessage as d, threadStatus as f, CliPath as h, T3AuthPairingLayer as i, T3OrchestrationLayer as l, ThreadSessionError as m, AuthAppLayer as n, T3LocalAuthLayer as o, ProjectLookupError as p, T3AuthLayer as r, T3LocalAuthOriginLayer as s, AppLayer as t, T3Orchestration as u };

package/dist/orchestration.js

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

package/dist/rpc.js

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

package/dist/runtime.js

@@ -1,3 +1,3 @@
-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 { 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-DwI3Skkh.js";
 import { t as NodeEnvironmentLive } from "./layer-DHhKS5jd.js";
 export { AppLayer, AuthAppLayer, NodeEnvironmentLive, T3AuthLayer, T3AuthPairingLayer, T3AuthTransportLayer, T3LocalAuthLayer, T3LocalAuthOriginLayer, T3LocalAuthTokenLayer, T3OrchestrationLayer };

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

@@ -82,6 +82,15 @@ export declare const makeT3Application: () => Effect.Effect<{
                 readonly updatedAt: string;
                 readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
             } | null;
+            readonly goal: {
+                readonly objective: string;
+                readonly status: "active" | "paused" | "budgetLimited" | "complete";
+                readonly tokensUsed: number;
+                readonly tokenBudget: number | null;
+                readonly timeUsedSeconds: number;
+                readonly createdAt: string;
+                readonly updatedAt: string;
+            } | null;
             readonly latestUserMessageAt: string | null;
             readonly hasPendingApprovals: boolean;
             readonly hasPendingUserInput: boolean;
@@ -120,6 +129,15 @@ export declare const makeT3Application: () => Effect.Effect<{
         readonly updatedAt: string;
         readonly archivedAt: string | null;
         readonly deletedAt: string | null;
+        readonly goal: {
+            readonly objective: string;
+            readonly status: "active" | "paused" | "budgetLimited" | "complete";
+            readonly tokensUsed: number;
+            readonly tokenBudget: number | null;
+            readonly timeUsedSeconds: number;
+            readonly createdAt: string;
+            readonly updatedAt: string;
+        } | null;
         readonly messages: readonly {
             readonly id: string & import("effect/Brand").Brand<"MessageId">;
             readonly role: "user" | "assistant" | "system";
@@ -225,6 +243,15 @@ export declare const makeT3Application: () => Effect.Effect<{
             readonly updatedAt: string;
             readonly archivedAt: string | null;
             readonly deletedAt: string | null;
+            readonly goal: {
+                readonly objective: string;
+                readonly status: "active" | "paused" | "budgetLimited" | "complete";
+                readonly tokensUsed: number;
+                readonly tokenBudget: number | null;
+                readonly timeUsedSeconds: number;
+                readonly createdAt: string;
+                readonly updatedAt: string;
+            } | null;
             readonly messages: readonly {
                 readonly id: string & import("effect/Brand").Brand<"MessageId">;
                 readonly role: "user" | "assistant" | "system";
@@ -401,6 +428,15 @@ export declare const makeT3Application: () => Effect.Effect<{
             readonly updatedAt: string;
             readonly archivedAt: string | null;
             readonly deletedAt: string | null;
+            readonly goal: {
+                readonly objective: string;
+                readonly status: "active" | "paused" | "budgetLimited" | "complete";
+                readonly tokensUsed: number;
+                readonly tokenBudget: number | null;
+                readonly timeUsedSeconds: number;
+                readonly createdAt: string;
+                readonly updatedAt: string;
+            } | null;
             readonly messages: readonly {
                 readonly id: string & import("effect/Brand").Brand<"MessageId">;
                 readonly role: "user" | "assistant" | "system";
@@ -495,6 +531,15 @@ export declare const makeT3Application: () => Effect.Effect<{
         readonly updatedAt: string;
         readonly archivedAt: string | null;
         readonly deletedAt: string | null;
+        readonly goal: {
+            readonly objective: string;
+            readonly status: "active" | "paused" | "budgetLimited" | "complete";
+            readonly tokensUsed: number;
+            readonly tokenBudget: number | null;
+            readonly timeUsedSeconds: number;
+            readonly createdAt: string;
+            readonly updatedAt: string;
+        } | null;
         readonly messages: readonly {
             readonly id: string & import("effect/Brand").Brand<"MessageId">;
             readonly role: "user" | "assistant" | "system";
@@ -555,6 +600,12 @@ export declare const makeT3Application: () => Effect.Effect<{
             readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
         } | null;
     }, import("../domain/error.ts").ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
+    callbackThread: (input: import("./service.ts").CallbackThreadInput) => Effect.Effect<{
+        dispatch: {
+            readonly sequence: number;
+        };
+        targetThreadId: string;
+    }, import("../domain/error.ts").ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
     loadShell: () => Effect.Effect<{
         readonly snapshotSequence: number;
         readonly projects: readonly {
@@ -633,6 +684,15 @@ export declare const makeT3Application: () => Effect.Effect<{
                 readonly updatedAt: string;
                 readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
             } | null;
+            readonly goal: {
+                readonly objective: string;
+                readonly status: "active" | "paused" | "budgetLimited" | "complete";
+                readonly tokensUsed: number;
+                readonly tokenBudget: number | null;
+                readonly timeUsedSeconds: number;
+                readonly createdAt: string;
+                readonly updatedAt: string;
+            } | null;
             readonly latestUserMessageAt: string | null;
             readonly hasPendingApprovals: boolean;
             readonly hasPendingUserInput: boolean;
@@ -752,6 +812,7 @@ export declare const makeT3Application: () => Effect.Effect<{
             readonly groupKey: string;
         } | undefined;
         readonly showInteractionModeToggle?: boolean | undefined;
+        readonly requiresNewThreadForModelChange?: boolean | undefined;
         readonly message?: string | undefined;
         readonly availability?: "available" | "unavailable" | undefined;
         readonly unavailableReason?: string | undefined;

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

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

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

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

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

@@ -17,6 +17,11 @@ export type SendThreadInput = {
     readonly message: string;
     readonly options?: NonNullable<ModelSelection["options"]>;
 };
+export type CallbackThreadInput = {
+    readonly fromThreadId: string;
+    readonly targetThreadId: string;
+    readonly prompt: string;
+};
 export type StartThreadPolicy = {
     readonly until: "dispatch" | "visible" | "complete";
 };
@@ -66,6 +71,10 @@ declare const T3Application_base: Context.ServiceClass<T3Application, "t3cli/T3A
     }, ApplicationError>;
     readonly watchThread: (threadId: string) => Stream.Stream<WaitEvent, ApplicationError>;
     readonly waitForThread: (threadId: string) => Effect.Effect<OrchestrationThread, ApplicationError>;
+    readonly callbackThread: (input: CallbackThreadInput) => Effect.Effect<{
+        readonly dispatch: DispatchResult;
+        readonly targetThreadId: string;
+    }, ApplicationError>;
 }>;
 export declare class T3Application extends T3Application_base {
 }

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

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

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

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

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

@@ -5,7 +5,7 @@ import { Environment } from "../environment/service.ts";
 import { T3Orchestration } from "../orchestration/service.ts";
 import { ProjectLookupError, ThreadSessionError } from "../domain/error.ts";
 import { type StartThreadInput } from "./service.ts";
-import type { SendThreadInput } from "./service.ts";
+import type { SendThreadInput, CallbackThreadInput } from "./service.ts";
 export declare const makeThreadApplication: () => Effect.Effect<{
     archiveThread: (threadId: string) => Effect.Effect<{
         readonly sequence: number;
@@ -87,6 +87,15 @@ export declare const makeThreadApplication: () => Effect.Effect<{
                 readonly updatedAt: string;
                 readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
             } | null;
+            readonly goal: {
+                readonly objective: string;
+                readonly status: "active" | "paused" | "budgetLimited" | "complete";
+                readonly tokensUsed: number;
+                readonly tokenBudget: number | null;
+                readonly timeUsedSeconds: number;
+                readonly createdAt: string;
+                readonly updatedAt: string;
+            } | null;
             readonly latestUserMessageAt: string | null;
             readonly hasPendingApprovals: boolean;
             readonly hasPendingUserInput: boolean;
@@ -125,6 +134,15 @@ export declare const makeThreadApplication: () => Effect.Effect<{
         readonly updatedAt: string;
         readonly archivedAt: string | null;
         readonly deletedAt: string | null;
+        readonly goal: {
+            readonly objective: string;
+            readonly status: "active" | "paused" | "budgetLimited" | "complete";
+            readonly tokensUsed: number;
+            readonly tokenBudget: number | null;
+            readonly timeUsedSeconds: number;
+            readonly createdAt: string;
+            readonly updatedAt: string;
+        } | null;
         readonly messages: readonly {
             readonly id: string & import("effect/Brand").Brand<"MessageId">;
             readonly role: "user" | "assistant" | "system";
@@ -230,6 +248,15 @@ export declare const makeThreadApplication: () => Effect.Effect<{
             readonly updatedAt: string;
             readonly archivedAt: string | null;
             readonly deletedAt: string | null;
+            readonly goal: {
+                readonly objective: string;
+                readonly status: "active" | "paused" | "budgetLimited" | "complete";
+                readonly tokensUsed: number;
+                readonly tokenBudget: number | null;
+                readonly timeUsedSeconds: number;
+                readonly createdAt: string;
+                readonly updatedAt: string;
+            } | null;
             readonly messages: readonly {
                 readonly id: string & import("effect/Brand").Brand<"MessageId">;
                 readonly role: "user" | "assistant" | "system";
@@ -406,6 +433,15 @@ export declare const makeThreadApplication: () => Effect.Effect<{
             readonly updatedAt: string;
             readonly archivedAt: string | null;
             readonly deletedAt: string | null;
+            readonly goal: {
+                readonly objective: string;
+                readonly status: "active" | "paused" | "budgetLimited" | "complete";
+                readonly tokensUsed: number;
+                readonly tokenBudget: number | null;
+                readonly timeUsedSeconds: number;
+                readonly createdAt: string;
+                readonly updatedAt: string;
+            } | null;
             readonly messages: readonly {
                 readonly id: string & import("effect/Brand").Brand<"MessageId">;
                 readonly role: "user" | "assistant" | "system";
@@ -500,6 +536,15 @@ export declare const makeThreadApplication: () => Effect.Effect<{
         readonly updatedAt: string;
         readonly archivedAt: string | null;
         readonly deletedAt: string | null;
+        readonly goal: {
+            readonly objective: string;
+            readonly status: "active" | "paused" | "budgetLimited" | "complete";
+            readonly tokensUsed: number;
+            readonly tokenBudget: number | null;
+            readonly timeUsedSeconds: number;
+            readonly createdAt: string;
+            readonly updatedAt: string;
+        } | null;
         readonly messages: readonly {
             readonly id: string & import("effect/Brand").Brand<"MessageId">;
             readonly role: "user" | "assistant" | "system";
@@ -560,4 +605,10 @@ export declare const makeThreadApplication: () => Effect.Effect<{
             readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
         } | null;
     }, ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
+    callbackThread: (input: CallbackThreadInput) => Effect.Effect<{
+        dispatch: {
+            readonly sequence: number;
+        };
+        targetThreadId: string;
+    }, ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
 }, never, T3Orchestration | Environment | Path.Path | Crypto.Crypto>;

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

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

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

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

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

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

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

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