t3code-cli 0.14.1 → 0.15.0

package/src/cli/ask.ts

@@ -0,0 +1,390 @@
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+import type { DispatchResult } from "@t3tools/contracts";
+
+import { T3Application } from "../application/service.ts";
+import { isThreadActive } from "../domain/thread-lifecycle.ts";
+import { ThreadSessionError } from "../domain/error.ts";
+import { loadT3CliEnv } from "../config/env/env.ts";
+import {
+  archivePolicyChoices,
+  cleanupInterruptedAsk,
+  ensureAskTargetAvailable,
+  ensureTrailingNewline,
+  finalizeArchive,
+  inspectAskTurn,
+  resolveAskFormat,
+  selectAskAnswer,
+  waitForAskThread,
+} from "./ask-lifecycle.ts";
+import type { AskExecutionState } from "./ask-lifecycle.ts";
+import { extraArgsConfig } from "./extra-args.ts";
+import {
+  AskNoAnswerError,
+  AskProjectMismatchError,
+  AskThreadBusyError,
+  AskTimeoutError,
+  InvalidAskTimeoutError,
+  InvalidFlagCombinationError,
+} from "./error.ts";
+import { humanJsonNdjsonFormatChoices } from "./format/output.ts";
+import { modelFlags, projectFlag, selfActionForceFlag, worktreeFlag } from "./flags.ts";
+import { T3Input } from "./input/service.ts";
+import { requireSelfActionConfirmation } from "./interaction/self-action.ts";
+import { readInitialMessage } from "./message-input.ts";
+import { buildModelOptions } from "./model-options.ts";
+import { T3Output } from "./output/service.ts";
+import { requireCommandProjectRef } from "./require.ts";
+import { resolveWorktreePath } from "./scope/index.ts";
+import { CliRuntime } from "./runtime/service.ts";
+
+interface AskResponse {
+  readonly answer: string;
+  readonly threadId: string;
+  readonly turnId: string | null;
+  readonly created: boolean;
+  readonly dispatch: DispatchResult;
+}
+
+const askThreadFlag = Flag.string("thread").pipe(
+  Flag.withDescription("Existing thread id; T3CODE_THREAD_ID is not used"),
+  Flag.optional,
+);
+
+const archivePolicyFlag = Flag.choice("archive", archivePolicyChoices).pipe(
+  Flag.withDescription(
+    "Archive policy (default: on-success for created threads, never for existing threads)",
+  ),
+  Flag.optional,
+);
+
+const timeoutFlag = Flag.string("timeout").pipe(
+  Flag.withDescription("Response timeout, such as 30s, 5m, or 1h"),
+  Flag.optional,
+);
+
+const askFormatFlag = Flag.choice("format", humanJsonNdjsonFormatChoices).pipe(
+  Flag.withDefault("human"),
+);
+
+export const askCommand = Command.make(
+  "ask",
+  {
+    project: projectFlag,
+    thread: askThreadFlag,
+    force: selfActionForceFlag,
+    message: Argument.string("message").pipe(Argument.optional),
+    stdin: Flag.boolean("stdin"),
+    title: Flag.string("title").pipe(Flag.optional),
+    worktree: worktreeFlag,
+    provider: Flag.string("provider").pipe(Flag.optional),
+    model: Flag.string("model").pipe(Flag.optional),
+    ...modelFlags,
+    archive: archivePolicyFlag,
+    timeout: timeoutFlag,
+    format: askFormatFlag,
+    ...extraArgsConfig,
+  },
+  ({
+    project,
+    thread,
+    force,
+    message,
+    stdin,
+    title,
+    worktree,
+    provider,
+    model,
+    option,
+    reasoningEffort,
+    effort,
+    fastMode,
+    thinking,
+    archive,
+    timeout,
+    format,
+  }) =>
+    Effect.gen(function* () {
+      const explicitThreadId = Option.getOrUndefined(thread);
+      const created = explicitThreadId === undefined;
+      const titleValue = Option.getOrUndefined(title);
+      const providerValue = Option.getOrUndefined(provider);
+      const modelValue = Option.getOrUndefined(model);
+      const createOnlyFlags = [
+        Option.isSome(title) ? "--title" : null,
+        Option.isSome(worktree) ? "--worktree" : null,
+        Option.isSome(provider) ? "--provider" : null,
+        Option.isSome(model) ? "--model" : null,
+      ].filter((flag): flag is string => flag !== null);
+
+      if (!created && createOnlyFlags.length > 0) {
+        return yield* Effect.fail(
+          new InvalidFlagCombinationError({
+            message: `${createOnlyFlags.join(", ")} cannot be used with --thread`,
+          }),
+        );
+      }
+      if (created && force) {
+        return yield* Effect.fail(
+          new InvalidFlagCombinationError({
+            message: "--force can only be used with --thread",
+          }),
+        );
+      }
+
+      const timeoutValue = Option.getOrUndefined(timeout);
+      const timeoutDuration =
+        timeoutValue === undefined ? undefined : yield* parseAskTimeout(timeoutValue);
+      const archivePolicy = Option.getOrElse(archive, () => (created ? "on-success" : "never"));
+      const application = yield* T3Application;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const input = yield* T3Input;
+      const output = yield* T3Output;
+      const resolvedFormat = resolveAskFormat(format, cliRuntime, t3CliEnv);
+      const options = buildModelOptions({
+        option,
+        reasoningEffort,
+        effort,
+        fastMode,
+        thinking,
+      });
+      const state: AskExecutionState = {
+        archivePolicy,
+        threadId: explicitThreadId,
+        createdThread: false,
+        dispatched: false,
+        askTurnId: null,
+        archiveResult: undefined,
+      };
+
+      const response = Effect.gen(function* () {
+        const text = yield* readInitialMessage({
+          message: Option.getOrUndefined(message),
+          fromStdin: stdin,
+          readStdin: input.readStdin,
+        });
+        let dispatch: DispatchResult;
+        let askMessageId: string;
+
+        if (explicitThreadId === undefined) {
+          const projectRef = yield* requireCommandProjectRef({ project });
+          const resolvedProject = yield* application.resolveProject(projectRef);
+          const worktreePath = resolveWorktreePath({
+            value: Option.getOrUndefined(worktree),
+            scope: t3CliEnv.scope,
+          });
+          const result = yield* application.startThread(
+            {
+              message: text,
+              projectRef: resolvedProject.id,
+              ...(titleValue !== undefined ? { title: titleValue } : {}),
+              ...(worktreePath !== undefined ? { worktreePath } : {}),
+              ...(providerValue !== undefined ? { provider: providerValue } : {}),
+              ...(modelValue !== undefined ? { model: modelValue } : {}),
+              ...(options.length > 0 ? { options } : {}),
+            },
+            {
+              until: "dispatch",
+              onThreadCreated: (threadId) =>
+                Effect.sync(() => {
+                  state.threadId = threadId;
+                  state.createdThread = true;
+                }),
+            },
+          );
+          state.dispatched = true;
+          dispatch = result.dispatch;
+          askMessageId = result.messageId;
+        } else {
+          const summary = yield* application.getThreadSummary(explicitThreadId);
+          yield* ensureAskTargetAvailable(summary);
+
+          const projectRef = Option.getOrUndefined(project);
+          if (projectRef !== undefined) {
+            const resolvedProject = yield* application.resolveProject(projectRef);
+            if (summary.projectId !== resolvedProject.id) {
+              return yield* Effect.fail(
+                new AskProjectMismatchError({
+                  message: `thread ${explicitThreadId} belongs to project ${summary.projectId}, not ${resolvedProject.id}`,
+                  threadId: explicitThreadId,
+                  projectId: resolvedProject.id,
+                }),
+              );
+            }
+          }
+
+          yield* requireSelfActionConfirmation({
+            threadId: explicitThreadId,
+            force,
+            cliRuntime,
+            t3CliEnv,
+            action: "ask",
+          });
+
+          const targetThread = (yield* application.getThreadMessages({
+            threadId: explicitThreadId,
+          })).thread;
+          if (isThreadActive(targetThread)) {
+            return yield* Effect.fail(
+              new AskThreadBusyError({
+                message: `thread is busy: ${explicitThreadId}`,
+                threadId: explicitThreadId,
+              }),
+            );
+          }
+
+          const result = yield* application.sendThread(
+            {
+              threadId: explicitThreadId,
+              message: text,
+              ...(options.length > 0 ? { options } : {}),
+            },
+            { until: "dispatch" },
+          );
+          state.dispatched = true;
+          dispatch = result.dispatch;
+          askMessageId = result.messageId;
+        }
+
+        const threadId = state.threadId;
+        if (threadId === undefined) {
+          return yield* Effect.fail(
+            new AskNoAnswerError({
+              message: "ask did not resolve a thread id",
+              threadId: "unknown",
+            }),
+          );
+        }
+
+        if (resolvedFormat === "ndjson") {
+          yield* output.printNdjson({ type: "dispatch", sequence: dispatch.sequence });
+        }
+        yield* application.awaitShellSequence(dispatch.sequence);
+        yield* waitForAskThread(application, output, {
+          threadId,
+          format: resolvedFormat,
+          messageId: askMessageId,
+          state,
+        });
+
+        const finalSnapshot = yield* application.getThreadMessages({ threadId });
+        const observation = inspectAskTurn(finalSnapshot.thread, askMessageId, state.askTurnId);
+        if (observation.status === "failed") {
+          return yield* Effect.fail(
+            new ThreadSessionError({
+              threadId,
+              message: observation.message,
+            }),
+          );
+        }
+        const answer = selectAskAnswer(finalSnapshot.thread, askMessageId, observation.turnId);
+        if (answer === undefined) {
+          return yield* Effect.fail(
+            new AskNoAnswerError({
+              message: `thread completed without a new final answer: ${threadId}`,
+              threadId,
+            }),
+          );
+        }
+        return {
+          answer: answer.text,
+          threadId,
+          turnId: answer.turnId,
+          created,
+          dispatch,
+        } satisfies AskResponse;
+      });
+
+      const responseWithCleanup = response.pipe(
+        Effect.onInterrupt(() => cleanupInterruptedAsk(application, output, state)),
+      );
+      const timedResponse =
+        timeoutDuration === undefined
+          ? responseWithCleanup
+          : responseWithCleanup.pipe(
+              Effect.timeoutOrElse({
+                duration: timeoutDuration,
+                orElse: () =>
+                  Effect.fail(
+                    new AskTimeoutError({
+                      message: `ask timed out after ${timeoutValue ?? Duration.format(timeoutDuration)}`,
+                      timeout: timeoutValue ?? Duration.format(timeoutDuration),
+                    }),
+                  ),
+              }),
+            );
+
+      return yield* timedResponse.pipe(
+        Effect.matchEffect({
+          onFailure: (error) =>
+            finalizeArchive(application, output, state, false).pipe(
+              Effect.flatMap(() => Effect.fail(error)),
+            ),
+          onSuccess: (result) =>
+            Effect.gen(function* () {
+              const archiveResult = yield* finalizeArchive(application, output, state, true);
+              const formatted = {
+                answer: result.answer,
+                threadId: result.threadId,
+                turnId: result.turnId,
+                created: result.created,
+                dispatch: result.dispatch,
+                archive: archiveResult,
+              };
+              if (resolvedFormat === "json") {
+                return yield* output.printJson(formatted);
+              }
+              if (resolvedFormat === "ndjson") {
+                return yield* output.printNdjson({ type: "result", ...formatted });
+              }
+              return yield* output.writeStdout(ensureTrailingNewline(result.answer));
+            }),
+        }),
+      );
+    }),
+).pipe(Command.withDescription("ask a project or existing thread and wait for one answer"));
+
+function parseAskTimeout(value: string) {
+  const trimmed = value.trim();
+  const shorthand = /^([0-9]+(?:\.[0-9]+)?)(ms|s|m|h|d|w)$/.exec(trimmed);
+  let input = trimmed;
+  if (shorthand !== null) {
+    const amount = shorthand[1];
+    const unit = shorthand[2];
+    const units: Readonly<Record<string, string>> = {
+      ms: "millis",
+      s: "seconds",
+      m: "minutes",
+      h: "hours",
+      d: "days",
+      w: "weeks",
+    };
+    const expandedUnit = unit === undefined ? undefined : units[unit];
+    if (amount !== undefined && expandedUnit !== undefined) {
+      input = `${amount} ${expandedUnit}`;
+    }
+  }
+  const parsed = Schema.decodeUnknownOption(Schema.DurationFromString)(input);
+  if (Option.isNone(parsed)) {
+    return Effect.fail(
+      new InvalidAskTimeoutError({
+        message: `invalid timeout: ${value}`,
+        value,
+      }),
+    );
+  }
+  const millis = Duration.toMillis(parsed.value);
+  if (!Number.isFinite(millis) || millis <= 0) {
+    return Effect.fail(
+      new InvalidAskTimeoutError({
+        message: `timeout must be a positive finite duration: ${value}`,
+        value,
+      }),
+    );
+  }
+  return Effect.succeed(parsed.value);
+}

