t3code-cli 0.9.1 → 0.11.0

package/src/cli/thread-format.test.ts

@@ -0,0 +1,32 @@
+import "vite-plus/test/config";
+
+import { assert, describe, it } from "@effect/vitest";
+import { fromPartial } from "@total-typescript/shoehorn";
+import type { OrchestrationThreadShell } from "#t3tools/contracts";
+
+import { formatThreadsHuman } from "./thread-format.ts";
+
+describe("formatThreadsHuman", () => {
+  it("appends (archived) for archived threads", () => {
+    const threads: OrchestrationThreadShell[] = [
+      fromPartial({
+        id: "active-1",
+        title: "Active thread",
+        archivedAt: null,
+        updatedAt: "2026-01-01T00:00:00.000Z",
+        session: null,
+      }),
+      fromPartial({
+        id: "archived-1",
+        title: "Archived thread",
+        archivedAt: "2026-01-02T00:00:00.000Z",
+        updatedAt: "2026-01-02T00:00:00.000Z",
+        session: null,
+      }),
+    ];
+
+    const output = formatThreadsHuman(threads);
+    assert.include(output, "- Active thread\n");
+    assert.include(output, "- Archived thread (archived)\n");
+  });
+});

package/src/cli/thread-format.ts

@@ -53,11 +53,18 @@ export function formatThreadsHuman(threads: ReadonlyArray<OrchestrationThreadShe
   return threads
     .map(
       (thread) =>
-        `- ${thread.title}\n  id: ${thread.id}\n  status: ${threadStatus(thread)}\n  updated: ${thread.updatedAt}\n`,
+        `- ${thread.title}${thread.archivedAt !== null ? " (archived)" : ""}\n  id: ${thread.id}\n  status: ${threadStatus(thread)}\n  updated: ${thread.updatedAt}\n`,
     )
     .join("");
 }
 
