t3code-cli 0.11.0 → 0.12.0

package/src/cli/threads/interrupt.ts

@@ -2,13 +2,15 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Command } from "effect/unstable/cli";
 
+import { extraArgsConfig } from "../extra-args.ts";
 import { formatFlag, selfActionForceFlag, threadFlag } from "../flags.ts";
 import { MissingThreadError } from "../error.ts";
-import { requireSelfActionConfirmation } from "../self-action.ts";
-import { resolveThreadId } from "../../scope/index.ts";
+import { requireSelfActionConfirmation } from "../interaction/self-action.ts";
+import { resolveThreadId } from "../scope/index.ts";
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
-import { resolveOutputFormat } from "../output-format.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 
 export const interruptThreadCommand = Command.make(
@@ -17,15 +19,17 @@ export const interruptThreadCommand = Command.make(
     thread: threadFlag,
     force: selfActionForceFlag,
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ thread, force, format }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
       const threadId = resolveThreadId({
         value: Option.getOrUndefined(thread),
-        env: environment.env,
+        scope: t3CliEnv.scope,
       });
       if (threadId === undefined) {
         return yield* Effect.fail(
@@ -37,16 +41,17 @@ export const interruptThreadCommand = Command.make(
       yield* requireSelfActionConfirmation({
         threadId,
         force,
-        environment,
+        cliRuntime,
+        t3CliEnv,
         action: "interrupt",
       });
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const dispatch = yield* application.interruptThread(threadId);
       if (resolvedFormat === "json") {
         return yield* output.printJson({ threadId, dispatch });
       }
       return yield* output.printInfo(
-        `thread interrupted: ${threadId}\nsequence: ${dispatch.sequence}`,
+        `thread interrupted: ${threadId} (sequence ${dispatch.sequence})`,
       );
     }),
 ).pipe(Command.withDescription("interrupt running thread turn"));

package/src/cli/threads/list.test.ts

@@ -11,8 +11,9 @@ import { Command } from "effect/unstable/cli";
 import { fromPartial } from "@total-typescript/shoehorn";
 
 import { T3Application } from "../../application/service.ts";
-import { T3Config } from "../../config/service.ts";
-import { NodeEnvironmentLive } from "../../environment/layer.ts";
+import { T3Config } from "../../config/config.ts";
+import * as CliRuntime from "../../cli/runtime/service.ts";
+import { t3CliEnvConfigLayer } from "../../config/env/env.test-utils.ts";
 import { InvalidFlagCombinationError } from "../error.ts";
 import { T3Output } from "../output/service.ts";
 import { listThreadsCommand } from "./list.ts";
@@ -44,7 +45,8 @@ const testLayer = Layer.mergeAll(
     printInfo: () => Effect.void,
   }),
   NodeServices.layer,