package/src/cli/error.ts

@@ -39,6 +39,60 @@ export class InvalidFlagCombinationError extends Schema.TaggedErrorClass<Invalid
   },
 ) {}
 
+export class InvalidAskTimeoutError extends Schema.TaggedErrorClass<InvalidAskTimeoutError>()(
+  "InvalidAskTimeoutError",
+  {
+    message: Schema.String,
+    value: Schema.String,
+  },
+) {}
+
+export class AskThreadArchivedError extends Schema.TaggedErrorClass<AskThreadArchivedError>()(
+  "AskThreadArchivedError",
+  {
+    message: Schema.String,
+    threadId: Schema.String,
+  },
+) {}
+
+export class AskThreadBusyError extends Schema.TaggedErrorClass<AskThreadBusyError>()(
+  "AskThreadBusyError",
+  {
+    message: Schema.String,
+    threadId: Schema.String,
+  },
+) {}
+
+export class AskThreadPendingRequestError extends Schema.TaggedErrorClass<AskThreadPendingRequestError>()(
+  "AskThreadPendingRequestError",
+  {
+    message: Schema.String,
+    threadId: Schema.String,
+  },
+) {}
+
+export class AskProjectMismatchError extends Schema.TaggedErrorClass<AskProjectMismatchError>()(
+  "AskProjectMismatchError",
+  {
+    message: Schema.String,
+    threadId: Schema.String,
+    projectId: Schema.String,
+  },
+) {}
+
+export class AskNoAnswerError extends Schema.TaggedErrorClass<AskNoAnswerError>()(
+  "AskNoAnswerError",
+  {
+    message: Schema.String,
+    threadId: Schema.String,
+  },
+) {}
+
+export class AskTimeoutError extends Schema.TaggedErrorClass<AskTimeoutError>()("AskTimeoutError", {
+  message: Schema.String,
+  timeout: Schema.String,
+}) {}
+
 export class MissingRequestError extends Schema.TaggedErrorClass<MissingRequestError>()(
   "MissingRequestError",
   {
@@ -59,3 +113,19 @@ export class ConflictingUpdateFlagsError extends Schema.TaggedErrorClass<Conflic
     message: Schema.String,
   },
 ) {}
