@prisma-next/cli 0.12.0-dev.2 → 0.12.0-dev.20

package/src/commands/init/inputs.ts

@@ -1,9 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import * as clack from '@clack/prompts';
-import { readUserConfig, resolveGating, writeUserConfig } from '@prisma-next/cli-telemetry';
 import { extname, join, normalize } from 'pathe';
 import type { GlobalFlags } from '../../utils/global-flags';
-import { isCI } from '../../utils/is-ci';
 import {
   errorInitAuthoringSchemaPathMismatch,
   errorInitInvalidFlagValue,
@@ -71,18 +69,6 @@ export interface ResolvedInitInputs {
    * is added separately via the install step.
    */
   readonly removePreviousFacade: string | null;
-  /**
-   * Telemetry consent answer recorded during this `init` run, or `null`
-   * when no prompt was shown. The prompt fires only on the
-   * canPrompt + !autoAcceptPrompts + no env/CI opt-out +
-   * `enableTelemetry === undefined` intersection; outside that window
-   * the field is `null` and the stored preference (if any) stays
-   * unchanged. The answer has already been persisted to
-   * `$XDG_CONFIG_HOME/prisma-next/config.json` by
-   * the time `runInit` sees this value — it's surfaced here purely so
-   * the post-init summary can mention what the user chose.
-   */
-  readonly enableTelemetry: boolean | null;
   /**
    * Whether to run `npx skills add prisma/prisma-next#v<version>` at the
    * project level after install + emit. True by default; `--no-skill`
@@ -106,12 +92,6 @@ const AUTHORING_VALUES: ReadonlyMap<string, AuthoringId> = new Map([
   ['ts', 'typescript'],
 ]);
 
-export const TELEMETRY_CONSENT_MESSAGE = [
-  'Help us prioritize features by sharing anonymous CLI usage data?',
-  'The telemetry implementation is open source and fully transparent.',
-  '(packages/1-framework/3-tooling/cli-telemetry and apps/telemetry-backend).',
-].join(' ');
-
 /**
  * Resolves every required input for `runInit`. In interactive mode, missing
  * inputs are prompted via clack; in non-interactive mode, missing required
@@ -197,11 +177,6 @@ export async function resolveInitInputs(ctx: {
     autoAcceptPrompts,
   });
 
-  const enableTelemetry = await resolveTelemetryConsent({
-    canPrompt,
-    autoAcceptPrompts,
-  });
-
   // Skill-install gating. `--no-skill` (commander parses
   // `options.skill === false`) is the only escape hatch; otherwise
   // project-level install is unconditional. The skill is always
@@ -219,60 +194,10 @@ export async function resolveInitInputs(ctx: {
     strictProbe: Boolean(options.strictProbe),
     reinit,
     removePreviousFacade,
-    enableTelemetry,
     installProjectSkill,
   };
 }
 
-/**
- * The interactive telemetry consent prompt. Shown as the last
- * question of the `init` sequence iff:
- *   1. `canPrompt === true` (interactive stdin / stdout combo),
- *   2. `autoAcceptPrompts === false` (the user did not pass `--yes`),
- *   3. neither telemetry env opt-out is active,
- *   4. the process is not running in CI,
- *   5. the stored `enableTelemetry` value is `undefined` (the user
- *      has never been asked, or skipped the prompt previously).
- *
- * Outside that intersection the function returns `null` and leaves the
- * stored preference untouched. Inside it, the user's answer is
- * persisted via `writeUserConfig({ enableTelemetry })` before this
- * function returns; on an affirmative answer `writeUserConfig`
- * generates and stores the v4 `installationId` in the same write.
- *
- * The wording names CLI usage data and points to the open-source
- * client/backend paths. Default value is `true` to match precedent
- * and to make the consent answer a single keystroke once it's been
- * disclosed.
- */
-async function resolveTelemetryConsent(opts: {
-  readonly canPrompt: boolean;
-  readonly autoAcceptPrompts: boolean;
-}): Promise<boolean | null> {
-  if (!opts.canPrompt || opts.autoAcceptPrompts || isCI()) {
-    return null;
-  }
-  const config = readUserConfig();
-  const gating = resolveGating({ env: process.env, config });
-  if (!gating.enabled && gating.reason === 'env-override') {
-    return null;
-  }
-  const stored = config.enableTelemetry;
-  if (stored !== undefined) {
-    return null;
-  }
-  const result = await clack.confirm({
-    message: TELEMETRY_CONSENT_MESSAGE,
-    initialValue: true,
-    output: process.stderr,
-  });
-  if (clack.isCancel(result)) {
-    throw errorInitUserAborted();
-  }
-  writeUserConfig({ enableTelemetry: Boolean(result) });
-  return Boolean(result);
-}
-
 async function resolveWriteEnv(opts: {
   readonly flag: boolean | undefined;
   readonly canPrompt: boolean;

package/src/commands/migration-graph.ts

@@ -16,7 +16,10 @@ import { migrationGraphToRenderInput } from '../utils/formatters/graph-migration
 import { graphRenderer } from '../utils/formatters/graph-render';
 import { buildMigrationGraphLayout } from '../utils/formatters/migration-graph-layout';
 import { buildMigrationGraphRows } from '../utils/formatters/migration-graph-rows';
-import { renderMigrationGraphTree } from '../utils/formatters/migration-graph-tree-render';
+import {
+  renderMigrationGraphLegend,
+  renderMigrationGraphTree,
+} from '../utils/formatters/migration-graph-tree-render';
 import { formatStyledHeader } from '../utils/formatters/styled';
 import type { CommonCommandOptions } from '../utils/global-flags';
 import { type GlobalFlags, parseGlobalFlagsOrExit } from '../utils/global-flags';
@@ -29,6 +32,32 @@ interface MigrationGraphOptions extends CommonCommandOptions {
   readonly dot?: boolean;
   readonly tree?: boolean;
   readonly ascii?: boolean;
+  readonly legend?: boolean;
+}
+
+/**
+ * `--legend` describes the `--tree` visual language, so passing it auto-enables
+ * the tree path (it has nothing to say about the legacy dagre default).
+ */
+export function migrationGraphUsesTree(options: {
+  readonly tree?: boolean;
+  readonly legend?: boolean;
+}): boolean {
+  return options.tree === true || options.legend === true;
+}
+
+/**
+ * The legend is decoration printed alongside the command header on stderr, so
+ * it is suppressed for the machine-readable / silent paths (`--json`, `--dot`,
+ * `--quiet`) exactly as the header is.
+ */
+export function migrationGraphShowsLegend(
+  options: { readonly legend?: boolean; readonly dot?: boolean },
+  flags: GlobalFlags,
+): boolean {
+  return (
+    options.legend === true && options.dot !== true && flags.json !== true && flags.quiet !== true
+  );
 }
 
 export interface MigrationGraphResult {
@@ -61,6 +90,16 @@ export async function executeMigrationGraphCommand(
       flags,
     });
     ui.stderr(header);
+    if (migrationGraphShowsLegend(options, flags)) {
+      ui.stderr(
+        renderMigrationGraphLegend({
+          colorize: flags.color !== false,
+          glyphMode: ui.resolveGlyphMode(options.ascii === true),
+        }),
+      );
+      // Blank line separating the stderr key from the graph that follows on stdout.
+      ui.stderr('');
+    }
   }
 
   const loaded = await buildReadAggregate(config, { migrationsDir });
@@ -102,6 +141,7 @@ export function createMigrationGraphCommand(): Command {
     'prisma-next migration graph --dot',
     'prisma-next migration graph --tree',
     'prisma-next migration graph --tree --ascii',
+    'prisma-next migration graph --legend',
   ]);
   setCommandSeeAlso(command, [
     { verb: 'migration status', oneLiner: 'Show migration path and pending status' },
@@ -114,6 +154,7 @@ export function createMigrationGraphCommand(): Command {
     .option('--dot', 'Output in Graphviz DOT format')
     .option('--tree', 'Experimental condensed annotated tree renderer')
     .option('--ascii', 'Use ASCII glyphs for --tree (pipe-friendly)')
+    .option('--legend', 'Print a key for the --tree glyphs and lane colors (implies --tree)')
     .action(async (options: MigrationGraphOptions) => {
       const flags = parseGlobalFlagsOrExit(options);
       const ui = createTerminalUI(flags);
@@ -145,7 +186,7 @@ export function createMigrationGraphCommand(): Command {
             JSON.stringify({ ok: true, nodes, edges, summary: graphResult.summary }, null, 2),
           );
         } else if (!flags.quiet) {
-          if (options.tree) {
+          if (migrationGraphUsesTree(options)) {
             const refsByHash = new Map<string, string[]>();
             for (const ref of graphResult.refs) {
               const existing = refsByHash.get(ref.hash);

package/src/commands/migration-status.ts

@@ -500,7 +500,7 @@ export async function loadAggregateStatusSpaces(args: {
       // Count pending *migrations* (graph edges), not operations: a
       // single authored migration that lowers to N ops or zero ops
       // both count as exactly one pending unit of work for the user.
-      pendingCount = walked.result.migrationEdges?.length ?? 0;
+      pendingCount = walked.result.migrationEdges.length;
       if (liveMarker === null) {
         status = pendingCount === 0 ? 'no-marker' : 'pending';
       } else {

package/src/commands/telemetry/index.ts

@@ -0,0 +1,107 @@
+import { userConfigPath, writeUserConfig } from '@prisma-next/cli-telemetry';
+import { Command } from 'commander';
+import {
+  addGlobalOptions,
+  setCommandDescriptions,
+  setCommandExamples,
+} from '../../utils/command-helpers';
+import { formatCommandHelp } from '../../utils/formatters/help';
+import {
+  type CommonCommandOptions,
+  parseGlobalFlags,
+  parseGlobalFlagsOrExit,
+} from '../../utils/global-flags';
+import { isCI } from '../../utils/is-ci';
+import { createTerminalUI } from '../../utils/terminal-ui';
+import { formatTelemetryStatusLines, resolveTelemetryStatus } from './status';
+
+function createTelemetryStatusCommand(): Command {
+  const command = new Command('status');
+  setCommandDescriptions(
+    command,
+    'Show whether anonymous CLI telemetry is enabled and why',
+    'Reports whether telemetry is currently enabled or disabled and the reason\n' +
+      '(default-on, stored opt-out, environment opt-out, or CI), the path to your\n' +
+      'user-level config file, and whether an installation ID has been stored.\n' +
+      'Read-only: never sends an event, never mints an ID, never writes anything.',
+  );
+  return addGlobalOptions(command).action((options: CommonCommandOptions) => {
+    const flags = parseGlobalFlagsOrExit(options);
+    const ui = createTerminalUI(flags);
+    const status = resolveTelemetryStatus({ env: process.env, inCI: isCI() });
+    if (flags.json) {
+      ui.output(JSON.stringify(status));
+    } else {
+      for (const line of formatTelemetryStatusLines(status)) {
+        ui.output(line);
+      }
+    }
+    process.exit(0);
+  });
+}
+
+function createTelemetryEnableCommand(): Command {
+  const command = new Command('enable');
+  setCommandDescriptions(
+    command,
+    'Enable anonymous CLI telemetry',
+    'Stores "enableTelemetry": true in your user-level config and mints an\n' +
+      'installation ID if one is not already stored.',
+  );
+  return addGlobalOptions(command).action((options: CommonCommandOptions) => {
+    const flags = parseGlobalFlagsOrExit(options);
+    writeUserConfig({ enableTelemetry: true });
+    const ui = createTerminalUI(flags);
+    if (flags.json) {
+      ui.output(JSON.stringify({ enableTelemetry: true, configPath: userConfigPath() }));
+    } else {
+      ui.output(`Telemetry enabled. Preference stored in ${userConfigPath()}.`);
+    }
+    process.exit(0);
+  });
+}
+
+function createTelemetryDisableCommand(): Command {
+  const command = new Command('disable');
+  setCommandDescriptions(
+    command,
+    'Disable anonymous CLI telemetry',
+    'Stores "enableTelemetry": false in your user-level config. No installation\n' +
+      'ID is minted and no event is sent.',
+  );
+  return addGlobalOptions(command).action((options: CommonCommandOptions) => {
+    const flags = parseGlobalFlagsOrExit(options);
+    writeUserConfig({ enableTelemetry: false });
+    const ui = createTerminalUI(flags);
+    if (flags.json) {
+      ui.output(JSON.stringify({ enableTelemetry: false, configPath: userConfigPath() }));
+    } else {
+      ui.output(`Telemetry disabled. Preference stored in ${userConfigPath()}.`);
+    }
+    process.exit(0);
+  });
+}
+
+export function createTelemetryCommand(): Command {
+  const command = new Command('telemetry');
+  setCommandDescriptions(
+    command,
+    'Inspect and change anonymous CLI telemetry',
+    'Show telemetry status, or enable / disable anonymous CLI usage data.\n' +
+      'Telemetry is on by default (opt-out); see https://prisma-next.dev/docs/cli/telemetry\n' +
+      'for what is collected and why.',
+  );
+  setCommandExamples(command, [
+    'prisma-next telemetry status',
+    'prisma-next telemetry disable',
+    'prisma-next telemetry enable',
+  ]);
+  command.configureHelp({
+    formatHelp: (cmd) => formatCommandHelp({ command: cmd, flags: parseGlobalFlags({}) }),
+    subcommandDescription: () => '',
+  });
+  command.addCommand(createTelemetryStatusCommand());
+  command.addCommand(createTelemetryEnableCommand());
+  command.addCommand(createTelemetryDisableCommand());
+  return command;
+}

package/src/commands/telemetry/status.ts

@@ -0,0 +1,67 @@
+import { readUserConfig, resolveGating, userConfigPath } from '@prisma-next/cli-telemetry';
+
+/**
+ * Why telemetry resolves the way it does, in the order the CLI's
+ * `resolveTelemetryGate` evaluates: CI hard-disables first, then the env
+ * opt-outs, then the stored `enableTelemetry`, then the opt-out default.
+ */
+export type TelemetryStatusReason =
+  | 'ci'
+  | 'env-opt-out'
+  | 'stored-opt-out'
+  | 'stored-opt-in'
+  | 'default-on';
+
+export interface TelemetryStatus {
+  readonly enabled: boolean;
+  readonly reason: TelemetryStatusReason;
+  readonly configPath: string;
+  readonly installationIdStored: boolean;
+}
+
+/**
+ * Resolves the same gate the runtime uses (CI check + `resolveGating`) and
+ * projects it into a user-facing status. Pure read: never mints, never
+ * writes. The `installationId` value itself is never surfaced — only its
+ * presence — so `status` discloses nothing identifying.
+ */
+export function resolveTelemetryStatus(inputs: {
+  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly inCI: boolean;
+}): TelemetryStatus {
+  const config = readUserConfig();
+  const configPath = userConfigPath();
+  const installationIdStored =
+    typeof config.installationId === 'string' && config.installationId.length > 0;
+
+  if (inputs.inCI) {
+    return { enabled: false, reason: 'ci', configPath, installationIdStored };
+  }
+
+  const gating = resolveGating({ env: inputs.env, config });
+  if (!gating.enabled) {
+    const reason: TelemetryStatusReason =
+      gating.reason === 'env-override' ? 'env-opt-out' : 'stored-opt-out';
+    return { enabled: false, reason, configPath, installationIdStored };
+  }
+
+  const reason: TelemetryStatusReason =
+    config.enableTelemetry === true ? 'stored-opt-in' : 'default-on';
+  return { enabled: true, reason, configPath, installationIdStored };
+}
+
+const REASON_EXPLANATION: Record<TelemetryStatusReason, string> = {
+  ci: 'CI environment detected — telemetry is hard-disabled.',
+  'env-opt-out': 'an environment opt-out is set (DO_NOT_TRACK / PRISMA_NEXT_DISABLE_TELEMETRY).',
+  'stored-opt-out': '"enableTelemetry": false is stored in your config.',
+  'stored-opt-in': '"enableTelemetry": true is stored in your config.',
+  'default-on': 'no explicit choice is stored, so the opt-out default applies.',
+};
+
+export function formatTelemetryStatusLines(status: TelemetryStatus): string[] {
+  return [
+    `Telemetry is ${status.enabled ? 'enabled' : 'disabled'}: ${REASON_EXPLANATION[status.reason]}`,
+    `Config file: ${status.configPath}`,
+    `Installation ID: ${status.installationIdStored ? 'stored' : 'not stored'}`,
+  ];
+}

package/src/control-api/client.ts

@@ -1,4 +1,8 @@
-import type { Contract, ContractMarkerRecord } from '@prisma-next/contract/types';
+import type {
+  Contract,
+  ContractMarkerRecord,
+  LedgerEntryRecord,
+} from '@prisma-next/contract/types';
 import { emit as emitContractArtifacts } from '@prisma-next/emitter';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type {
@@ -447,6 +451,12 @@ class ControlClientImpl implements ControlClient {
     return familyInstance.readAllMarkers({ driver });
   }
 
+  /** Reads the per-migration journal for `space` (defaults to the app contract space). */
+  async readLedger(space = APP_SPACE_ID): Promise<readonly LedgerEntryRecord[]> {
+    const { driver, familyInstance } = await this.ensureConnected();
+    return familyInstance.readLedger({ driver, space });
+  }
+
   async migrationApply(options: MigrationApplyOptions): Promise<MigrationApplyResult> {
     const { onProgress } = options;
     await this.connectWithProgress(options.connection, 'migrationApply', onProgress);

package/src/control-api/operations/apply.ts

@@ -141,6 +141,7 @@ export async function applyMigration<TFamilyId extends string, TTargetId extends
     destinationContract: r.entry.destinationContract,
     policy,
     frameworkComponents,
+    migrationEdges: r.entry.migrationEdges,
     // Per-space post-apply schema verification is non-strict: each
     // space's `destinationContract` describes only its own slice; a
     // strict verifier would treat every other space's tables as

package/src/control-api/operations/migration-apply.ts

@@ -7,6 +7,7 @@ import type {
   TargetMigrationsCapability,
 } from '@prisma-next/framework-components/control';
 import {
+  buildSynthMigrationEdge,
   type ContractMarkerRecordLike,
   type ContractSpaceAggregate,
   type ContractSpaceMember,
@@ -319,7 +320,7 @@ export async function executeMigrationApply<TFamilyId extends string, TTargetId
     includeMarkers: true,
   });
   const totalMigrationsApplied = applied.value.orderedResolutions.reduce(
-    (sum, r) => sum + (r.entry.migrationEdges?.length ?? 0),
+    (sum, r) => sum + r.entry.migrationEdges.length,
     0,
   );
   const summary = `Applied ${totalMigrationsApplied} migration(s) (${applied.value.totalOpsExecuted} operation(s)) across ${orderedAll.length} contract space(s)`;
@@ -361,7 +362,13 @@ function buildAtHeadResolution(args: {
     displayOps: [],
     destinationContract: member.contract(),
     strategy: 'graph-walk',
-    migrationEdges: [],
+    migrationEdges: [
+      buildSynthMigrationEdge({
+        currentMarkerStorageHash: liveMarker?.storageHash,
+        destinationStorageHash: targetHash,
+        operationCount: 0,
+      }),
+    ],
   };
 }
 
@@ -404,7 +411,7 @@ function buildSuccess(args: BuildSuccessArgs): MigrationApplySuccess {
   // JSON-shape consumers (e.g. `parsed.applied.length` in integration
   // tests). The aggregate per-space breakdown lives on `perSpace[]`.
   const applied = args.orderedResolutions.flatMap((r) => {
-    const edges = r.entry.migrationEdges ?? [];
+    const edges = r.entry.migrationEdges;
     return edges.map((edge) => ({
       spaceId: r.spaceId,
       dirName: edge.dirName,

package/src/control-api/types.ts

@@ -2,7 +2,11 @@ import type {
   ContractSourceDiagnostics,
   ContractSourceProvider,
 } from '@prisma-next/config/config-types';
-import type { Contract, ContractMarkerRecord } from '@prisma-next/contract/types';
+import type {
+  Contract,
+  ContractMarkerRecord,
+  LedgerEntryRecord,
+} from '@prisma-next/contract/types';
 import type {
   ControlAdapterDescriptor,
   ControlDriverDescriptor,
@@ -876,6 +880,13 @@ export interface ControlClient {
    */
   readAllMarkers(): Promise<ReadonlyMap<string, ContractMarkerRecord>>;
 
+  /**
+   * Reads the per-migration ledger journal for `space` in apply order.
+   * Returns an empty array when the ledger store does not yet exist or
+   * has no rows for that space.
+   */
+  readLedger(space?: string): Promise<readonly LedgerEntryRecord[]>;
+
   /**
    * Applies pre-planned on-disk migrations to the database.
    * Each migration runs in its own transaction with full execution checks.

package/src/utils/formatters/migration-graph-lane-colors.ts

@@ -0,0 +1,31 @@
+import { createColors } from 'colorette';
+
+export type LaneColorizer = (text: string) => string;
+
+const { magenta, cyan, green, yellow, blueBright, red } = createColors({ useColor: true });
+
+export const LANE_COLOR_CYCLE: readonly LaneColorizer[] = [
+  magenta,
+  cyan,
+  green,
+  yellow,
+  blueBright,
+  red,
+];
+
+/**
+ * The hue for a gutter column. The leftmost lane (column 0) is **neutral** — it
+ * has nothing to be told apart from in the common single-lane linear case, so
+ * the renderer dims it rather than tinting it; the rotating palette is reserved
+ * for columns ≥ 1 (where a second lane exists to distinguish). Callers must dim
+ * column 0 themselves; this returns identity for it as a guard. A lane freed and
+ * reused by a later branch keeps its column's hue — coloring is by position, not
+ * branch identity, exactly like `git log --graph`.
+ */
+export function laneColorForColumn(column: number): LaneColorizer {
+  if (column <= 0) {
+    return (text) => text;
+  }
+  const colorizer = LANE_COLOR_CYCLE[(column - 1) % LANE_COLOR_CYCLE.length];
+  return colorizer ?? ((text) => text);
+}

package/src/utils/formatters/migration-graph-layout.ts

@@ -21,6 +21,7 @@ export type StructuralCell =
   | { readonly kind: 'arc-branch-corner' }
   | { readonly kind: 'arc-branch-tee' }
   | { readonly kind: 'arc-land-corner' }
+  | { readonly kind: 'arc-land-tee' }
   | { readonly kind: 'arc-crossing' }
   | { readonly kind: 'arc-land-bridge' }
   | {
@@ -379,6 +380,7 @@ function emptyCells(width: number): StructuralCell[] {
 function buildBranchConnectorCells(
   startLane: number,
   endLane: number,
+  fanTargetLanes: ReadonlySet<number>,
   activeLanes: ReadonlySet<number>,
   gridWidth: number,
 ): StructuralCell[] {
@@ -393,7 +395,13 @@ function buildBranchConnectorCells(
     } else if (lane === endLane) {
       cells[lane] = { kind: 'branch-corner' };
     } else if (lane > startLane && lane < endLane) {
-      cells[lane] = { kind: 'branch-tee' };
+      if (fanTargetLanes.has(lane)) {
+        cells[lane] = { kind: 'branch-tee' };
+      } else if (activeLanes.has(lane)) {
+        cells[lane] = { kind: 'arc-crossing' };
+      } else {
+        cells[lane] = { kind: 'branch-tee' };
+      }
     }
   }
   return cells;
@@ -402,6 +410,7 @@ function buildBranchConnectorCells(
 function buildMergeConnectorCells(
   startLane: number,
   endLane: number,
+  fanTargetLanes: ReadonlySet<number>,
   activeLanes: ReadonlySet<number>,
   gridWidth: number,
 ): StructuralCell[] {
@@ -416,7 +425,13 @@ function buildMergeConnectorCells(
     } else if (lane === endLane) {
       cells[lane] = { kind: 'merge-corner' };
     } else if (lane > startLane && lane < endLane) {
-      cells[lane] = activeLanes.has(lane) ? { kind: 'merge-tee' } : { kind: 'horizontal-pass' };
+      if (fanTargetLanes.has(lane)) {
+        cells[lane] = { kind: 'merge-tee' };
+      } else if (activeLanes.has(lane)) {
+        cells[lane] = { kind: 'arc-crossing' };
+      } else {
+        cells[lane] = { kind: 'horizontal-pass' };
+      }
     }
   }
   return cells;
@@ -689,6 +704,15 @@ function applySkipRollbackRouting(
       .map((other) => other.backLane);
     const maxCoSourcedLane = Math.max(...coSourcedLanes);
 
+    // Back-lanes of arcs that converge on this same target node. They share the
+    // node's landing row, so each inner lane reads as a `┴` junction (the outer
+    // arcs' horizontal bridge passes through it on the way to the node) and only
+    // the outermost closes the corner with `╯`.
+    const coLandingLanes = routes
+      .filter((other) => other.edge.to === edge.to)
+      .map((other) => other.backLane);
+    const maxCoLandingLane = Math.max(...coLandingLanes);
+
     const sourceRow = result[sourceRowIndex];
     if (sourceRow !== undefined) {
       const cells = sourceRow.cells;
@@ -750,6 +774,7 @@ function applySkipRollbackRouting(
       const existing = cells[backLane];
       if (
         existing?.kind !== 'arc-land-corner' &&
+        existing?.kind !== 'arc-land-tee' &&
         existing?.kind !== 'arc-land-bridge' &&
         existing?.kind !== 'arc-branch-corner' &&
         existing?.kind !== 'arc-branch-tee' &&
@@ -766,6 +791,12 @@ function applySkipRollbackRouting(
       const contractHash = targetRow.contractHash ?? EMPTY_CONTRACT_HASH;
       cells[targetCol] = { kind: 'node', contractHash, arcLand: true };
       for (let lane = targetCol + 1; lane < backLane; lane += 1) {
+        // An inner converging arc's own landing junction: the outer arcs' bridge
+        // passes through it (`┴`) while its own vertical run closes here.
+        if (coLandingLanes.includes(lane)) {
+          cells[lane] = { kind: 'arc-land-tee' };
+          continue;
+        }
         // A bridged lane that carries another arc OR a forward vertical still
         // active at this row must cross over it (`┼`) rather than overwrite it
         // with a bare bridge (`──`).
@@ -774,7 +805,8 @@ function applySkipRollbackRouting(
           existing !== undefined &&
           existing.kind !== 'empty' &&
           existing.kind !== 'horizontal-pass' &&
-          existing.kind !== 'arc-land-bridge';
+          existing.kind !== 'arc-land-bridge' &&
+          existing.kind !== 'arc-land-tee';
         const crossed =
           occupied ||
           routes.some(
@@ -785,7 +817,10 @@ function applySkipRollbackRouting(
           );
         cells[lane] = crossed ? { kind: 'arc-crossing' } : { kind: 'arc-land-bridge' };
       }
-      cells[backLane] = { kind: 'arc-land-corner' };
+      // Inner converging arcs close as a landing tee so the outermost arc's
+      // bridge reads through to the node; only the outermost arc draws `╯`.
+      cells[backLane] =
+        backLane < maxCoLandingLane ? { kind: 'arc-land-tee' } : { kind: 'arc-land-corner' };
       for (const other of routes) {
         if (other.backLane <= backLane) continue;
         if (!routeCrossesRow(other, targetRowIndex, result)) continue;
@@ -793,6 +828,7 @@ function applySkipRollbackRouting(
         const existing = cells[other.backLane];
         if (
           existing?.kind !== 'arc-land-corner' &&
+          existing?.kind !== 'arc-land-tee' &&
           existing?.kind !== 'arc-land-bridge' &&
           existing?.kind !== 'node'
         ) {
@@ -922,13 +958,14 @@ function layoutComponent(
     const endLane = Math.max(...laneIndices);
     ensureGridWidth(endLane + 1);
     const activeLanes = new Set(activeLaneIndices());
+    const fanTargetLanes = new Set(laneIndices);
     rows.push({
       kind: 'merge-connector',
       contractHash,
       startLane,
       endLane,
       branchCount: laneIndices.length,
-      cells: buildMergeConnectorCells(startLane, endLane, activeLanes, gridWidth),
+      cells: buildMergeConnectorCells(startLane, endLane, fanTargetLanes, activeLanes, gridWidth),
     });
     for (const index of laneIndices) {
       if (index !== startLane) setLane(index, null);
@@ -941,6 +978,7 @@ function layoutComponent(
     startLane: number,
     endLane: number,
     branchCount: number,
+    fanTargetLanes: readonly number[],
   ): void {
     ensureGridWidth(endLane + 1);
     const activeLanes = new Set(activeLaneIndices());
@@ -950,7 +988,13 @@ function layoutComponent(
       startLane,
       endLane,
       branchCount,
-      cells: buildBranchConnectorCells(startLane, endLane, activeLanes, gridWidth),
+      cells: buildBranchConnectorCells(
+        startLane,
+        endLane,
+        new Set(fanTargetLanes),
+        activeLanes,
+        gridWidth,
+      ),
     });
   }
 
@@ -1046,7 +1090,7 @@ function layoutComponent(
 
     if (groups.length >= 2) {
       const endLane = Math.max(...laneForGroup);
-      emitBranchConnector(node, column, endLane, groups.length);
+      emitBranchConnector(node, column, endLane, groups.length, laneForGroup);
     }
 
     for (let groupIndex = 0; groupIndex < groups.length; groupIndex++) {