aiwcli 0.15.1 → 0.15.3

package/dist/templates/_shared/lib-ts/base/sentinel-ipc.ts

@@ -0,0 +1,87 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+export interface SentinelIpcPaths {
+  tmpDir: string;
+  inputPath: string;
+  stdoutPath: string;
+  stderrPath: string;
+  sentinelPath: string;
+}
+
+function sanitizePrefix(prefix: string): string {
+  return prefix.replaceAll(/[^a-zA-Z0-9_-]/g, "-");
+}
+
+export function createSentinelIpcPaths(prefix: string): SentinelIpcPaths {
+  const safePrefix = sanitizePrefix(prefix);
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), `${safePrefix}-`));
+
+  return {
+    tmpDir,
+    inputPath: path.join(tmpDir, "input.txt"),
+    stdoutPath: path.join(tmpDir, "stdout.txt"),
+    stderrPath: path.join(tmpDir, "stderr.txt"),
+    sentinelPath: path.join(tmpDir, "sentinel.txt"),
+  };
+}
+
+export function buildShellCaptureScript(
+  command: string,
+  paths: Pick<SentinelIpcPaths, "inputPath" | "stdoutPath" | "stderrPath" | "sentinelPath">,
+  quote: (input: string) => string,
+): string {
+  return [
+    command,
+    `< ${quote(paths.inputPath)}`,
+    `> ${quote(paths.stdoutPath)}`,
+    `2> ${quote(paths.stderrPath)}`,
+    `; echo $? > ${quote(paths.sentinelPath)}`,
+  ].join(" ");
+}
+
+export async function waitForSentinelFile(
+  sentinelPath: string,
+  timeoutMs: number,
+  pollIntervalMs = 250,
+): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (fs.existsSync(sentinelPath)) return true;
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+
+  return fs.existsSync(sentinelPath);
+}
+
+export function readSentinelExitCode(sentinelPath: string, fallback = 1): number {
+  if (!fs.existsSync(sentinelPath)) return fallback;
+
+  const raw = fs.readFileSync(sentinelPath, "utf-8").trim();
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+export function readTextIfExists(filePath: string): string {
+  if (!filePath || !fs.existsSync(filePath)) return "";
+  return fs.readFileSync(filePath, "utf-8");
+}
+
+export function cleanupSentinelIpc(paths: Pick<SentinelIpcPaths, "tmpDir">): void {
+  try {
+    fs.rmSync(paths.tmpDir, { recursive: true, force: true });
+  } catch {
+    // Best-effort cleanup.
+  }
+}
+
+export function cleanupSentinelPath(sentinelPath: string | undefined): void {
+  if (!sentinelPath) return;
+
+  try {
+    fs.rmSync(path.dirname(sentinelPath), { recursive: true, force: true });
+  } catch {
+    // Best-effort cleanup.
+  }
+}

package/dist/templates/_shared/lib-ts/base/tmux-driver.ts

@@ -1,20 +1,33 @@
 /**
- * Shared tmux pane driver helpers for launching CLI tools in split panes.
+ * Shared pane driver helpers for launching CLI tools in visible panes.
  *
- * This module centralizes:
- * - tmux/session availability checks
- * - split-pane command launch behavior (auto-close vs hold-open)
- * - REPL prompt injection into tmux panes
- * - optional direct exec fallback when tmux is unavailable
- * - optional provider/model preflight hook point
+ * This module now delegates pane creation to platform-specific launchers:
+ * - tmux (Linux/macOS in tmux sessions)
+ * - Windows Terminal split-pane
+ * - Windows new-window fallback
+ *
+ * Prompt delivery is handled at launch time by passing prompt text as a CLI
+ * argument for REPL mode, rather than injecting into an already-running pane.
  */
 
 import * as fs from "node:fs";
 
+import { createPaneLauncher, type PaneBackend, type PaneSplitDirection } from "./pane-launcher.js";
+import { cleanupSentinelIpc, createSentinelIpcPaths } from "./sentinel-ipc.js";
 import { execFileAsync, findExecutable } from "./subprocess-utils.js";
+import {
+  getTmuxAvailability,
+  normalizeSplitFlag,
+  quoteForSh,
+  type TmuxAvailability,
+  type TmuxSplitFlag,
+} from "./launchers/tmux-launcher.js";
+
+export type { TmuxAvailability, TmuxSplitFlag };
+export { getTmuxAvailability, normalizeSplitFlag, quoteForSh };
 
 export type DriverMode = "exec" | "repl";
-export type TmuxSplitFlag = "-h" | "-v";
+export type TmuxSplitOption = TmuxSplitFlag | "auto";
 
 export interface DriverPreflightResult {
   available: boolean;
@@ -24,27 +37,6 @@ export interface DriverPreflightResult {
 export type DriverPreflight =
   (toolPath: string) => Promise<DriverPreflightResult> | DriverPreflightResult;
 
-export interface SendToPaneOptions {
-  waitForPromptMs?: number;
-  postPasteDelayMs?: number;
-  retryEnter?: boolean;
-  retryDelayMs?: number;
-}
-
-export interface SendToPaneResult {
-  success: boolean;
-  /** Which step failed, if any */
-  failedAt?: "prompt-wait" | "load-buffer" | "paste-buffer" | "send-enter";
-  /** ms spent waiting for REPL prompt */
-  promptWaitMs?: number;
-  /** Last 200 chars of pane content at time of prompt-wait timeout */
-  paneTailOnTimeout?: string;
-  /** stderr from the failed tmux command, if any */
-  tmuxStderr?: string;
-  /** Whether retry Enter was sent */
-  retrySent?: boolean;
-}
-
 export interface LaunchDriverOptions {
   toolName: string;
   toolBin?: string;
@@ -52,8 +44,7 @@ export interface LaunchDriverOptions {
   args?: string[];
   env?: Record<string, string>;
   promptPath?: string;
-  sendPromptInRepl?: boolean;
-  splitFlag?: string;
+  splitFlag?: TmuxSplitOption;
   splitTarget?: string;
   autoClose?: boolean;
   holdPane?: boolean;
@@ -66,31 +57,15 @@ export interface LaunchDriverOptions {
 export interface LaunchDriverResult {
   launched: boolean;
   usedTmux: boolean;
+  backend: PaneBackend;
   mode: DriverMode;
   toolPath?: string;
   paneId?: string;
+  sentinelPath?: string;
   exitCode?: number;
+  stdout?: string;
   reason?: string;
   stderr?: string;
-  sendDiagnostics?: SendToPaneResult;
-}
-
-export interface TmuxAvailability {
-  available: boolean;
-  tmuxPath?: string;
-  reason?: string;
-}
-
-const REPL_PROMPT_REGEX = /(^|\n)\s*[›>]\s/;
-const REPL_ACTIVITY_HINT = "\n• ";
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function getLastLine(text: string): string {
-  const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-  return lines.at(-1) ?? "";
 }
 
 function buildEnvPrefix(env: Record<string, string>): string {
@@ -99,7 +74,21 @@ function buildEnvPrefix(env: Record<string, string>): string {
     .join(" ");
 }
 
-function buildToolCommand(
+function quoteForPowerShell(input: string): string {
+  return `'${input.replaceAll("'", "''")}'`;
+}
+
+function buildCommandArgs(
+  args: string[],
+  mode: DriverMode,
+  promptPath?: string,
+): string[] {
+  if (mode !== "repl" || !promptPath) return args;
+  const promptText = fs.readFileSync(promptPath, "utf-8");
+  return [...args, promptText];
+}
+
+function buildShToolCommand(
   toolPath: string,
   args: string[],
   env: Record<string, string>,
@@ -107,7 +96,8 @@ function buildToolCommand(
   promptPath?: string,
 ): string {
   const envPrefix = buildEnvPrefix(env);
-  const argPart = args.map((arg) => quoteForSh(arg)).join(" ");
+  const commandArgs = buildCommandArgs(args, mode, promptPath);
+  const argPart = commandArgs.map((arg) => quoteForSh(arg)).join(" ");
   const base = [envPrefix, quoteForSh(toolPath), argPart]
     .filter(Boolean)
     .join(" ");
@@ -119,50 +109,63 @@ function buildToolCommand(
   return base;
 }
 
+function buildPowerShellToolCommand(
+  toolPath: string,
+  args: string[],
+  env: Record<string, string>,
+  mode: DriverMode,
+  promptPath?: string,
+): string {
+  const envPrefix = Object.entries(env)
+    .map(([key, value]) => `$env:${key}=${quoteForPowerShell(value)}`)
+    .join("; ");
+
+  const commandArgs = buildCommandArgs(args, mode, promptPath);
+  const argArray = commandArgs.map((arg) => quoteForPowerShell(arg)).join(", ");
+  const invocation = `& ${quoteForPowerShell(toolPath)}${argArray ? ` @(${argArray})` : ""}`;
+
+  const body = mode === "exec" && promptPath
+    ? `Get-Content -Raw -Path ${quoteForPowerShell(promptPath)} | ${invocation}`
+    : invocation;
+
+  return [envPrefix, body].filter(Boolean).join("; ");
+}
+
 function wrapPaneCommand(
+  backend: PaneBackend,
   command: string,
+  sentinelPath: string,
   autoClose: boolean,
   holdPane: boolean,
   holdMessage: string,
 ): string {
-  if (autoClose) {
-    return `${command}; code=$?; tmux kill-pane -t "$TMUX_PANE" >/dev/null 2>&1 || true; exit $code`;
-  }
+  if (backend === "tmux") {
+    const base = `${command}; code=$?; printf '%s' "$code" > ${quoteForSh(sentinelPath)}`;
 
-  if (holdPane) {
-    return `${command}; code=$?; echo; echo ${quoteForSh(holdMessage)}; exec bash`;
-  }
+    if (autoClose) {
+      return `${base}; tmux kill-pane -t "$TMUX_PANE" >/dev/null 2>&1 || true; exit $code`;
+    }
 
-  return command;
-}
+    if (holdPane) {
+      return `${base}; echo; echo ${quoteForSh(holdMessage)}; exec bash`;
+    }
 
-async function capturePaneText(tmuxPath: string, paneId: string): Promise<string> {
-  const result = await execFileAsync(tmuxPath, ["capture-pane", "-p", "-t", paneId], {
-    timeout: 3000,
-  });
-  return result.exitCode === 0 ? result.stdout : "";
-}
+    return `${base}; exit $code`;
+  }
+
+  const base = `${command}; $code = $LASTEXITCODE; Set-Content -Path ${quoteForPowerShell(sentinelPath)} -Value $code -NoNewline`;
 
-async function waitForReplPrompt(
-  tmuxPath: string,
-  paneId: string,
-  timeoutMs: number,
-): Promise<boolean> {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    const snapshot = await capturePaneText(tmuxPath, paneId);
-    if (REPL_PROMPT_REGEX.test(snapshot)) return true;
-    await sleep(250);
+  if (holdPane && !autoClose) {
+    return `${base}; Write-Host ''; Write-Host ${quoteForPowerShell(holdMessage)}; Read-Host -Prompt 'Press Enter to close' | Out-Null`;
   }
-  return false;
-}
 
-export function quoteForSh(input: string): string {
-  return `'${input.replaceAll("'", "'\"'\"'")}'`;
+  return `${base}; exit $code`;
 }
 
-export function normalizeSplitFlag(value: string | undefined): TmuxSplitFlag {
-  return value?.trim() === "-v" ? "-v" : "-h";
+function mapSplitDirection(splitFlag: TmuxSplitOption | undefined): PaneSplitDirection {
+  if (splitFlag === "auto") return "auto";
+  if (splitFlag === "-v") return "v";
+  return "h";
 }
 
 export function isTruthy(value: string | undefined): boolean {
@@ -171,77 +174,24 @@ export function isTruthy(value: string | undefined): boolean {
   return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
 }
 
-export function getTmuxAvailability(): TmuxAvailability {
-  if (!process.env.TMUX) {
-    return { available: false, reason: "TMUX is not set" };
-  }
-
-  const tmuxPath = findExecutable("tmux");
-  if (!tmuxPath) {
-    return { available: false, reason: "tmux not found on PATH" };
-  }
-
-  return { available: true, tmuxPath };
-}
-
 export function resolveToolPath(toolName: string, toolBin?: string): string | null {
   const bin = toolBin?.trim() || toolName;
   return findExecutable(bin);
 }
 
-export async function sendFileToPane(
-  tmuxPath: string,
-  paneId: string,
-  filePath: string,
-  options?: SendToPaneOptions,
-): Promise<SendToPaneResult> {
-  if (!fs.existsSync(filePath)) return { success: false, failedAt: "load-buffer", tmuxStderr: "file not found" };
-
-  const startTime = Date.now();
-  const promptReady = await waitForReplPrompt(tmuxPath, paneId, options?.waitForPromptMs ?? 12000);
-  const promptWaitMs = Date.now() - startTime;
-
-  if (!promptReady) {
-    const snapshot = await capturePaneText(tmuxPath, paneId);
-    const paneTailOnTimeout = snapshot.slice(-200);
-    return { success: false, failedAt: "prompt-wait", promptWaitMs, paneTailOnTimeout };
-  }
-
-  const bufferName = `aiwcli-pane-${Date.now()}`;
-  const load = await execFileAsync(tmuxPath, ["load-buffer", "-b", bufferName, filePath], {
-    timeout: 3000,
-  });
-  if (load.exitCode !== 0) return { success: false, failedAt: "load-buffer", promptWaitMs, tmuxStderr: load.stderr };
-
-  const paste = await execFileAsync(tmuxPath, ["paste-buffer", "-d", "-p", "-b", bufferName, "-t", paneId], {
-    timeout: 3000,
-  });
-  if (paste.exitCode !== 0) return { success: false, failedAt: "paste-buffer", promptWaitMs, tmuxStderr: paste.stderr };
-
-  await sleep(options?.postPasteDelayMs ?? 500);
-
-  const firstEnter = await execFileAsync(tmuxPath, ["send-keys", "-t", paneId, "Enter"], {
-    timeout: 3000,
-  });
-  if (firstEnter.exitCode !== 0) return { success: false, failedAt: "send-enter", promptWaitMs, tmuxStderr: firstEnter.stderr };
-
-  if (options?.retryEnter === false) {
-    return { success: true, promptWaitMs, retrySent: false };
-  }
-
-  let retrySent = false;
-  await sleep(options?.retryDelayMs ?? 1200);
-  const snapshot = await capturePaneText(tmuxPath, paneId);
-  const lastFewLines = snapshot.split(/\r?\n/).slice(-5).join("\n");
-  if (REPL_PROMPT_REGEX.test(lastFewLines) && !lastFewLines.includes(REPL_ACTIVITY_HINT)) {
-    const secondEnter = await execFileAsync(tmuxPath, ["send-keys", "-t", paneId, "Enter"], {
-      timeout: 3000,
-    });
-    if (secondEnter.exitCode !== 0) return { success: false, failedAt: "send-enter", promptWaitMs, tmuxStderr: secondEnter.stderr };
-    retrySent = true;
+function buildCommandForBackend(
+  backend: PaneBackend,
+  toolPath: string,
+  args: string[],
+  envVars: Record<string, string>,
+  mode: DriverMode,
+  promptPath?: string,
+): string {
+  if (backend === "tmux") {
+    return buildShToolCommand(toolPath, args, envVars, mode, promptPath);
   }
 
-  return { success: true, promptWaitMs, retrySent };
+  return buildPowerShellToolCommand(toolPath, args, envVars, mode, promptPath);
 }
 
 export async function launchDriverInTmuxOrFallback(
@@ -257,6 +207,7 @@ export async function launchDriverInTmuxOrFallback(
     return {
       launched: false,
       usedTmux: false,
+      backend: "exec",
       mode,
       reason: `${options.toolBin ?? options.toolName} not found on PATH`,
     };
@@ -268,6 +219,7 @@ export async function launchDriverInTmuxOrFallback(
       return {
         launched: false,
         usedTmux: false,
+        backend: "exec",
         mode,
         toolPath,
         reason: preflight.error ?? "driver preflight failed",
@@ -275,85 +227,89 @@ export async function launchDriverInTmuxOrFallback(
     }
   }
 
-  if (mode === "exec" && options.promptPath && !fs.existsSync(options.promptPath)) {
+  if (options.promptPath && !fs.existsSync(options.promptPath)) {
     return {
       launched: false,
       usedTmux: false,
+      backend: "exec",
       mode,
       toolPath,
       reason: `prompt file not found: ${options.promptPath}`,
     };
   }
 
-  const tmux = getTmuxAvailability();
-  if (tmux.available && tmux.tmuxPath) {
-    const splitFlag = normalizeSplitFlag(options.splitFlag);
-    const splitTarget = options.splitTarget?.trim();
-    const baseCmd = buildToolCommand(toolPath, args, envVars, mode, options.promptPath);
-    const holdMessage = options.holdMessage ?? "[aiwcli] Driver exited. Pane held open.";
-    const paneBody = wrapPaneCommand(
-      baseCmd,
-      Boolean(options.autoClose),
-      Boolean(options.holdPane) && !Boolean(options.autoClose),
-      holdMessage,
-    );
-    const paneCmd = `bash -lc ${quoteForSh(paneBody)}`;
-
-    const tmuxArgs = ["split-window", splitFlag, "-P", "-F", "#{pane_id}"];
-    if (splitTarget) tmuxArgs.push("-t", splitTarget);
-    tmuxArgs.push(paneCmd);
-
-    const split = await execFileAsync(tmux.tmuxPath, tmuxArgs, { timeout: 3000 });
-    if (split.exitCode !== 0) {
-      return {
-        launched: false,
-        usedTmux: true,
-        mode,
-        toolPath,
-        reason: "tmux split-window failed",
-        stderr: split.stderr.trim() || undefined,
-      };
-    }
+  const paneLauncher = await createPaneLauncher({ requireTmuxSession: true });
+  if (paneLauncher) {
+    const sentinel = createSentinelIpcPaths(`aiwcli-pane-${options.toolName}`);
 
-    const paneId = getLastLine(split.stdout);
-    if (mode === "repl" && options.sendPromptInRepl !== false && paneId && options.promptPath) {
-      const sendResult = await sendFileToPane(tmux.tmuxPath, paneId, options.promptPath);
-      if (!sendResult.success) {
+    try {
+      const baseCommand = buildCommandForBackend(
+        paneLauncher.backend,
+        toolPath,
+        args,
+        envVars,
+        mode,
+        options.promptPath,
+      );
+
+      const holdMessage = options.holdMessage ?? "[aiwcli] Driver exited. Pane held open.";
+      const paneCommand = wrapPaneCommand(
+        paneLauncher.backend,
+        baseCommand,
+        sentinel.sentinelPath,
+        Boolean(options.autoClose),
+        Boolean(options.holdPane) && !Boolean(options.autoClose),
+        holdMessage,
+      );
+
+      const paneResult = await paneLauncher.launch({
+        command: paneCommand,
+        splitDirection: mapSplitDirection(options.splitFlag),
+        splitTarget: options.splitTarget,
+      });
+
+      if (!paneResult.launched) {
+        cleanupSentinelIpc(sentinel);
         return {
-          launched: true,
-          usedTmux: true,
+          launched: false,
+          usedTmux: paneLauncher.backend === "tmux",
+          backend: paneLauncher.backend,
           mode,
           toolPath,
-          paneId,
-          reason: `launched, but prompt injection failed at ${sendResult.failedAt}`,
-          sendDiagnostics: sendResult,
+          reason: paneResult.reason ?? "pane launch failed",
+          stderr: paneResult.stderr,
         };
       }
+
       return {
         launched: true,
-        usedTmux: true,
+        usedTmux: paneLauncher.backend === "tmux",
+        backend: paneLauncher.backend,
+        mode,
+        toolPath,
+        paneId: paneResult.paneId,
+        sentinelPath: sentinel.sentinelPath,
+      };
+    } catch (error) {
+      cleanupSentinelIpc(sentinel);
+      return {
+        launched: false,
+        usedTmux: paneLauncher.backend === "tmux",
+        backend: paneLauncher.backend,
         mode,
         toolPath,
-        paneId: paneId || undefined,
-        sendDiagnostics: sendResult,
+        reason: `pane launch failed: ${String(error)}`,
       };
     }
-
-    return {
-      launched: true,
-      usedTmux: true,
-      mode,
-      toolPath,
-      paneId: paneId || undefined,
-    };
   }
 
-  if (mode === "exec" && options.allowExecFallback) {
-    const input = options.promptPath
+  if (options.allowExecFallback) {
+    const commandArgs = buildCommandArgs(args, mode, options.promptPath);
+    const input = mode === "exec" && options.promptPath
       ? fs.readFileSync(options.promptPath, "utf-8")
       : undefined;
 
-    const result = await execFileAsync(toolPath, args, {
+    const result = await execFileAsync(toolPath, commandArgs, {
       input,
       timeout: timeoutMs,
       env: { ...process.env, ...envVars },
@@ -363,19 +319,23 @@ export async function launchDriverInTmuxOrFallback(
     return {
       launched: true,
       usedTmux: false,
+      backend: "exec",
       mode,
       toolPath,
       exitCode: result.exitCode,
+      stdout: result.stdout,
       stderr: result.stderr,
       reason: result.exitCode === 0 ? undefined : `fallback exec exited ${result.exitCode}`,
     };
   }
 
+  const tmux = getTmuxAvailability({ requireSessionEnv: true });
   return {
     launched: false,
     usedTmux: false,
+    backend: "exec",
     mode,
     toolPath,
-    reason: `${tmux.reason ?? "tmux unavailable"}; fallback disabled`,
+    reason: `${tmux.reason ?? "no available pane launcher"}; fallback disabled`,
   };
 }

package/dist/templates/_shared/lib-ts/base/tmux-pane-placement.ts

@@ -0,0 +1,78 @@
+import { execFileAsync } from "./subprocess-utils.js";
+
+export type TmuxSplitFlag = "-h" | "-v";
+
+export interface TmuxPaneInfo {
+  paneId: string;
+  width: number;
+  height: number;
+  active: boolean;
+}
+
+export interface PlacementResult {
+  targetPane: string;
+  splitFlag: TmuxSplitFlag;
+}
+
+const LIST_PANES_FORMAT = "#{pane_id} #{pane_width} #{pane_height} #{pane_active}";
+
+export async function listPanes(tmuxPath: string): Promise<TmuxPaneInfo[]> {
+  const result = await execFileAsync(tmuxPath, ["list-panes", "-F", LIST_PANES_FORMAT], {
+    timeout: 3000,
+  });
+  if (result.exitCode !== 0) return [];
+
+  const panes: TmuxPaneInfo[] = [];
+  for (const rawLine of result.stdout.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+
+    const parts = line.split(/\s+/);
+    if (parts.length < 4) continue;
+
+    const paneId = parts[0] ?? "";
+    const width = Number.parseInt(parts[1] ?? "", 10);
+    const height = Number.parseInt(parts[2] ?? "", 10);
+    const activeRaw = parts[3] ?? "";
+
+    if (!paneId || !Number.isFinite(width) || !Number.isFinite(height)) continue;
+    panes.push({
+      paneId,
+      width,
+      height,
+      active: activeRaw === "1",
+    });
+  }
+
+  return panes;
+}
+
+export function findBestSplit(panes: TmuxPaneInfo[]): PlacementResult | null {
+  if (panes.length === 0) return null;
+
+  let best = panes[0];
+  let bestArea = best.width * best.height;
+
+  for (let i = 1; i < panes.length; i++) {
+    const pane = panes[i];
+    if (!pane) continue;
+    const area = pane.width * pane.height;
+    if (area > bestArea) {
+      best = pane;
+      bestArea = area;
+    }
+  }
+
+  // Terminal cells are ~2x taller than wide (typical monospace font aspect ratio).
+  // Correct for this so BSP splits the visually longer axis, not just the higher
+  // character count. Without this, a 77x68 pane looks "wider" in chars but is
+  // actually much taller in pixels, and should split top/bottom (-v), not left/right.
+  const CELL_ASPECT_RATIO = 2.0;
+  const visualWidth = best.width;
+  const visualHeight = best.height * CELL_ASPECT_RATIO;
+
+  return {
+    targetPane: best.paneId,
+    splitFlag: visualWidth >= visualHeight ? "-h" : "-v",
+  };
+}

package/dist/templates/_shared/lib-ts/context/context-formatter.ts

@@ -255,9 +255,6 @@ export function buildExternalAgentContext(
     `- **Context folder:** ${displayPath(contextDir)}`,
     `- **Notes folder:** ${displayPath(notesDir)}`,
   ];
-  if (ctx.summary) {
-    lines.push(`- **Summary:** ${ctx.summary}`);
-  }
   return lines.join("\n");
 }