+export function formatThreadDeletedHuman(input: {
+  readonly threadId: string;
+  readonly dispatch: { readonly sequence: number };
+}) {
+  return `thread deleted: ${input.threadId}\nsequence: ${input.dispatch.sequence}`;
+}
+
 export function formatThreadStartedHuman(input: {
   readonly thread: OrchestrationThread;
   readonly sequence: number;

package/src/cli/thread.ts

@@ -3,27 +3,23 @@ import { Command } from "effect/unstable/cli";
 import { approveThreadCommand } from "./threads/approve.ts";
 import { archiveThreadCommand } from "./threads/archive.ts";
 import { callbackThreadCommand } from "./threads/callback.ts";
-import { listThreadsCommand } from "./threads/list.ts";
-import { getThreadMessagesCommand } from "./threads/messages.ts";
+import { deleteThreadCommand } from "./threads/delete.ts";
+import { interruptThreadCommand } from "./threads/interrupt.ts";
 import { respondThreadCommand } from "./threads/respond.ts";
-import { sendThreadCommand } from "./threads/send.ts";
-import { showThreadCommand } from "./threads/show.ts";
-import { startThreadCommand } from "./threads/start.ts";
-import { waitForThreadCommand } from "./threads/wait.ts";
+import { unarchiveThreadCommand } from "./threads/unarchive.ts";
+import { updateThreadCommand } from "./threads/update.ts";
 
 export function createThreadCommand() {
   return Command.make("thread").pipe(
-    Command.withDescription("thread commands"),
+    Command.withDescription("advanced thread commands"),
     Command.withSubcommands([
-      listThreadsCommand,
-      startThreadCommand,
-      sendThreadCommand,
-      showThreadCommand,
       approveThreadCommand,
       respondThreadCommand,
       archiveThreadCommand,
-      getThreadMessagesCommand,
-      waitForThreadCommand,
+      interruptThreadCommand,
+      unarchiveThreadCommand,
+      updateThreadCommand,
+      deleteThreadCommand,
       callbackThreadCommand,
     ]),
   );

package/src/cli/threads/archive.ts

@@ -1,9 +1,10 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
-import { Command, Flag } from "effect/unstable/cli";
+import { Command } from "effect/unstable/cli";
 
-import { formatFlag, threadFlag } from "../flags.ts";
-import { MissingThreadError, SelfArchiveError } from "../error.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 { T3Application } from "../../application/service.ts";
 import { Environment } from "../../environment/service.ts";
@@ -14,7 +15,7 @@ export const archiveThreadCommand = Command.make(
   "archive",
   {
     thread: threadFlag,
-    force: Flag.boolean("force").pipe(Flag.withAlias("f")),
+    force: selfActionForceFlag,
     format: formatFlag,
   },
   ({ thread, force, format }) =>
@@ -33,20 +34,12 @@ export const archiveThreadCommand = Command.make(
           }),
         );
       }
-      const envThreadId = environment.env.T3CODE_THREAD_ID;
-      if (
-        envThreadId !== undefined &&
-        envThreadId.length > 0 &&
-        threadId === envThreadId &&
-        !force
-      ) {
-        return yield* Effect.fail(
-          new SelfArchiveError({
-            threadId,
-            message: `cannot archive thread ${threadId}: matches T3CODE_THREAD_ID (are you trying to archive yourself?). Use --force to override.`,
-          }),
-        );
-      }
+      yield* requireSelfActionConfirmation({
+        threadId,
+        force,
+        environment,
+        action: "archive",
+      });
       const resolvedFormat = resolveOutputFormat(format, environment, "json");
       const dispatch = yield* application.archiveThread(threadId);
       if (resolvedFormat === "json") {

package/src/cli/threads/delete.ts

@@ -0,0 +1,61 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command } from "effect/unstable/cli";
+
+import { requireDestructiveConfirmation } from "../confirm.ts";
+import { formatFlag, selfActionForceFlag, threadFlag, yesFlag } from "../flags.ts";
+import { formatThreadDeletedHuman } from "../thread-format.ts";
+import { MissingThreadError } from "../error.ts";
+import { requireSelfActionConfirmation } from "../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 { T3Output } from "../output/service.ts";
+
+export const deleteThreadCommand = Command.make(
+  "delete",
+  {
+    thread: threadFlag,
+    force: selfActionForceFlag,
+    yes: yesFlag,
+    format: formatFlag,
+  },
+  ({ thread, force, yes, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        env: environment.env,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+      yield* requireSelfActionConfirmation({
+        threadId,
+        force,
+        environment,
+        action: "delete",
+      });
+      yield* requireDestructiveConfirmation({
+        message: `Delete thread ${threadId}?`,
+        yes,
+        environment,
+      });
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const result = yield* application.deleteThread(threadId);
+      if (resolvedFormat === "json") {
+        return yield* output.printJson({
+          threadId: result.threadId,
+          dispatch: result.dispatch,
+        });
+      }
+      return yield* output.printInfo(formatThreadDeletedHuman(result));
+    }),
+).pipe(Command.withDescription("delete thread"));

package/src/cli/threads/interrupt.ts

@@ -0,0 +1,52 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command } from "effect/unstable/cli";
+
+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 { T3Application } from "../../application/service.ts";
+import { Environment } from "../../environment/service.ts";
+import { resolveOutputFormat } from "../output-format.ts";
+import { T3Output } from "../output/service.ts";
+
+export const interruptThreadCommand = Command.make(
+  "interrupt",
+  {
+    thread: threadFlag,
+    force: selfActionForceFlag,
+    format: formatFlag,
+  },
+  ({ thread, force, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        env: environment.env,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+      yield* requireSelfActionConfirmation({
+        threadId,
+        force,
+        environment,
+        action: "interrupt",
+      });
+      const resolvedFormat = resolveOutputFormat(format, environment, "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}`,
+      );
+    }),
+).pipe(Command.withDescription("interrupt running thread turn"));

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

