t3code-cli 0.1.0

package/src/cli/output-format.ts

@@ -0,0 +1,41 @@
+import type { EnvironmentShape } from "../environment/service.ts";
+
+export const humanJsonFormatChoices = ["auto", "human", "json"] as const;
+export const humanNdjsonFormatChoices = ["auto", "human", "ndjson"] as const;
+export const humanJsonNdjsonFormatChoices = ["auto", "human", "json", "ndjson"] as const;
+
+export type HumanJsonFormat = (typeof humanJsonFormatChoices)[number];
+export type HumanNdjsonFormat = (typeof humanNdjsonFormatChoices)[number];
+export type HumanJsonNdjsonFormat = (typeof humanJsonNdjsonFormatChoices)[number];
+
+export function resolveOutputFormat<T extends "json" | "ndjson">(
+  format: "auto" | "human" | T,
+  environment: EnvironmentShape,
+  nonHumanFormat: T,
+): "human" | T {
+  if (format !== "auto") {
+    return format;
+  }
+  return isHumanTerminal(environment) ? "human" : nonHumanFormat;
+}
+
+export function canRenderLiveTerminal(environment: EnvironmentShape) {
+  return (
+    environment.stderrIsTTY && environment.env.TERM !== "dumb" && !isAgentEnvironment(environment)
+  );
+}
+
+function isHumanTerminal(environment: EnvironmentShape) {
+  return (
+    environment.stdoutIsTTY && !isAgentEnvironment(environment) && environment.env.TERM !== "dumb"
+  );
+}
+
+function isAgentEnvironment(environment: EnvironmentShape) {
+  return (
+    environment.env.CI !== undefined ||
+    environment.env.CODEX_CI !== undefined ||
+    environment.env.CODEX_THREAD_ID !== undefined ||
+    environment.env.T3CLI_AGENT !== undefined
+  );
+}

package/src/cli/project-format.ts

@@ -0,0 +1,11 @@
+import type { ProjectShell } from "../domain/schema.ts";
+
+export function formatProjectsHuman(projects: ReadonlyArray<ProjectShell>) {
+  return projects
+    .map((project) => `- ${project.title}\n  id: ${project.id}\n  path: ${project.workspaceRoot}\n`)
+    .join("");
+}
+
+export function formatProjectAddedHuman(project: ProjectShell) {
+  return `project added: ${project.title}\nid: ${project.id}\npath: ${project.workspaceRoot}`;
+}

package/src/cli/projects.ts

@@ -0,0 +1,62 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+import { formatProjectAddedHuman, formatProjectsHuman } from "./project-format.ts";
+import { T3Application } from "../application/service.ts";
+import { Environment } from "../environment/service.ts";
+import { humanJsonFormatChoices, resolveOutputFormat } from "./output-format.ts";
+import { T3Output } from "./output/service.ts";
+
+export function createProjectsCommand() {
+  return Command.make("projects").pipe(
+    Command.withDescription("project commands"),
+    Command.withSubcommands([listCommand, addCommand]),
+  );
+}
+
+const listCommand = Command.make(
+  "list",
+  {
+    format: Flag.choice("format", humanJsonFormatChoices).pipe(Flag.withDefault("auto")),
+  },
+  ({ format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const snapshot = yield* application.loadShell();
+      if (resolvedFormat === "json") {
+        yield* output.printJson(snapshot.projects);
+      } else {
+        yield* output.writeStdout(formatProjectsHuman(snapshot.projects));
+      }
+    }),
+).pipe(Command.withDescription("list projects"));
+
+const addCommand = Command.make(
+  "add",
+  {
+    path: Argument.string("path"),
+    title: Flag.string("title").pipe(Flag.optional),
+    format: Flag.choice("format", humanJsonFormatChoices).pipe(Flag.withDefault("auto")),
+  },
+  ({ path, title, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const titleValue = Option.getOrUndefined(title);
+      const result = yield* application.addProject({
+        path,
+        ...(titleValue !== undefined && titleValue.length > 0 ? { title: titleValue } : {}),
+      });
+      if (resolvedFormat === "json") {
+        yield* output.printJson(result);
+      } else {
+        yield* output.printInfo(formatProjectAddedHuman(result.project));
+      }
+    }),
+).pipe(Command.withDescription("add project"));

