t3code-cli 0.10.0 → 0.12.0

package/src/cli/format/human.ts

@@ -0,0 +1,131 @@
+import { Marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+import stringWidth from "string-width";
+import wrapAnsi from "wrap-ansi";
+
+type TableColumn<Row> = {
+  readonly header: string;
+  readonly value: (row: Row) => string;
+  readonly maxWidth?: number;
+};
+
+type RecordEntry = {
+  readonly field: string;
+  readonly value: string;
+};
+
+const terminalMarkdown = new Marked(
+  markedTerminal({
+    reflowText: false,
+    showSectionPrefix: true,
+    width: 100,
+  }),
+);
+
+export function formatTable<Row>(
+  columns: ReadonlyArray<TableColumn<Row>>,
+  rows: ReadonlyArray<Row>,
+) {
+  if (rows.length === 0) {
+    return "";
+  }
+
+  const widths = columns.map((column) =>
+    Math.min(
+      column.maxWidth ?? Number.POSITIVE_INFINITY,
+      Math.max(stringWidth(column.header), ...rows.map((row) => widestLine(column.value(row)))),
+    ),
+  );
+
+  const header = formatTableLine(
+    columns.map((column) => column.header),
+    widths,
+  );
+  const divider = widths.map((width) => "-".repeat(width)).join("  ");
+  const body = rows.map((row) =>
+    formatTableRow(
+      columns.map((column) => column.value(row)),
+      widths,
+    ),
+  );
+
+  return [header, divider, ...body].join("\n");
+}
+
+export function formatRecord(entries: ReadonlyArray<RecordEntry>) {
+  return formatTable(
+    [
+      { header: "field", value: (entry) => entry.field, maxWidth: 24 },
+      { header: "value", value: (entry) => entry.value, maxWidth: 96 },
+    ],
+    entries,
+  );
+}
+
+export function formatMarkdown(text: string) {
+  return terminalMarkdown
+    .parse(text, {
+      async: false,
+    })
+    .trimEnd();
+}
+
+export function formatChatTranscript(
+  messages: ReadonlyArray<{
+    readonly role: string;
+    readonly text: string;
+  }>,
+) {
+  return `${messages.map(formatChatMessage).join("\n\n")}\n`;
+}
+
+function formatChatMessage(message: { readonly role: string; readonly text: string }) {
+  const rendered = formatMarkdown(message.text);
+  return `${message.role}\n${indentBlock(rendered.length > 0 ? rendered : "(empty)")}`;
+}
+
+function formatTableRow(cells: ReadonlyArray<string>, widths: ReadonlyArray<number>) {
+  const wrappedCells = cells.map((cell, index) => wrapCell(cell, widths[index]!));
+  const height = Math.max(...wrappedCells.map((cell) => cell.length));
+  const lines: string[] = [];
+
+  for (let rowIndex = 0; rowIndex < height; rowIndex += 1) {
+    lines.push(
+      formatTableLine(
+        wrappedCells.map((cell) => cell[rowIndex] ?? ""),
+        widths,
+      ),
+    );
+  }
+
+  return lines.join("\n");
+}
+
+function formatTableLine(cells: ReadonlyArray<string>, widths: ReadonlyArray<number>) {
+  return cells.map((cell, index) => padRight(cell, widths[index]!)).join("  ");
+}
+
+function wrapCell(value: string, width: number) {
+  const lines = value
+    .split("\n")
+    .flatMap((line) =>
+      wrapAnsi(line.length > 0 ? line : " ", width, { hard: true, trim: false }).split("\n"),
+    );
+  return lines.length > 0 ? lines : [""];
+}
+
+function widestLine(value: string) {
+  return Math.max(...value.split("\n").map((line) => stringWidth(line)));
+}
+
+function padRight(value: string, width: number) {
+  const padding = width - stringWidth(value);
+  return padding > 0 ? `${value}${" ".repeat(padding)}` : value;
+}
+
+function indentBlock(value: string) {
+  return value
+    .split("\n")
+    .map((line) => `  ${line}`)
+    .join("\n");
+}

package/src/cli/format/index.ts

@@ -0,0 +1,12 @@
+export {
+  resolveOutputFormat,
+  canRenderLiveTerminal,
+  isInteractiveHumanTerminal,
+  isAgentEnvironment,
+  humanJsonFormatChoices,
+  humanNdjsonFormatChoices,
+  humanJsonNdjsonFormatChoices,
+  type HumanJsonFormat,
+  type HumanNdjsonFormat,
+  type HumanJsonNdjsonFormat,
+} from "./output.ts";

package/src/cli/format/model.ts

@@ -0,0 +1,29 @@
+import type { ServerProvider } from "@t3tools/contracts";
+
+import { formatTable } from "./human.ts";
+
+export function formatModelsHuman(providers: ReadonlyArray<ServerProvider>) {
+  if (providers.length === 0) {
+    return "no models found\n";
+  }
+  return providers
+    .map((provider) => {
+      const models = provider.models;
+      const displayName = provider.displayName ?? provider.instanceId;
+      const header = `${displayName} (${provider.instanceId}) - ${provider.status}`;
+      if (models.length === 0) {
+        return `${header}\n  no models`;
+      }
+      return `${header}\n${formatTable(
+        [
+          { header: "slug", value: (model) => model.slug, maxWidth: 40 },
+          { header: "name", value: (model) => model.name, maxWidth: 48 },
+          { header: "custom", value: (model) => (model.isCustom ? "yes" : "no"), maxWidth: 6 },
+          { header: "sub-provider", value: (model) => model.subProvider ?? "-", maxWidth: 24 },
+        ],
+        models,
+      )}`;
+    })
+    .join("\n\n")
+    .concat("\n");
+}

package/src/cli/format/output.ts

@@ -0,0 +1,51 @@
+import * as Option from "effect/Option";
+
+import type { T3CliEnvShape } from "../../config/env/env.ts";
+import type { CliRuntime } from "../runtime/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,
+  cliRuntime: CliRuntime["Service"],
+  t3CliEnv: T3CliEnvShape,
+  nonHumanFormat: T,
+): "human" | T {
+  if (format !== "auto") {
+    return format;
+  }
+  return isHumanTerminal(cliRuntime, t3CliEnv) ? "human" : nonHumanFormat;
+}
+
+export function canRenderLiveTerminal(cliRuntime: CliRuntime["Service"], t3CliEnv: T3CliEnvShape) {
+  return (
+    cliRuntime.stderrIsTTY &&
+    Option.getOrElse(t3CliEnv.term, () => "") !== "dumb" &&
+    !isAgentEnvironment(t3CliEnv)
+  );
+}
+
+export function isInteractiveHumanTerminal(
+  cliRuntime: CliRuntime["Service"],
+  t3CliEnv: T3CliEnvShape,
+) {
+  return (
+    cliRuntime.stdoutIsTTY &&
+    !isAgentEnvironment(t3CliEnv) &&
+    Option.getOrElse(t3CliEnv.term, () => "") !== "dumb"
+  );
+}
+
+function isHumanTerminal(cliRuntime: CliRuntime["Service"], t3CliEnv: T3CliEnvShape) {
+  return isInteractiveHumanTerminal(cliRuntime, t3CliEnv);
+}
+
+export function isAgentEnvironment(t3CliEnv: T3CliEnvShape) {
+  return t3CliEnv.ci || t3CliEnv.codexCi || t3CliEnv.codexThreadId || t3CliEnv.t3cliAgent;
+}