@@ -0,0 +1,69 @@
+import "vite-plus/test/config";
+
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import * as Option from "effect/Option";
+import { assert, describe, it } from "@effect/vitest";
+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 { InvalidFlagCombinationError } from "../error.ts";
+import { T3Output } from "../output/service.ts";
+import { listThreadsCommand } from "./list.ts";
+
+const testLayer = Layer.mergeAll(
+  Layer.succeed(
+    T3Application,
+    fromPartial({
+      listThreads: () => Effect.die("listThreads should not be called"),
+    }),
+  ),
+  Layer.succeed(
+    T3Config,
+    fromPartial({
+      resolve: () =>
+        Effect.succeed({
+          url: "ws://localhost",
+          token: "token",
+          source: "config",
+          local: true,
+        }),
+    }),
+  ),
+  Layer.succeed(T3Output, {
+    writeStdout: () => Effect.void,
+    writeStderr: () => Effect.void,
+    printJson: () => Effect.void,
+    printNdjson: () => Effect.void,
+    printInfo: () => Effect.void,
+  }),
+  NodeServices.layer,
+  NodeEnvironmentLive,
+);
+
+describe("listThreadsCommand", () => {
+  it.layer(testLayer)("listThreadsCommand", (t) => {
+    t.effect("rejects --archived and --all together", () =>
+      Effect.gen(function* () {
+        const run = Command.runWith(listThreadsCommand, { version: "0.0.0-test" });
+        const exit = yield* run(["--archived", "--all", "--project", "proj-1"]).pipe(Effect.exit);
+        assert.isTrue(Exit.isFailure(exit));
+        if (!Exit.isFailure(exit)) {
+          return;
+        }
+        const error = Cause.findErrorOption(exit.cause);
+        assert.isTrue(Option.isSome(error));
+        if (Option.isSome(error)) {
+          assert.instanceOf(error.value, InvalidFlagCombinationError);
+          assert.equal(error.value.message, "--archived and --all are mutually exclusive");
+        }
+      }),
+    );
+  });
+});

package/src/cli/threads/list.ts

@@ -1,7 +1,9 @@
 import * as Effect from "effect/Effect";
-import { Command } from "effect/unstable/cli";
+import { Command, Flag } from "effect/unstable/cli";
 
+import type { ListThreadsInclude } from "../../application/service.ts";
 import { formatFlag, projectFlag } from "../flags.ts";
+import { InvalidFlagCombinationError } from "../error.ts";
 import { requireCommandProjectRef } from "../require.ts";
 import { formatThreadsHuman } from "../thread-format.ts";
 import { T3Application } from "../../application/service.ts";