package/src/cli/thread-format.ts

@@ -0,0 +1,74 @@
+import type { WaitEvent } from "../application/service.ts";
+import type { ThreadDetail, ThreadShell } from "../domain/schema.ts";
+import { latestAssistantMessage, threadStatus } from "../domain/thread-lifecycle.ts";
+
+export function formatThreadsHuman(threads: ReadonlyArray<ThreadShell>) {
+  return threads
+    .map(
+      (thread) =>
+        `- ${thread.title}\n  id: ${thread.id}\n  status: ${threadStatus(thread)}\n  updated: ${thread.updatedAt}\n`,
+    )
+    .join("");
+}
+
+export function formatThreadStartedHuman(input: {
+  readonly thread: ThreadDetail;
+  readonly sequence: number;
+}) {
+  return `thread started: ${input.thread.title}\nid: ${input.thread.id}\nstatus: ${threadStatus(input.thread)}\nsequence: ${input.sequence}`;
+}
+
+export function formatThreadMessagesHuman(thread: ThreadDetail, limit: number) {
+  const messages = limit === 0 ? thread.messages : thread.messages.slice(-limit);
+  return messages.map((message) => `\n### ${message.role}\n\n${message.text}\n`).join("");
+}
+
+export function formatWaitDoneHuman(thread: ThreadDetail) {
+  const latest = latestAssistantMessage(thread);
+  return `status: ${threadStatus(thread)}\n${latest !== undefined ? `\n### ${latest.role}\n\n${latest.text}\n` : ""}`;
+}
+
+export function formatThreadMessagesJson(thread: ThreadDetail, full: boolean) {
+  return full ? thread : { thread: stripThreadMessages(thread), messages: thread.messages };
+}
+
+export function formatWaitEventNdjson(event: WaitEvent) {
+  if (event.type !== "thread" && event.type !== "done") {
+    return event;
+  }
+  const compactThread = stripThreadHeavy(event.thread);
+  return event.type === "done"
+    ? {
+        type: "done",
+        thread: compactThread,
+        latestAssistantMessage: latestAssistantMessage(event.thread) ?? null,
+      }
+    : {
+        type: "thread",
+        thread: compactThread,
+        messageCount: event.thread.messages.length,
+      };
+}
+
+function stripThreadMessages<T extends { readonly messages: unknown }>(thread: T) {
+  const { messages: _messages, ...rest } = thread;
+  return rest;
+}
+
+function stripThreadHeavy<
+  T extends {
+    readonly messages: unknown;
+    readonly activities?: unknown;
+    readonly proposedPlans?: unknown;
+    readonly checkpoints?: unknown;
+  },
+>(thread: T) {
+  const {
+    messages: _messages,
+    activities: _activities,
+    proposedPlans: _proposedPlans,
+    checkpoints: _checkpoints,
+    ...rest
+  } = thread;
+  return rest;
+}

package/src/cli/threads/archive.ts

@@ -0,0 +1,28 @@
+import * as Effect from "effect/Effect";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+import { T3Application } from "../../application/service.ts";
+import { Environment } from "../../environment/service.ts";
+import { humanJsonFormatChoices, resolveOutputFormat } from "../output-format.ts";
+import { T3Output } from "../output/service.ts";
+
+export const archiveThreadCommand = Command.make(
+  "archive",
+  {
+    thread: Argument.string("thread"),
+    format: Flag.choice("format", humanJsonFormatChoices).pipe(Flag.withDefault("auto")),
+  },
+  ({ thread, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const dispatch = yield* application.archiveThread(thread);
+      if (resolvedFormat === "json") {
+        yield* output.printJson(dispatch);
+      } else {
+        yield* output.printInfo(`thread archived: ${thread}\nsequence: ${dispatch.sequence}`);
+      }
+    }),
+).pipe(Command.withDescription("archive thread"));