-  NodeEnvironmentLive,
+  CliRuntime.layer,
+  t3CliEnvConfigLayer("/tmp/t3cli-test"),
 );
 
 describe("listThreadsCommand", () => {

package/src/cli/threads/list.ts

@@ -2,13 +2,15 @@ import * as Effect from "effect/Effect";
 import { Command, Flag } from "effect/unstable/cli";
 
 import type { ListThreadsInclude } from "../../application/service.ts";
+import { extraArgsConfig } from "../extra-args.ts";
 import { formatFlag, projectFlag } from "../flags.ts";
 import { InvalidFlagCombinationError } from "../error.ts";
 import { requireCommandProjectRef } from "../require.ts";
-import { formatThreadsHuman } from "../thread-format.ts";
+import { formatThreadsHuman } from "../format/thread.ts";
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
-import { resolveOutputFormat } from "../output-format.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 
 export const listThreadsCommand = Command.make(
@@ -18,11 +20,13 @@ export const listThreadsCommand = Command.make(
     archived: Flag.boolean("archived").pipe(Flag.withDescription("List archived threads only")),
     all: Flag.boolean("all").pipe(Flag.withDescription("List active and archived threads")),
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ project, archived, all, format }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
       if (archived && all) {
         yield* Effect.fail(
@@ -32,12 +36,8 @@ export const listThreadsCommand = Command.make(
         );
       }
       const include: ListThreadsInclude = archived ? "archived" : all ? "all" : "active";
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
-      const projectRef = yield* requireCommandProjectRef({
-        project,
-        env: environment.env,
-        cwd: environment.cwd,
-      });
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+      const projectRef = yield* requireCommandProjectRef({ project });
       const result = yield* application.listThreads(projectRef, { include });
       if (resolvedFormat === "json") {
         yield* output.printJson(result.threads);

package/src/cli/threads/messages.ts

@@ -2,14 +2,16 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Command, Flag } from "effect/unstable/cli";
 
+import { extraArgsConfig } from "../extra-args.ts";
 import { formatFlag, threadFlag } from "../flags.ts";
 import { InvalidLimitError } from "../error.ts";
 import { MissingThreadError } from "../error.ts";
-import { resolveThreadId } from "../../scope/index.ts";
-import { formatThreadMessagesHuman, formatThreadMessagesJson } from "../thread-format.ts";
+import { resolveThreadId } from "../scope/index.ts";
+import { formatThreadMessagesHuman, formatThreadMessagesJson } from "../format/thread.ts";
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
-import { resolveOutputFormat } from "../output-format.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 
 export const getThreadTranscriptCommand = Command.make(
@@ -19,6 +21,7 @@ export const getThreadTranscriptCommand = Command.make(
     limit: Flag.integer("limit").pipe(Flag.withDefault(20)),
     full: Flag.boolean("full"),
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ thread, limit, full, format }) =>
     Effect.gen(function* () {
@@ -28,11 +31,12 @@ export const getThreadTranscriptCommand = Command.make(
         );
       }
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
       const threadId = resolveThreadId({
         value: Option.getOrUndefined(thread),
-        env: environment.env,
+        scope: t3CliEnv.scope,
       });
       if (threadId === undefined) {
         return yield* Effect.fail(
@@ -41,7 +45,7 @@ export const getThreadTranscriptCommand = Command.make(
           }),
         );
       }
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const detail = yield* application.getThreadMessages(threadId);
       if (resolvedFormat === "json") {
         return yield* output.printJson(formatThreadMessagesJson(detail, full));

package/src/cli/threads/respond.ts

@@ -2,14 +2,16 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Command, Flag } from "effect/unstable/cli";
 
+import { extraArgsConfig } from "../extra-args.ts";
 import { formatFlag, threadFlag } from "../flags.ts";
 import { MissingRequestError, MissingThreadError } from "../error.ts";
 import { readJsonAnswers } from "../message-input.ts";
-import { resolveThreadId } from "../../scope/index.ts";
+import { resolveThreadId } from "../scope/index.ts";
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
 import { T3Input } from "../input/service.ts";
-import { resolveOutputFormat } from "../output-format.ts";
+import { resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 
 const requestFlag = Flag.string("request").pipe(
@@ -25,6 +27,7 @@ export const respondThreadCommand = Command.make(
     answers: Flag.string("answers").pipe(Flag.optional),
     stdin: Flag.boolean("stdin"),
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ thread, request, answers, stdin, format }) =>
     Effect.gen(function* () {
@@ -35,11 +38,12 @@ export const respondThreadCommand = Command.make(
         readStdin: inputService.readStdin,
       });
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
       const threadId = resolveThreadId({
         value: Option.getOrUndefined(thread),
-        env: environment.env,
+        scope: t3CliEnv.scope,
       });
       if (threadId === undefined) {
         return yield* Effect.fail(
@@ -54,7 +58,7 @@ export const respondThreadCommand = Command.make(
           new MissingRequestError({ message: "request id is required: pass --request" }),
         );
       }
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const result = yield* application.respondToThread({
         threadId,
         requestId,
@@ -64,7 +68,7 @@ export const respondThreadCommand = Command.make(
         return yield* output.printJson(result);
       }
       return yield* output.printInfo(
-        `user input submitted: ${result.requestId}\nsequence: ${result.dispatch.sequence}`,
+        `user input submitted: ${result.requestId} (sequence ${result.dispatch.sequence})`,
       );
     }),
 ).pipe(Command.withDescription("respond to a pending user-input request"));

package/src/cli/threads/send.ts

@@ -2,16 +2,18 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Argument, Command, Flag } from "effect/unstable/cli";
 
+import { extraArgsConfig } from "../extra-args.ts";
 import { modelFlags, selfActionForceFlag, threadFlag, threadFormatFlag } from "../flags.ts";
 import { readInitialMessage } from "../message-input.ts";
 import { buildModelOptions } from "../model-options.ts";
 import { MissingThreadError } from "../error.ts";
-import { requireSelfActionConfirmation } from "../self-action.ts";
-import { resolveThreadId } from "../../scope/index.ts";
+import { requireSelfActionConfirmation } from "../interaction/self-action.ts";
+import { resolveThreadId } from "../scope/index.ts";
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
 import { T3Input } from "../input/service.ts";
-import { canRenderLiveTerminal, resolveOutputFormat } from "../output-format.ts";
+import { canRenderLiveTerminal, resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 import { printWaitEventsHuman, printWaitEventsNdjson } from "../wait-events.ts";
 
@@ -25,6 +27,7 @@ export const sendThreadCommand = Command.make(
     ...modelFlags,
     wait: Flag.boolean("wait"),
     format: threadFormatFlag,
+    ...extraArgsConfig,
   },
   ({
     thread,
@@ -54,11 +57,12 @@ export const sendThreadCommand = Command.make(
         thinking,
       });
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
       const threadId = resolveThreadId({
         value: Option.getOrUndefined(thread),
-        env: environment.env,
+        scope: t3CliEnv.scope,
       });
       if (threadId === undefined) {
         return yield* Effect.fail(
@@ -70,7 +74,8 @@ export const sendThreadCommand = Command.make(
       yield* requireSelfActionConfirmation({
         threadId,
         force,
-        environment,
+        cliRuntime,
+        t3CliEnv,
         action: "send a message to",
       });
       const input = {
@@ -78,7 +83,12 @@ export const sendThreadCommand = Command.make(
         threadId,
         ...(options.length > 0 ? { options } : {}),
       };
-      const resolvedFormat = resolveOutputFormat(format, environment, wait ? "ndjson" : "json");
+      const resolvedFormat = resolveOutputFormat(
+        format,
+        cliRuntime,
+        t3CliEnv,
+        wait ? "ndjson" : "json",
+      );
 
       if (resolvedFormat === "ndjson") {
         const sent = yield* application.sendThread(input, { until: wait ? "dispatch" : "visible" });
@@ -101,7 +111,7 @@ export const sendThreadCommand = Command.make(
         }
         yield* printWaitEventsHuman(output, application.watchThread(sent.threadId), {
           threadId: sent.threadId,
-          live: canRenderLiveTerminal(environment),
+          live: canRenderLiveTerminal(cliRuntime, t3CliEnv),
         });
         return yield* Effect.void;
       }

package/src/cli/threads/show.ts

@@ -2,13 +2,15 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Command } from "effect/unstable/cli";
 
+import { extraArgsConfig } from "../extra-args.ts";
 import { formatFlag, threadFlag } from "../flags.ts";
 import { MissingThreadError } from "../error.ts";
-import { resolveThreadId } from "../../scope/index.ts";
-import { formatThreadShowHuman, formatThreadShowJson } from "../thread-format.ts";
+import { resolveThreadId } from "../scope/index.ts";
+import { formatThreadShowHuman, formatThreadShowJson } from "../format/thread.ts";
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
-import { resolveOutputFormat } from "../output-format.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 
 export const showThreadCommand = Command.make(
@@ -16,15 +18,17 @@ export const showThreadCommand = Command.make(
   {
     thread: threadFlag,
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ thread, format }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
       const threadId = resolveThreadId({
         value: Option.getOrUndefined(thread),
-        env: environment.env,
+        scope: t3CliEnv.scope,
       });
       if (threadId === undefined) {
         return yield* Effect.fail(
@@ -33,7 +37,7 @@ export const showThreadCommand = Command.make(
           }),
         );
       }
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const detail = yield* application.showThread(threadId);
       if (resolvedFormat === "json") {
         return yield* output.printJson(formatThreadShowJson(detail));

package/src/cli/threads/start.ts

@@ -3,16 +3,18 @@ import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
 import { Argument, Command, Flag } from "effect/unstable/cli";
 
+import { extraArgsConfig } from "../extra-args.ts";
 import { modelFlags, projectFlag, threadFormatFlag, worktreeFlag } from "../flags.ts";
 import { readInitialMessage } from "../message-input.ts";
 import { buildModelOptions } from "../model-options.ts";
 import { requireCommandProjectRef } from "../require.ts";
-import { resolveWorktreePath } from "../../scope/index.ts";
-import { formatThreadStartedHuman } from "../thread-format.ts";
+import { resolveWorktreePath } from "../scope/index.ts";
+import { formatThreadStartedHuman } from "../format/thread.ts";
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
 import { T3Input } from "../input/service.ts";
-import { canRenderLiveTerminal, resolveOutputFormat } from "../output-format.ts";
+import { canRenderLiveTerminal, resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 import { printWaitEventsHuman, printWaitEventsNdjson } from "../wait-events.ts";
 
@@ -29,6 +31,7 @@ export const startThreadCommand = Command.make(
     ...modelFlags,
     wait: Flag.boolean("wait"),
     format: threadFormatFlag,
+    ...extraArgsConfig,
   },
   ({
     project,
@@ -64,16 +67,13 @@ export const startThreadCommand = Command.make(
         thinking,
       });
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
-      const projectRef = yield* requireCommandProjectRef({
-        project,
-        env: environment.env,
-        cwd: environment.cwd,
-      });
+      const projectRef = yield* requireCommandProjectRef({ project });
       const worktreePath = resolveWorktreePath({
         value: Option.getOrUndefined(worktree),
-        env: environment.env,
+        scope: t3CliEnv.scope,
       });
       const input = {
         message: text,
@@ -86,7 +86,12 @@ export const startThreadCommand = Command.make(
         ...(modelValue !== undefined && modelValue.length > 0 ? { model: modelValue } : {}),
         ...(options.length > 0 ? { options } : {}),
       };
-      const resolvedFormat = resolveOutputFormat(format, environment, wait ? "ndjson" : "json");
+      const resolvedFormat = resolveOutputFormat(
+        format,
+        cliRuntime,
+        t3CliEnv,
+        wait ? "ndjson" : "json",
+      );
 
       if (resolvedFormat === "ndjson") {
         const started = yield* application.startThread(input, {
@@ -117,7 +122,7 @@ export const startThreadCommand = Command.make(
         }
         yield* printWaitEventsHuman(output, application.watchThread(started.threadId), {
           threadId: started.threadId,
-          live: canRenderLiveTerminal(environment),
+          live: canRenderLiveTerminal(cliRuntime, t3CliEnv),
         });
         return;
       }

package/src/cli/threads/unarchive.ts

@@ -2,12 +2,14 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Command } from "effect/unstable/cli";
 
+import { extraArgsConfig } from "../extra-args.ts";
 import { formatFlag, threadFlag } from "../flags.ts";
 import { MissingThreadError } from "../error.ts";
-import { resolveThreadId } from "../../scope/index.ts";
+import { resolveThreadId } from "../scope/index.ts";
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
-import { resolveOutputFormat } from "../output-format.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 
 export const unarchiveThreadCommand = Command.make(
@@ -15,15 +17,17 @@ export const unarchiveThreadCommand = Command.make(
   {
     thread: threadFlag,
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ thread, format }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
       const threadId = resolveThreadId({
         value: Option.getOrUndefined(thread),
-        env: environment.env,
+        scope: t3CliEnv.scope,
       });
       if (threadId === undefined) {
         return yield* Effect.fail(
@@ -32,13 +36,13 @@ export const unarchiveThreadCommand = Command.make(
           }),
         );
       }
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const dispatch = yield* application.unarchiveThread(threadId);
       if (resolvedFormat === "json") {
         return yield* output.printJson(dispatch);
       }
       return yield* output.printInfo(
-        `thread unarchived: ${threadId}\nsequence: ${dispatch.sequence}`,
+        `thread unarchived: ${threadId} (sequence ${dispatch.sequence})`,
       );
     }),
 ).pipe(Command.withDescription("unarchive thread"));

package/src/cli/threads/update.ts

@@ -2,18 +2,20 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Command, Flag } from "effect/unstable/cli";
 
+import { extraArgsConfig } from "../extra-args.ts";
 import { formatFlag, modelFlags, selfActionForceFlag, threadFlag } from "../flags.ts";
 import {
   ConflictingUpdateFlagsError,
   MissingThreadError,
   MissingUpdateFieldsError,
 } from "../error.ts";
-import { requireSelfActionConfirmation } from "../self-action.ts";
+import { requireSelfActionConfirmation } from "../interaction/self-action.ts";
 import { buildModelOptions } from "../model-options.ts";
-import { resolveThreadId } from "../../scope/index.ts";
+import { resolveThreadId } from "../scope/index.ts";
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
-import { resolveOutputFormat } from "../output-format.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 
 export const updateThreadCommand = Command.make(
@@ -30,6 +32,7 @@ export const updateThreadCommand = Command.make(
     worktree: Flag.string("worktree").pipe(Flag.optional),
     clearWorktree: Flag.boolean("clear-worktree").pipe(Flag.optional),
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({
     thread,
@@ -50,11 +53,12 @@ export const updateThreadCommand = Command.make(
   }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
       const threadId = resolveThreadId({
         value: Option.getOrUndefined(thread),
-        env: environment.env,
+        scope: t3CliEnv.scope,
       });
       if (threadId === undefined) {
         return yield* Effect.fail(
@@ -67,7 +71,8 @@ export const updateThreadCommand = Command.make(
       yield* requireSelfActionConfirmation({
         threadId,
         force,
-        environment,
+        cliRuntime,
+        t3CliEnv,
         action: "update",
       });
 
@@ -141,10 +146,10 @@ export const updateThreadCommand = Command.make(
             ? { worktreePath: worktreeValue }
             : {}),
       });
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       if (resolvedFormat === "json") {
         return yield* output.printJson(dispatch);
       }
-      return yield* output.printInfo(`thread updated: ${threadId}\nsequence: ${dispatch.sequence}`);
+      return yield* output.printInfo(`thread updated: ${threadId} (sequence ${dispatch.sequence})`);
     }),
 ).pipe(Command.withDescription("update thread metadata"));

package/src/cli/threads/wait.ts

@@ -2,12 +2,14 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Command } from "effect/unstable/cli";
 
+import { extraArgsConfig } from "../extra-args.ts";
 import { threadFlag, waitFormatFlag } from "../flags.ts";
 import { MissingThreadError } from "../error.ts";
-import { resolveThreadId } from "../../scope/index.ts";
-import { Environment } from "../../environment/service.ts";
+import { resolveThreadId } from "../scope/index.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
 import { T3Application } from "../../application/service.ts";
-import { canRenderLiveTerminal, resolveOutputFormat } from "../output-format.ts";
+import { canRenderLiveTerminal, resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 import { printWaitEventsHuman, printWaitEventsNdjson } from "../wait-events.ts";
 
@@ -16,15 +18,17 @@ export const waitForThreadCommand = Command.make(
   {
     thread: threadFlag,
     format: waitFormatFlag,
+    ...extraArgsConfig,
   },
   ({ thread, format }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
       const threadId = resolveThreadId({
         value: Option.getOrUndefined(thread),
-        env: environment.env,
+        scope: t3CliEnv.scope,
       });
       if (threadId === undefined) {
         return yield* Effect.fail(
@@ -33,13 +37,13 @@ export const waitForThreadCommand = Command.make(
           }),
         );
       }
-      const resolvedFormat = resolveOutputFormat(format, environment, "ndjson");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "ndjson");
       if (resolvedFormat === "ndjson") {
         return yield* printWaitEventsNdjson(output, application.watchThread(threadId));
       }
       return yield* printWaitEventsHuman(output, application.watchThread(threadId), {
         threadId,
-        live: canRenderLiveTerminal(environment),
+        live: canRenderLiveTerminal(cliRuntime, t3CliEnv),
       });
     }),
 ).pipe(Command.withDescription("wait for thread to pause"));

package/src/cli/wait-events.ts

@@ -8,7 +8,7 @@ import type { WaitEvent } from "../application/service.ts";
 import { ThreadSessionError } from "../domain/error.ts";
 import { latestAssistantMessage } from "../domain/thread-lifecycle.ts";
 import type { T3Output } from "./output/service.ts";
-import { formatWaitDoneHuman, formatWaitEventNdjson } from "./thread-format.ts";
+import { formatWaitDoneHuman, formatWaitEventNdjson } from "./format/thread.ts";
 
 export function printWaitEventsNdjson(
   output: T3Output["Service"],