+
+export class InvalidSnoozeUntilError extends Schema.TaggedErrorClass<InvalidSnoozeUntilError>()(
+  "InvalidSnoozeUntilError",
+  {
+    message: Schema.String,
+    value: Schema.String,
+  },
+) {}
+
+export class UnavailableSnoozePresetError extends Schema.TaggedErrorClass<UnavailableSnoozePresetError>()(
+  "UnavailableSnoozePresetError",
+  {
+    message: Schema.String,
+    preset: Schema.String,
+  },
+) {}

package/src/cli/format/thread.ts

@@ -1,6 +1,10 @@
-import type { ThreadShow } from "../../application/threads.ts";
+import type { ThreadSearchResult, ThreadShow } from "../../application/threads.ts";
 import type { WaitEvent } from "../../application/service.ts";
-import type { OrchestrationThread, OrchestrationThreadShell } from "@t3tools/contracts";
+import type {
+  OrchestrationThread,
+  OrchestrationThreadDetailSnapshot,
+  OrchestrationThreadShell,
+} from "@t3tools/contracts";
 import { latestAssistantMessage, threadStatus } from "../../domain/thread-lifecycle.ts";
 import { formatChatTranscript, formatRecord, formatTable } from "./human.ts";
 
@@ -98,6 +102,28 @@ export function formatThreadsHuman(threads: ReadonlyArray<OrchestrationThreadShe
   )}\n`;
 }
 
+export function formatThreadSearchHuman(matches: ReadonlyArray<ThreadSearchResult>) {
+  if (matches.length === 0) {
+    return "no matches\n";
+  }
+  return `${matches
+    .map((match) =>
+      formatRecord([
+        { field: "thread", value: match.threadTitle ?? "-" },
+        { field: "thread id", value: match.threadId },
+        { field: "project", value: match.projectTitle ?? "-" },
+        { field: "project id", value: match.projectId },
+        { field: "workspace", value: match.workspaceRoot ?? "-" },
+        { field: "branch", value: match.branch ?? "-" },
+        { field: "worktree", value: match.worktreePath ?? "-" },
+        { field: "source", value: match.source },
+        { field: "created", value: match.messageCreatedAt ?? "-" },
+        { field: "snippet", value: match.snippet },
+      ]),
+    )
+    .join("\n\n")}\n`;
+}
+
 export function formatThreadDeletedHuman(input: {
   readonly threadId: string;
   readonly dispatch: { readonly sequence: number };
@@ -117,9 +143,15 @@ export function formatThreadStartedHuman(input: {
   ])}`;
 }
 