package/src/cli/threads/list.ts

@@ -0,0 +1,29 @@
+import * as Effect from "effect/Effect";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+import { formatThreadsHuman } from "../thread-format.ts";
+import { T3Application } from "../../application/service.ts";
+import { Environment } from "../../environment/service.ts";
+import { humanJsonFormatChoices, resolveOutputFormat } from "../output-format.ts";
+import { T3Output } from "../output/service.ts";
+
+export const listThreadsCommand = Command.make(
+  "list",
+  {
+    project: Argument.string("project"),
+    format: Flag.choice("format", humanJsonFormatChoices).pipe(Flag.withDefault("auto")),
+  },
+  ({ project, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const result = yield* application.listThreads(project);
+      if (resolvedFormat === "json") {
+        yield* output.printJson(result.threads);
+      } else {
+        yield* output.writeStdout(formatThreadsHuman(result.threads));
+      }
+    }),
+).pipe(Command.withDescription("list project threads"));

package/src/cli/threads/messages.ts

@@ -0,0 +1,36 @@
+import * as Effect from "effect/Effect";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+import { InvalidLimitError } from "../error.ts";
+import { formatThreadMessagesHuman, formatThreadMessagesJson } from "../thread-format.ts";
+import { T3Application } from "../../application/service.ts";
+import { Environment } from "../../environment/service.ts";
+import { humanJsonFormatChoices, resolveOutputFormat } from "../output-format.ts";
+import { T3Output } from "../output/service.ts";
+
+export const getThreadMessagesCommand = Command.make(
+  "messages",
+  {
+    thread: Argument.string("thread"),
+    limit: Flag.integer("limit").pipe(Flag.withDefault(20)),
+    full: Flag.boolean("full"),
+    format: Flag.choice("format", humanJsonFormatChoices).pipe(Flag.withDefault("auto")),
+  },
+  ({ thread, limit, full, format }) =>
+    Effect.gen(function* () {
+      if (limit < 0) {
+        return yield* Effect.fail(
+          new InvalidLimitError({ message: `invalid limit: ${limit}`, value: String(limit) }),
+        );
+      }
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const detail = yield* application.getThreadMessages(thread);
+      if (resolvedFormat === "json") {
+        return yield* output.printJson(formatThreadMessagesJson(detail, full));
+      }
+      return yield* output.writeStdout(formatThreadMessagesHuman(detail, limit));
+    }),
+).pipe(Command.withDescription("get latest thread messages"));

package/src/cli/threads/send.ts