package/src/cli/format/project.ts

@@ -0,0 +1,32 @@
+import type { OrchestrationProjectShell } from "@t3tools/contracts";
+
+import { formatRecord, formatTable } from "./human.ts";
+
+export function formatProjectsHuman(projects: ReadonlyArray<OrchestrationProjectShell>) {
+  if (projects.length === 0) {
+    return "no projects\n";
+  }
+  return `${formatTable(
+    [
+      { header: "title", value: (project) => project.title, maxWidth: 32 },
+      { header: "id", value: (project) => project.id, maxWidth: 40 },
+      { header: "path", value: (project) => project.workspaceRoot, maxWidth: 72 },
+    ],
+    projects,
+  )}\n`;
+}
+
+export function formatProjectAddedHuman(project: OrchestrationProjectShell) {
+  return `project added\n${formatRecord([
+    { field: "title", value: project.title },
+    { field: "id", value: project.id },
+    { field: "path", value: project.workspaceRoot },
+  ])}`;
+}
+
+export function formatProjectDeletedHuman(input: {
+  readonly projectId: string;
+  readonly dispatch: { readonly sequence: number };
+}) {
+  return `project deleted: ${input.projectId} (sequence ${input.dispatch.sequence})`;
+}

package/src/cli/format/terminal.ts