-export function formatThreadMessagesHuman(thread: OrchestrationThread, limit: number) {
-  const messages = limit === 0 ? thread.messages : thread.messages.slice(-limit);
-  return formatChatTranscript(messages);
+export function formatThreadMessagesHuman(
+  snapshot: OrchestrationThreadDetailSnapshot,
+  limit: number,
+) {
+  const messages = limit === 0 ? snapshot.thread.messages : snapshot.thread.messages.slice(-limit);
+  const transcript = formatChatTranscript(messages);
+  return snapshot.page?.hasMore === true && snapshot.page.beforeCursor !== null
+    ? `${transcript}\nearlier turns available\nbefore cursor: ${snapshot.page.beforeCursor}\n`
+    : transcript;
 }
 
 export function formatWaitDoneHuman(thread: OrchestrationThread) {
@@ -129,8 +161,18 @@ export function formatWaitDoneHuman(thread: OrchestrationThread) {
   }`;
 }
 
-export function formatThreadMessagesJson(thread: OrchestrationThread, full: boolean) {
-  return full ? thread : { thread: stripThreadMessages(thread), messages: thread.messages };
+export function formatThreadMessagesJson(
+  snapshot: OrchestrationThreadDetailSnapshot,
+  full: boolean,
+) {
+  return full
+    ? { ...snapshot, page: snapshot.page ?? null }
+    : {
+        snapshotSequence: snapshot.snapshotSequence,
+        thread: stripThreadMessages(snapshot.thread),
+        messages: snapshot.thread.messages,
+        page: snapshot.page ?? null,
+      };
 }
 
 export function formatWaitEventNdjson(event: WaitEvent) {

package/src/cli/search.ts

@@ -0,0 +1,48 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+import { T3Application } from "../application/service.ts";
+import { loadT3CliEnv } from "../config/env/env.ts";
+import { InvalidLimitError } from "./error.ts";
+import { extraArgsConfig } from "./extra-args.ts";
+import { formatFlag } from "./flags.ts";
+import { formatThreadSearchHuman } from "./format/thread.ts";
+import { resolveOutputFormat } from "./format/output.ts";
+import { T3Output } from "./output/service.ts";
+import { CliRuntime } from "./runtime/service.ts";
+
+export const searchThreadsCommand = Command.make(
+  "search",
+  {
+    query: Argument.string("query"),
+    limit: Flag.integer("limit").pipe(
+      Flag.withDescription("Maximum matches (1-50, default: 50)"),
+      Flag.optional,
+    ),
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ query, limit, format }) =>
+    Effect.gen(function* () {
+      const value = Option.getOrUndefined(limit);
+      if (value !== undefined && (value < 1 || value > 50)) {
+        return yield* Effect.fail(
+          new InvalidLimitError({ message: `invalid limit: ${value}`, value: String(value) }),
+        );
+      }
+      const application = yield* T3Application;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const output = yield* T3Output;
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+      const matches = yield* application.searchThreads({
+        query,
+        ...(value !== undefined ? { limit: value } : {}),
+      });
+      if (resolvedFormat === "json") {
+        return yield* output.printJson(matches);
+      }
+      return yield* output.writeStdout(formatThreadSearchHuman(matches));
+    }),
+).pipe(Command.withDescription("search threads by conversation content"));

package/src/cli/thread.ts

@@ -5,8 +5,14 @@ import { archiveThreadCommand } from "./threads/archive.ts";
 import { callbackThreadCommand } from "./threads/callback.ts";
 import { deleteThreadCommand } from "./threads/delete.ts";
 import { interruptThreadCommand } from "./threads/interrupt.ts";
+import { pinThreadCommand } from "./threads/pin.ts";
 import { respondThreadCommand } from "./threads/respond.ts";
+import { settleThreadCommand } from "./threads/settle.ts";
+import { snoozeThreadCommand } from "./threads/snooze.ts";
 import { unarchiveThreadCommand } from "./threads/unarchive.ts";
+import { unpinThreadCommand } from "./threads/unpin.ts";
+import { unsnoozeThreadCommand } from "./threads/unsnooze.ts";
+import { unsettleThreadCommand } from "./threads/unsettle.ts";
 import { updateThreadCommand } from "./threads/update.ts";
 
 export function createThreadCommand() {
@@ -17,6 +23,12 @@ export function createThreadCommand() {
       respondThreadCommand,
       archiveThreadCommand,
       interruptThreadCommand,
+      settleThreadCommand,
+      unsettleThreadCommand,
+      snoozeThreadCommand,
+      unsnoozeThreadCommand,
+      pinThreadCommand,
+      unpinThreadCommand,
       unarchiveThreadCommand,
       updateThreadCommand,
       deleteThreadCommand,

package/src/cli/threads/messages.ts

@@ -4,7 +4,7 @@ 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 { InvalidFlagCombinationError, InvalidLimitError } from "../error.ts";
 import { MissingThreadError } from "../error.ts";
 import { resolveThreadId } from "../scope/index.ts";
 import { formatThreadMessagesHuman, formatThreadMessagesJson } from "../format/thread.ts";
@@ -19,17 +19,37 @@ export const getThreadTranscriptCommand = Command.make(
   {
     thread: threadFlag,
     limit: Flag.integer("limit").pipe(Flag.withDefault(20)),
+    turnLimit: Flag.integer("turn-limit").pipe(Flag.optional),
+    beforeCursor: Flag.string("before-cursor").pipe(Flag.optional),
+    all: Flag.boolean("all"),
     full: Flag.boolean("full"),
     format: formatFlag,
     ...extraArgsConfig,
   },
-  ({ thread, limit, full, format }) =>
+  ({ thread, limit, turnLimit, beforeCursor, all, full, format }) =>
     Effect.gen(function* () {
       if (limit < 0) {
         return yield* Effect.fail(
           new InvalidLimitError({ message: `invalid limit: ${limit}`, value: String(limit) }),
         );
       }
+      const turnLimitValue = Option.getOrUndefined(turnLimit);
+      const beforeCursorValue = Option.getOrUndefined(beforeCursor);
+      if (turnLimitValue !== undefined && turnLimitValue <= 0) {
+        return yield* Effect.fail(
+          new InvalidLimitError({
+            message: `invalid turn limit: ${turnLimitValue}`,
+            value: String(turnLimitValue),
+          }),
+        );
+      }
+      if (all && (turnLimitValue !== undefined || beforeCursorValue !== undefined)) {
+        return yield* Effect.fail(
+          new InvalidFlagCombinationError({
+            message: "--all cannot be combined with --turn-limit or --before-cursor",
+          }),
+        );
+      }
       const application = yield* T3Application;
       const cliRuntime = yield* CliRuntime;
       const t3CliEnv = yield* loadT3CliEnv;
@@ -46,7 +66,17 @@ export const getThreadTranscriptCommand = Command.make(
         );
       }
       const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
-      const detail = yield* application.getThreadMessages(threadId);
+      const detail = yield* application.getThreadMessages({
+        threadId,
+        ...(!all
+          ? {
+              window: {
+                turnLimit: turnLimitValue ?? (beforeCursorValue === undefined ? 10 : 20),
+                ...(beforeCursorValue !== undefined ? { beforeCursor: beforeCursorValue } : {}),
+              },
+            }
+          : {}),
+      });
       if (resolvedFormat === "json") {
         return yield* output.printJson(formatThreadMessagesJson(detail, full));
       }