@@ -0,0 +1,91 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+import { readInitialMessage } from "../message-input.ts";
+import { buildModelOptions } from "../model-options.ts";
+import { T3Application } from "../../application/service.ts";
+import { Environment } from "../../environment/service.ts";
+import { T3Input } from "../input/service.ts";
+import {
+  canRenderLiveTerminal,
+  humanJsonNdjsonFormatChoices,
+  resolveOutputFormat,
+} from "../output-format.ts";
+import { T3Output } from "../output/service.ts";
+import { printWaitEventsHuman, printWaitEventsNdjson } from "../wait-events.ts";
+
+export const sendThreadCommand = Command.make(
+  "send",
+  {
+    thread: Argument.string("thread"),
+    message: Argument.string("message").pipe(Argument.optional),
+    stdin: Flag.boolean("stdin"),
+    option: Flag.keyValuePair("option").pipe(Flag.optional),
+    reasoningEffort: Flag.string("reasoning-effort").pipe(Flag.optional),
+    effort: Flag.string("effort").pipe(Flag.optional),
+    fastMode: Flag.boolean("fast-mode").pipe(Flag.optional),
+    thinking: Flag.boolean("thinking").pipe(Flag.optional),
+    wait: Flag.boolean("wait"),
+    format: Flag.choice("format", humanJsonNdjsonFormatChoices).pipe(Flag.withDefault("auto")),
+  },
+  ({ thread, message, stdin, option, reasoningEffort, effort, fastMode, thinking, wait, format }) =>
+    Effect.gen(function* () {
+      const inputService = yield* T3Input;
+      const text = yield* readInitialMessage({
+        message: Option.getOrUndefined(message),
+        fromStdin: stdin,
+        readStdin: inputService.readStdin,
+      });
+      const options = buildModelOptions({
+        option,
+        reasoningEffort,
+        effort,
+        fastMode,
+        thinking,
+      });
+      const input = {
+        message: text,
+        threadId: thread,
+        ...(options.length > 0 ? { options } : {}),
+      };
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const resolvedFormat = resolveOutputFormat(format, environment, wait ? "ndjson" : "json");
+
+      if (resolvedFormat === "ndjson") {
+        const sent = yield* application.sendThread(input, { until: wait ? "dispatch" : "visible" });
+        yield* output.printNdjson({ type: "dispatch", sequence: sent.dispatch.sequence });
+        if (wait) {
+          yield* printWaitEventsNdjson(output, application.watchThread(sent.threadId));
+        }
+        return;
+      }
+
+      if (wait) {
+        const sent = yield* application.sendThread(input, { until: "dispatch" });
+        if (resolvedFormat === "json") {
+          const finalThread = yield* application.waitForThread(sent.threadId);
+          yield* output.printJson({
+            dispatch: sent.dispatch,
+            threadId: sent.threadId,
+            thread: finalThread,
+          });
+          return;
+        }
+        yield* printWaitEventsHuman(output, application.watchThread(sent.threadId), {
+          threadId: sent.threadId,
+          live: canRenderLiveTerminal(environment),
+        });
+        return;
+      }
+
+      const result = yield* application.sendThread(input, { until: "visible" });
+      if (resolvedFormat === "json") {
+        yield* output.printJson(result);
+      } else {
+        yield* output.printInfo(`message sent: ${result.threadId}`);
+      }
+    }),
+).pipe(Command.withDescription("send message to existing thread"));

package/src/cli/threads/start.ts