@@ -0,0 +1,87 @@
+import type { TerminalSessionSnapshot, TerminalSummary } from "@t3tools/contracts";
+
+import { formatTable } from "./human.ts";
+
+type TerminalRow = {
+  readonly id: string;
+  readonly status: string;
+  readonly label: string;
+  readonly cwd: string;
+  readonly updated: string;
+  readonly process: string;
+};
+
+export function formatTerminalListHuman(terminals: ReadonlyArray<TerminalSummary>) {
+  if (terminals.length === 0) {
+    return "no terminals\n";
+  }
+  return `${formatTerminalTable(terminals.map(toSummaryRow))}\n`;
+}
+
+export function formatTerminalCreatedHuman(snapshot: TerminalSessionSnapshot) {
+  return `terminal created\n${formatTerminalTable([toSnapshotRow(snapshot)])}`;
+}
+
+export function formatTerminalWrittenHuman(input: {
+  readonly terminalId: string;
+  readonly threadId: string;
+  readonly bytes: number;
+}) {
+  return `wrote ${input.bytes} bytes to ${input.terminalId} (${input.threadId})`;
+}
+
+export function formatTerminalDestroyedHuman(input: {
+  readonly terminalId: string;
+  readonly threadId: string;
+}) {
+  return `destroyed ${input.terminalId} (${input.threadId})`;
+}
+
+function formatTerminalTable(rows: ReadonlyArray<TerminalRow>) {
+  return formatTable(
+    [
+      { header: "id", value: (row) => row.id, maxWidth: 44 },
+      { header: "status", value: (row) => row.status, maxWidth: 8 },
+      { header: "label", value: (row) => row.label, maxWidth: 24 },
+      { header: "cwd", value: (row) => row.cwd, maxWidth: 40 },
+      { header: "updated", value: (row) => row.updated, maxWidth: 24 },
+      { header: "process", value: (row) => row.process, maxWidth: 20 },
+    ],
+    rows,
+  );
+}
+
+function toSummaryRow(terminal: TerminalSummary): TerminalRow {
+  return {
+    id: terminal.terminalId,
+    status: terminal.status,
+    label: terminal.label,
+    cwd: terminal.cwd,
+    updated: terminal.updatedAt,
+    process: formatProcessInfo(terminal),
+  };
+}
+
+function toSnapshotRow(snapshot: TerminalSessionSnapshot): TerminalRow {
+  return {
+    id: snapshot.terminalId,
+    status: snapshot.status,
+    label: snapshot.label,
+    cwd: snapshot.cwd,
+    updated: snapshot.updatedAt,
+    process: formatProcessInfo(snapshot),
+  };
+}
+
+function formatProcessInfo(input: {
+  readonly pid: number | null;
+  readonly exitCode: number | null;
+  readonly exitSignal: number | null;
+}) {
+  const parts = [
+    typeof input.pid === "number" ? `pid ${input.pid}` : null,
+    typeof input.exitCode === "number" ? `exit ${input.exitCode}` : null,
+    typeof input.exitSignal === "number" ? `sig ${input.exitSignal}` : null,
+  ].filter((part): part is string => part !== null);
+  return parts.length > 0 ? parts.join(", ") : "-";
+}

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

@@ -0,0 +1,34 @@
+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.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, "title            id          status   updated                   flags");
+    assert.include(output, "Active thread    active-1");
+    assert.include(output, "Archived thread  archived-1");
+    assert.include(output, "archived");
+  });
+});

package/src/cli/format/thread.ts