@@ -13,20 +15,30 @@ export const listThreadsCommand = Command.make(
   "list",
   {
     project: projectFlag,
+    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,
   },
-  ({ project, format }) =>
+  ({ project, archived, all, format }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
       const environment = yield* Environment;
       const output = yield* T3Output;
+      if (archived && all) {
+        yield* Effect.fail(
+          new InvalidFlagCombinationError({
+            message: "--archived and --all are mutually exclusive",
+          }),
+        );
+      }
+      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 result = yield* application.listThreads(projectRef);
+      const result = yield* application.listThreads(projectRef, { include });
       if (resolvedFormat === "json") {
         yield* output.printJson(result.threads);
       } else {

package/src/cli/threads/messages.ts

@@ -12,8 +12,8 @@ import { Environment } from "../../environment/service.ts";
 import { resolveOutputFormat } from "../output-format.ts";
 import { T3Output } from "../output/service.ts";
 
-export const getThreadMessagesCommand = Command.make(
-  "messages",
+export const getThreadTranscriptCommand = Command.make(
+  "transcript",
   {
     thread: threadFlag,
     limit: Flag.integer("limit").pipe(Flag.withDefault(20)),
@@ -48,4 +48,4 @@ export const getThreadMessagesCommand = Command.make(
       }
       return yield* output.writeStdout(formatThreadMessagesHuman(detail, limit));
     }),
-).pipe(Command.withDescription("get latest thread messages"));
+).pipe(Command.withDescription("get latest thread transcript"));

package/src/cli/threads/send.ts

@@ -2,10 +2,11 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Argument, Command, Flag } from "effect/unstable/cli";
 
-import { modelFlags, threadFlag, threadFormatFlag } from "../flags.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 { T3Application } from "../../application/service.ts";
 import { Environment } from "../../environment/service.ts";
@@ -18,13 +19,26 @@ export const sendThreadCommand = Command.make(
   "send",
   {
     thread: threadFlag,
+    force: selfActionForceFlag,
     message: Argument.string("message").pipe(Argument.optional),
     stdin: Flag.boolean("stdin"),
     ...modelFlags,
     wait: Flag.boolean("wait"),
     format: threadFormatFlag,
   },
-  ({ thread, message, stdin, option, reasoningEffort, effort, fastMode, thinking, wait, format }) =>
+  ({
+    thread,
+    force,
+    message,
+    stdin,
+    option,
+    reasoningEffort,
+    effort,
+    fastMode,
+    thinking,
+    wait,
+    format,
+  }) =>
     Effect.gen(function* () {
       const inputService = yield* T3Input;
       const text = yield* readInitialMessage({
@@ -53,6 +67,12 @@ export const sendThreadCommand = Command.make(
           }),
         );
       }
+      yield* requireSelfActionConfirmation({
+        threadId,
+        force,
+        environment,
+        action: "send a message to",
+      });
       const input = {
         message: text,
         threadId,

package/src/cli/threads/unarchive.ts

@@ -0,0 +1,44 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command } from "effect/unstable/cli";
+
+import { formatFlag, threadFlag } from "../flags.ts";
+import { MissingThreadError } from "../error.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 { T3Output } from "../output/service.ts";
+
+export const unarchiveThreadCommand = Command.make(
+  "unarchive",
+  {
+    thread: threadFlag,
+    format: formatFlag,
+  },
+  ({ thread, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        env: environment.env,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+      const resolvedFormat = resolveOutputFormat(format, environment, "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}`,
+      );
+    }),
+).pipe(Command.withDescription("unarchive thread"));

package/src/cli/threads/update.ts

@@ -0,0 +1,150 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command, Flag } from "effect/unstable/cli";
+
+import { formatFlag, modelFlags, selfActionForceFlag, threadFlag } from "../flags.ts";
+import {
+  ConflictingUpdateFlagsError,
+  MissingThreadError,
+  MissingUpdateFieldsError,
+} from "../error.ts";
+import { requireSelfActionConfirmation } from "../self-action.ts";
+import { buildModelOptions } from "../model-options.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 { T3Output } from "../output/service.ts";
+
+export const updateThreadCommand = Command.make(
+  "update",
+  {
+    thread: threadFlag,
+    force: selfActionForceFlag,
+    title: Flag.string("title").pipe(Flag.optional),
+    provider: Flag.string("provider").pipe(Flag.optional),
+    model: Flag.string("model").pipe(Flag.optional),
+    ...modelFlags,
+    branch: Flag.string("branch").pipe(Flag.optional),
+    clearBranch: Flag.boolean("clear-branch").pipe(Flag.optional),
+    worktree: Flag.string("worktree").pipe(Flag.optional),
+    clearWorktree: Flag.boolean("clear-worktree").pipe(Flag.optional),
+    format: formatFlag,
+  },
+  ({
+    thread,
+    force,
+    title,
+    provider,
+    model,
+    option,
+    reasoningEffort,
+    effort,
+    fastMode,
+    thinking,
+    branch,
+    clearBranch,
+    worktree,
+    clearWorktree,
+    format,
+  }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        env: environment.env,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+
+      yield* requireSelfActionConfirmation({
+        threadId,
+        force,
+        environment,
+        action: "update",
+      });
+
+      const titleValue = Option.getOrUndefined(title);
+      const providerValue = Option.getOrUndefined(provider);
+      const modelValue = Option.getOrUndefined(model);
+      const branchValue = Option.getOrUndefined(branch);
+      const worktreeValue = Option.getOrUndefined(worktree);
+      const clearBranchValue = Option.getOrUndefined(clearBranch);
+      const clearWorktreeValue = Option.getOrUndefined(clearWorktree);
+      const options = buildModelOptions({
+        option,
+        reasoningEffort,
+        effort,
+        fastMode,
+        thinking,
+      });
+
+      if (clearBranchValue === true && branchValue !== undefined) {
+        return yield* Effect.fail(
+          new ConflictingUpdateFlagsError({
+            message: "--branch and --clear-branch are mutually exclusive",
+          }),
+        );
+      }
+      if (clearWorktreeValue === true && worktreeValue !== undefined) {
+        return yield* Effect.fail(
+          new ConflictingUpdateFlagsError({
+            message: "--worktree and --clear-worktree are mutually exclusive",
+          }),
+        );
+      }
+
+      const hasTitle = titleValue !== undefined && titleValue.length > 0;
+      const hasProvider = providerValue !== undefined && providerValue.length > 0;
+      const hasModel = modelValue !== undefined && modelValue.length > 0;
+      const hasBranch = branchValue !== undefined && branchValue.length > 0;
+      const hasWorktree = worktreeValue !== undefined && worktreeValue.length > 0;
+      if (
+        !hasTitle &&
+        !hasProvider &&
+        !hasModel &&
+        options.length === 0 &&
+        !hasBranch &&
+        clearBranchValue !== true &&
+        !hasWorktree &&
+        clearWorktreeValue !== true
+      ) {
+        return yield* Effect.fail(
+          new MissingUpdateFieldsError({
+            message:
+              "at least one update field is required: --title, model flags, --branch, --clear-branch, --worktree, or --clear-worktree",
+          }),
+        );
+      }
+
+      const dispatch = yield* application.updateThread({
+        threadId,
+        ...(hasTitle ? { title: titleValue } : {}),
+        ...(hasProvider ? { provider: providerValue } : {}),
+        ...(hasModel ? { model: modelValue } : {}),
+        ...(options.length > 0 ? { options } : {}),
+        ...(clearBranchValue === true
+          ? { branch: null }
+          : hasBranch
+            ? { branch: branchValue }
+            : {}),
+        ...(clearWorktreeValue === true
+          ? { worktreePath: null }
+          : hasWorktree
+            ? { worktreePath: worktreeValue }
+            : {}),
+      });
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      if (resolvedFormat === "json") {
+        return yield* output.printJson(dispatch);
+      }
+      return yield* output.printInfo(`thread updated: ${threadId}\nsequence: ${dispatch.sequence}`);
+    }),
+).pipe(Command.withDescription("update thread metadata"));

package/src/domain/error.ts

@@ -30,6 +30,14 @@ export class ThreadSessionError extends Schema.TaggedErrorClass<ThreadSessionErr
   },
 ) {}
 
+export class ThreadLookupError extends Schema.TaggedErrorClass<ThreadLookupError>()(
+  "ThreadLookupError",
+  {
+    message: Schema.String,
+    threadId: Schema.String,
+  },
+) {}
+
 export class ProjectCreateVisibilityError extends Schema.TaggedErrorClass<ProjectCreateVisibilityError>()(
   "ProjectCreateVisibilityError",
   {
@@ -38,9 +46,20 @@ export class ProjectCreateVisibilityError extends Schema.TaggedErrorClass<Projec
   },
 ) {}
 
+export class TerminalLookupError extends Schema.TaggedErrorClass<TerminalLookupError>()(
+  "TerminalLookupError",
+  {
+    message: Schema.String,
+    threadId: Schema.String,
+    terminalId: Schema.String,
+  },
+) {}
+
 export type DomainError =
   | ProjectLookupError
   | ModelSelectionError
   | ThreadEventError
   | ThreadSessionError
-  | ProjectCreateVisibilityError;
+  | ThreadLookupError
+  | ProjectCreateVisibilityError
+  | TerminalLookupError;