@@ -0,0 +1,136 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+import { readInitialMessage } from "../message-input.ts";
+import { buildModelOptions } from "../model-options.ts";
+import { formatThreadStartedHuman } from "../thread-format.ts";
+import { T3Application } from "../../application/service.ts";
+import { Environment } from "../../environment/service.ts";
+import { T3Input } from "../input/service.ts";
+import {
+  canRenderLiveTerminal,
+  humanJsonNdjsonFormatChoices,
+  resolveOutputFormat,
+} from "../output-format.ts";
+import { T3Output } from "../output/service.ts";
+import { printWaitEventsHuman, printWaitEventsNdjson } from "../wait-events.ts";
+
+export const startThreadCommand = Command.make(
+  "start",
+  {
+    project: Argument.string("project"),
+    message: Argument.string("message").pipe(Argument.optional),
+    stdin: Flag.boolean("stdin"),
+    title: Flag.string("title").pipe(Flag.optional),
+    worktree: Flag.string("worktree").pipe(Flag.optional),
+    provider: Flag.string("provider").pipe(Flag.optional),
+    model: Flag.string("model").pipe(Flag.optional),
+    option: Flag.keyValuePair("option").pipe(Flag.optional),
+    reasoningEffort: Flag.string("reasoning-effort").pipe(Flag.optional),
+    effort: Flag.string("effort").pipe(Flag.optional),
+    fastMode: Flag.boolean("fast-mode").pipe(Flag.optional),
+    thinking: Flag.boolean("thinking").pipe(Flag.optional),
+    wait: Flag.boolean("wait"),
+    format: Flag.choice("format", humanJsonNdjsonFormatChoices).pipe(Flag.withDefault("auto")),
+  },
+  ({
+    project,
+    message,
+    stdin,
+    title,
+    worktree,
+    provider,
+    model,
+    option,
+    reasoningEffort,
+    effort,
+    fastMode,
+    thinking,
+    wait,
+    format,
+  }) =>
+    Effect.gen(function* () {
+      const inputService = yield* T3Input;
+      const text = yield* readInitialMessage({
+        message: Option.getOrUndefined(message),
+        fromStdin: stdin,
+        readStdin: inputService.readStdin,
+      });
+      const titleValue = Option.getOrUndefined(title);
+      const worktreeValue = Option.getOrUndefined(worktree);
+      const providerValue = Option.getOrUndefined(provider);
+      const modelValue = Option.getOrUndefined(model);
+      const options = buildModelOptions({
+        option,
+        reasoningEffort,
+        effort,
+        fastMode,
+        thinking,
+      });
+      const input = {
+        projectRef: project,
+        message: text,
+        ...(titleValue !== undefined && titleValue.length > 0 ? { title: titleValue } : {}),
+        ...(worktreeValue !== undefined && worktreeValue.length > 0
+          ? { worktreePath: worktreeValue }
+          : {}),
+        ...(providerValue !== undefined && providerValue.length > 0
+          ? { provider: providerValue }
+          : {}),
+        ...(modelValue !== undefined && modelValue.length > 0 ? { model: modelValue } : {}),
+        ...(options.length > 0 ? { options } : {}),
+      };
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const resolvedFormat = resolveOutputFormat(format, environment, wait ? "ndjson" : "json");
+
+      if (resolvedFormat === "ndjson") {
+        const started = yield* application.startThread(input, {
+          until: wait ? "dispatch" : "visible",
+        });
+        yield* output.printNdjson({ type: "dispatch", sequence: started.dispatch.sequence });
+        if (wait) {
+          yield* printWaitEventsNdjson(output, application.watchThread(started.threadId));
+        } else {
+          yield* printWaitEventsNdjson(
+            output,
+            Stream.fromIterable([{ type: "thread", thread: started.thread! }]),
+          );
+        }
+        return;
+      }
+
+      if (wait) {
+        const started = yield* application.startThread(input, { until: "dispatch" });
+        if (resolvedFormat === "json") {
+          const thread = yield* application.waitForThread(started.threadId);
+          yield* output.printJson({
+            dispatch: started.dispatch,
+            threadId: started.threadId,
+            thread,
+          });
+          return;
+        }
+        yield* printWaitEventsHuman(output, application.watchThread(started.threadId), {
+          threadId: started.threadId,
+          live: canRenderLiveTerminal(environment),
+        });
+        return;
+      }
+
+      const result = yield* application.startThread(input, { until: "visible" });
+      if (resolvedFormat === "json") {
+        yield* output.printJson(result);
+      } else {
+        yield* output.printInfo(
+          formatThreadStartedHuman({
+            thread: result.thread!,
+            sequence: result.dispatch.sequence,
+          }),
+        );
+      }
+    }),
+).pipe(Command.withDescription("start thread with initial message"));

package/src/cli/threads/wait.ts

@@ -0,0 +1,35 @@
+import * as Effect from "effect/Effect";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+import { Environment } from "../../environment/service.ts";
+import { T3Application } from "../../application/service.ts";
+import {
+  canRenderLiveTerminal,
+  humanNdjsonFormatChoices,
+  resolveOutputFormat,
+} from "../output-format.ts";
+import { T3Output } from "../output/service.ts";
+import { printWaitEventsHuman, printWaitEventsNdjson } from "../wait-events.ts";
+
+export const waitForThreadCommand = Command.make(
+  "wait",
+  {
+    thread: Argument.string("thread"),
+    format: Flag.choice("format", humanNdjsonFormatChoices).pipe(Flag.withDefault("auto")),
+  },
+  ({ thread, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const resolvedFormat = resolveOutputFormat(format, environment, "ndjson");
+      if (resolvedFormat === "ndjson") {
+        yield* printWaitEventsNdjson(output, application.watchThread(thread));
+        return;
+      }
+      yield* printWaitEventsHuman(output, application.watchThread(thread), {
+        threadId: thread,
+        live: canRenderLiveTerminal(environment),
+      });
+    }),
+).pipe(Command.withDescription("wait for thread to pause"));