@@ -0,0 +1,185 @@
+import type { ThreadShow } from "../../application/threads.ts";
+import type { WaitEvent } from "../../application/service.ts";
+import type { OrchestrationThread, OrchestrationThreadShell } from "@t3tools/contracts";
+import { latestAssistantMessage, threadStatus } from "../../domain/thread-lifecycle.ts";
+import { formatChatTranscript, formatRecord, formatTable } from "./human.ts";
+
+export function formatThreadShowJson(thread: ThreadShow) {
+  return {
+    id: thread.id,
+    projectId: thread.projectId,
+    title: thread.title,
+    status: thread.status,
+    session: thread.session,
+    latestTurn: thread.latestTurn,
+    modelSelection: thread.modelSelection,
+    runtimeMode: thread.runtimeMode,
+    interactionMode: thread.interactionMode,
+    branch: thread.branch,
+    worktreePath: thread.worktreePath,
+    archivedAt: thread.archivedAt,
+    createdAt: thread.createdAt,
+    updatedAt: thread.updatedAt,
+    messageCount: thread.messageCount,
+    hasPendingApprovals: thread.hasPendingApprovals,
+    hasPendingUserInput: thread.hasPendingUserInput,
+    hasActionableProposedPlan: thread.hasActionableProposedPlan,
+    pendingApprovals: thread.pendingApprovals,
+    pendingUserInputs: thread.pendingUserInputs,
+  };
+}
+
+export function formatThreadShowHuman(thread: ThreadShow) {
+  const sections = [
+    formatRecord([
+      { field: "title", value: thread.title },
+      { field: "id", value: thread.id },
+      { field: "project", value: thread.projectId },
+      { field: "status", value: thread.status },
+      {
+        field: "model",
+        value: `${thread.modelSelection.instanceId}/${thread.modelSelection.model}`,
+      },
+      { field: "runtime", value: thread.runtimeMode },
+      { field: "interaction", value: thread.interactionMode },
+      ...(thread.branch !== null ? [{ field: "branch", value: thread.branch }] : []),
+      ...(thread.worktreePath !== null ? [{ field: "worktree", value: thread.worktreePath }] : []),
+      ...(thread.archivedAt !== null ? [{ field: "archived", value: thread.archivedAt }] : []),
+      { field: "messages", value: String(thread.messageCount) },
+      { field: "updated", value: thread.updatedAt },
+    ]),
+  ];
+  if (thread.pendingApprovals.length > 0) {
+    sections.push(
+      `\npending approvals\n${formatTable(
+        [
+          { header: "request", value: (approval) => approval.requestId, maxWidth: 40 },
+          { header: "kind", value: (approval) => approval.requestKind, maxWidth: 16 },
+          { header: "created", value: (approval) => approval.createdAt, maxWidth: 28 },
+          { header: "detail", value: (approval) => approval.detail ?? "-", maxWidth: 72 },
+        ],
+        thread.pendingApprovals,
+      )}`,
+    );
+  }
+  if (thread.pendingUserInputs.length > 0) {
+    sections.push(
+      `\npending user inputs\n${formatTable(
+        [
+          { header: "request", value: (input) => input.requestId, maxWidth: 40 },
+          { header: "questions", value: (input) => String(input.questions.length), maxWidth: 9 },
+          { header: "created", value: (input) => input.createdAt, maxWidth: 28 },
+          {
+            header: "prompt",
+            value: (input) => input.questions.map((question) => question.question).join("\n"),
+            maxWidth: 72,
+          },
+        ],
+        thread.pendingUserInputs,
+      )}`,
+    );
+  }
+  return `${sections.join("\n")}\n`;
+}
+
+export function formatThreadsHuman(threads: ReadonlyArray<OrchestrationThreadShell>) {
+  if (threads.length === 0) {
+    return "no threads\n";
+  }
+  return `${formatTable(
+    [
+      { header: "title", value: (thread) => thread.title, maxWidth: 36 },
+      { header: "id", value: (thread) => thread.id, maxWidth: 40 },
+      { header: "status", value: (thread) => threadStatus(thread), maxWidth: 18 },
+      { header: "updated", value: (thread) => thread.updatedAt, maxWidth: 28 },
+      { header: "flags", value: formatThreadFlags, maxWidth: 34 },
+    ],
+    threads,
+  )}\n`;
+}
+
+export function formatThreadDeletedHuman(input: {
+  readonly threadId: string;
+  readonly dispatch: { readonly sequence: number };
+}) {
+  return `thread deleted: ${input.threadId} (sequence ${input.dispatch.sequence})`;
+}
+
+export function formatThreadStartedHuman(input: {
+  readonly thread: OrchestrationThread;
+  readonly sequence: number;
+}) {
+  return `thread started\n${formatRecord([
+    { field: "title", value: input.thread.title },
+    { field: "id", value: input.thread.id },
+    { field: "status", value: threadStatus(input.thread) },
+    { field: "sequence", value: String(input.sequence) },
+  ])}`;
+}
+
+export function formatThreadMessagesHuman(thread: OrchestrationThread, limit: number) {
+  const messages = limit === 0 ? thread.messages : thread.messages.slice(-limit);
+  return formatChatTranscript(messages);
+}
+
+export function formatWaitDoneHuman(thread: OrchestrationThread) {
+  const latest = latestAssistantMessage(thread);
+  return `status: ${threadStatus(thread)}\n${
+    latest !== undefined ? `\n${formatChatTranscript([latest])}` : ""
+  }`;
+}
+
+export function formatThreadMessagesJson(thread: OrchestrationThread, 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 formatThreadFlags(thread: OrchestrationThreadShell) {
+  const flags = [
+    thread.archivedAt !== null ? "archived" : null,
+    thread.hasPendingApprovals ? "approval" : null,
+    thread.hasPendingUserInput ? "input" : null,
+    thread.hasActionableProposedPlan ? "plan" : null,
+  ].filter((flag): flag is string => flag !== null);
+  return flags.length > 0 ? flags.join(", ") : "-";
+}
+
+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/index.ts

@@ -8,3 +8,23 @@ export {
   waitFormatFlag,
   worktreeFlag,
 } from "./flags.ts";
+export * as Env from "./env/index.ts";
+export * as Runtime from "./runtime/index.ts";
+export {
+  resolveCommandProjectRef,
+  resolveProjectRef,
+  resolveThreadId,
+  resolveWorktreePath,
+} from "./scope/index.ts";
+export {
+  resolveOutputFormat,
+  canRenderLiveTerminal,
+  isInteractiveHumanTerminal,
+  isAgentEnvironment,
+  humanJsonFormatChoices,
+  humanNdjsonFormatChoices,
+  humanJsonNdjsonFormatChoices,
+  type HumanJsonFormat,
+  type HumanNdjsonFormat,
+  type HumanJsonNdjsonFormat,
+} from "./format/index.ts";

package/src/cli/input/layer.ts

@@ -23,8 +23,28 @@ export const makeT3Input = Effect.fn("makeT3Input")(function* () {
     );
   });
 
