t3code-cli 0.6.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-DIg0RxSO.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.6.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-DIg0RxSO.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-DIg0RxSO.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,
@@ -120,73 +123,68 @@ const makeModelsApplication = fn("makeModelsApplication")(function* () {
 //#endregion
 //#region src/domain/helpers.ts
 const resolveProjectScope = fn("resolveProjectScope")(function* (snapshot, input) {
-	const absoluteRef = yield* resolveAbsolutePath(input.ref, input.cwd);
+	const path = yield* Path;
 	const byId = findProjectById(snapshot, input.ref);
 	if (byId !== null) return { project: byId };
-	const byExactPath = yield* findProjectByWorkspaceRoot(snapshot, absoluteRef, input.cwd);
-	if (byExactPath !== void 0) return { project: byExactPath };
-	const byAncestor = yield* findProjectByAncestorPath(snapshot, absoluteRef, input.cwd);
-	if (byAncestor !== void 0) return byAncestor;
-	return yield* findProjectByKnownWorktreePath(snapshot, absoluteRef, input.cwd);
+	if (!path.isAbsolute(input.ref)) return;
+	return yield* findProjectByPathPriority(snapshot, path.normalize(input.ref));
 });
 function findProjectById(snapshot, projectId) {
 	return snapshot.projects.find((project) => project.id === projectId) ?? null;
 }
-const resolveAbsolutePath = fn("resolveAbsolutePath")(function* (ref, cwd) {
-	const path = yield* Path;
-	return path.isAbsolute(ref) ? path.normalize(ref) : path.normalize(path.resolve(cwd, ref));
-});
 const isDescendantPath = fn("isDescendantPath")(function* (parent, child) {
 	const path = yield* Path;
 	if (child === parent) return true;
 	const relative = path.relative(parent, child);
 	return relative.length > 0 && !relative.startsWith("..") && !path.isAbsolute(relative);
 });
-const findProjectByWorkspaceRoot = fn("findProjectByWorkspaceRoot")(function* (snapshot, absolutePath, cwd) {
-	for (const project of snapshot.projects) if ((yield* resolveAbsolutePath(project.workspaceRoot, cwd)) === absolutePath) return project;
-});
-const findProjectByAncestorPath = fn("findProjectByAncestorPath")(function* (snapshot, absolutePath, cwd) {
-	let bestProject;
-	let bestWorkspaceRoot = "";
-	for (const project of snapshot.projects) {
-		const workspaceRoot = yield* resolveAbsolutePath(project.workspaceRoot, cwd);
-		if (!(yield* isDescendantPath(workspaceRoot, absolutePath))) continue;
-		if (workspaceRoot.length > bestWorkspaceRoot.length) {
-			bestProject = project;
-			bestWorkspaceRoot = workspaceRoot;
-		}
-	}
-	if (bestProject === void 0) return;
-	if (absolutePath === bestWorkspaceRoot) return { project: bestProject };
-	return {
-		project: bestProject,
-		inferredWorktreePath: absolutePath
-	};
-});
-const findProjectByKnownWorktreePath = fn("findProjectByKnownWorktreePath")(function* (snapshot, absolutePath, cwd) {
+const findProjectByPathPriority = fn("findProjectByPathPriority")(function* (snapshot, absolutePath) {
+	const path = yield* Path;
 	const projectsById = new Map(snapshot.projects.map((project) => [project.id, project]));
-	let bestProject;
-	let bestKnownPath = "";
+	const workspaceRoots = new Map(snapshot.projects.map((project) => [project.id, path.normalize(project.workspaceRoot)]));
+	const candidates = [];
 	for (const thread of snapshot.threads) {
 		if (thread.worktreePath === null) continue;
 		const project = projectsById.get(thread.projectId);
 		if (project === void 0) continue;
-		const knownPath = yield* resolveAbsolutePath(thread.worktreePath, cwd);
-		if (!(yield* isDescendantPath(knownPath, absolutePath))) continue;
-		if (knownPath.length > bestKnownPath.length) {
-			bestProject = project;
-			bestKnownPath = knownPath;
-		}
+		const workspaceRoot = workspaceRoots.get(thread.projectId);
+		if (workspaceRoot === void 0) continue;
+		const matchPath = path.normalize(thread.worktreePath);
+		if (!(yield* isDescendantPath(matchPath, absolutePath))) continue;
+		candidates.push({
+			project,
+			matchPath,
+			workspaceRoot,
+			source: "worktree"
+		});
+	}
+	for (const project of snapshot.projects) {
+		const workspaceRoot = workspaceRoots.get(project.id);
+		if (workspaceRoot === void 0) continue;
+		if (!(yield* isDescendantPath(workspaceRoot, absolutePath))) continue;
+		candidates.push({
+			project,
+			matchPath: workspaceRoot,
+			workspaceRoot,
+			source: "project"
+		});
+	}
+	if (candidates.length === 0) return;
+	candidates.sort((left, right) => {
+		if (left.matchPath.length !== right.matchPath.length) return right.matchPath.length - left.matchPath.length;
+		if (left.source === right.source) return 0;
+		return left.source === "worktree" ? -1 : 1;
+	});
+	const best = candidates[0];
+	if (absolutePath === best.matchPath) {
+		if (best.source === "worktree" && best.matchPath !== best.workspaceRoot) return {
+			project: best.project,
+			inferredWorktreePath: best.matchPath
+		};
+		return { project: best.project };
 	}
-	if (bestProject === void 0) return;
-	const workspaceRoot = yield* resolveAbsolutePath(bestProject.workspaceRoot, cwd);
-	if (absolutePath === workspaceRoot) return { project: bestProject };
-	if (absolutePath === bestKnownPath) return bestKnownPath === workspaceRoot ? { project: bestProject } : {
-		project: bestProject,
-		inferredWorktreePath: bestKnownPath
-	};
 	return {
-		project: bestProject,
+		project: best.project,
 		inferredWorktreePath: absolutePath
 	};
 });
@@ -444,10 +442,7 @@ const makeThreadApplication = fn("makeThreadApplication")(function* () {
 	const environment = yield* Environment;
 	const listThreads = fn("T3ApplicationLive.listThreads")(function* (projectRef) {
 		const snapshot = yield* orchestration.getShellSnapshot();
-		const scope = yield* resolveProjectScope(snapshot, {
-			ref: projectRef,
-			cwd: environment.cwd
-		}).pipe(provideService(Path, path));
+		const scope = yield* resolveProjectScope(snapshot, { ref: projectRef }).pipe(provideService(Path, path));
 		if (scope === void 0) return yield* fail(new ProjectLookupError({
 			message: `project not found: ${projectRef}`,
 			ref: projectRef
@@ -471,10 +466,7 @@ const makeThreadApplication = fn("makeThreadApplication")(function* () {
 			message: "project is required",
 			ref: environment.cwd
 		}));
-		const scope = yield* resolveProjectScope(snapshot, {
-			ref: projectRef,
-			cwd: environment.cwd
-		}).pipe(provideService(Path, path));
+		const scope = yield* resolveProjectScope(snapshot, { ref: projectRef }).pipe(provideService(Path, path));
 		if (scope === void 0) return yield* fail(new ProjectLookupError({
 			message: `project not found: ${projectRef}`,
 			ref: projectRef
@@ -583,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
+			};
 		})
 	};
 });
@@ -1191,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));
@@ -1212,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-DIg0RxSO.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-DIg0RxSO.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";