package/src/cli/threads.ts

@@ -0,0 +1,22 @@
+import { Command } from "effect/unstable/cli";
+
+import { archiveThreadCommand } from "./threads/archive.ts";
+import { listThreadsCommand } from "./threads/list.ts";
+import { getThreadMessagesCommand } from "./threads/messages.ts";
+import { sendThreadCommand } from "./threads/send.ts";
+import { startThreadCommand } from "./threads/start.ts";
+import { waitForThreadCommand } from "./threads/wait.ts";
+
+export function createThreadsCommand() {
+  return Command.make("threads").pipe(
+    Command.withDescription("thread commands"),
+    Command.withSubcommands([
+      listThreadsCommand,
+      startThreadCommand,
+      sendThreadCommand,
+      archiveThreadCommand,
+      getThreadMessagesCommand,
+      waitForThreadCommand,
+    ]),
+  );
+}

package/src/cli/wait-events.ts

@@ -0,0 +1,112 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import * as Terminal from "effect/Terminal";
+
+import type { ApplicationError } from "../application/error.ts";
+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";
+
+export function printWaitEventsNdjson(
+  output: T3Output["Service"],
+  events: Stream.Stream<WaitEvent, ApplicationError>,
+) {
+  return events.pipe(
+    Stream.tap((event) => output.printNdjson(formatWaitEventNdjson(event))),
+    Stream.runDrain,
+  );
+}
+
+export function printWaitEventsHuman(
+  output: T3Output["Service"],
+  events: Stream.Stream<WaitEvent, ApplicationError>,
+  options: {
+    readonly threadId: string;
+    readonly live: boolean;
+  },
+) {
+  let latest = "";
+  let status = `waiting for ${options.threadId}`;
+  let rendered = false;
+  let columns = 0;
+
+  const render = () => {
+    if (!options.live) {
+      return Effect.void;
+    }
+    rendered = true;
+    return output.writeStderr(
+      `\r\x1b[2K${fitLine(`${status}${latest.length > 0 ? ` | ${latest}` : ""}`, columns)}`,
+    );
+  };
+
+  return Effect.gen(function* () {
+    if (options.live) {
+      const terminal = yield* Terminal.Terminal;
+      columns = yield* terminal.columns;
+    }
+    if (options.live) {
+      yield* render();
+    } else {
+      yield* output.writeStderr(`${status}...\n`);
+    }
+
+    yield* events.pipe(
+      Stream.tap((event) => {
+        if (event.type === "thread") {
+          const message = latestAssistantMessage(event.thread);
+          if (message !== undefined) {
+            latest = compactLine(message.text);
+          }
+          return render();
+        }
+        if (event.type === "message") {
+          if (event.message.role === "assistant") {
+            latest = compactLine(event.message.text);
+          }
+          return render();
+        }
+        if (event.type === "status") {
+          status = `${event.threadId}: ${event.status}`;
+          return render();
+        }
+        return Effect.gen(function* () {
+          if (rendered) {
+            yield* output.writeStderr("\r\x1b[2K");
+          }
+          yield* output.writeStdout(formatWaitDoneHuman(event.thread));
+        });
+      }),
+      Stream.runLast,
+      Effect.flatMap((event) => {
+        if (Option.isSome(event) && event.value.type === "done") {
+          return Effect.void;
+        }
+        return Effect.fail(
+          new ThreadSessionError({
+            message: `thread wait ended without done event: ${options.threadId}`,
+            threadId: options.threadId,
+          }),
+        );
+      }),
+    );
+  });
+}
+
+function compactLine(text: string) {
+  const compact = text.replace(/\s+/g, " ").trim();
+  return compact.length <= 120 ? compact : `...${compact.slice(-117)}`;
+}
+
+function fitLine(text: string, columns: number) {
+  if (columns <= 0 || text.length <= columns) {
+    return text;
+  }
+  if (columns <= 3) {
+    return text.slice(0, columns);
+  }
+  return `${text.slice(0, columns - 3)}...`;
+}