+  const readStdinBinary = Effect.fn("T3InputLive.readStdinBinary")(function* () {
+    return yield* stdio.stdin.pipe(
+      Stream.runFold(
+        () => new Uint8Array(0),
+        (acc, chunk) => {
+          const merged = new Uint8Array(acc.length + chunk.length);
+          merged.set(acc);
+          merged.set(chunk, acc.length);
+          return merged;
+        },
+      ),
+      Effect.map((bytes) => Buffer.from(bytes).toString("latin1")),
+      Effect.catchTags({
+        PlatformError: (error) =>
+          Effect.fail(new InputError({ message: "failed to read stdin", cause: error })),
+      }),
+    );
+  });
+
   return {
     readStdin,
+    readStdinBinary,
   };
 });
 

package/src/cli/input/service.ts

@@ -7,5 +7,6 @@ export class T3Input extends Context.Service<
   T3Input,
   {
     readonly readStdin: () => Effect.Effect<string, InputError>;
+    readonly readStdinBinary: () => Effect.Effect<string, InputError>;
   }
 >()("t3cli/T3Input") {}

package/src/cli/interaction/confirm.ts

@@ -0,0 +1,64 @@
+import * as Effect from "effect/Effect";
+import * as Prompt from "effect/unstable/cli/Prompt";
+
+import { DestructiveConfirmationRequiredError } from "../error.ts";
+import { isInteractiveHumanTerminal } from "../format/output.ts";
+import type { T3CliEnvShape } from "../../config/env/env.ts";
+import type { CliRuntime } from "../runtime/service.ts";
+
+export const requireDestructiveConfirmation = Effect.fn("requireDestructiveConfirmation")(
+  function* (input: {
+    readonly message: string;
+    readonly yes: boolean;
+    readonly cliRuntime: CliRuntime["Service"];
+    readonly t3CliEnv: T3CliEnvShape;
+  }) {
+    if (input.yes) {
+      return;
+    }
+    if (!isInteractiveHumanTerminal(input.cliRuntime, input.t3CliEnv)) {
+      yield* Effect.fail(
+        new DestructiveConfirmationRequiredError({
+          message: "destructive action requires --yes in non-interactive mode",
+        }),
+      );
+      return;
+    }
+    const confirmed = yield* Prompt.run(Prompt.confirm({ message: input.message, initial: false }));
+    if (confirmed) {
+      return;
+    }
+    yield* Effect.fail(new DestructiveConfirmationRequiredError({ message: "aborted" }));
+  },
+);
+
+export const requireEnvironmentReplaceConfirmation = Effect.fn(
+  "requireEnvironmentReplaceConfirmation",
+)(function* (input: {
+  readonly name: string;
+  readonly replace: boolean;
+  readonly cliRuntime: CliRuntime["Service"];
+  readonly t3CliEnv: T3CliEnvShape;
+}) {
+  if (input.replace) {
+    return;
+  }
+  if (!isInteractiveHumanTerminal(input.cliRuntime, input.t3CliEnv)) {
+    yield* Effect.fail(
+      new DestructiveConfirmationRequiredError({
+        message: `environment '${input.name}' already exists: pass --replace`,
+      }),
+    );
+    return;
+  }
+  const confirmed = yield* Prompt.run(
+    Prompt.confirm({
+      message: `Environment '${input.name}' already exists. Replace?`,
+      initial: false,
+    }),
+  );
+  if (confirmed) {
+    return;
+  }
+  yield* Effect.fail(new DestructiveConfirmationRequiredError({ message: "aborted" }));
+});