claudecode-omc 4.4.5 → 4.4.6

package/scripts/post-tool-use-failure.mjs

@@ -149,10 +149,28 @@ async function main() {
     // Write error state
     writeErrorState(stateDir, toolName, inputPreview, error, retryCount);
 
-    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+    // Inject continuation guidance so the model analyzes the error instead of stopping.
+    // Without this, PostToolUseFailure returns silently and the model may end its turn.
+    // The PostToolUse hook (post-tool-verifier.mjs) provides similar guidance for
+    // successful Bash calls with error patterns, but PostToolUseFailure is a separate
+    // event that needs its own guidance injection.
+    let guidance;
+    if (retryCount >= 5) {
+      guidance = `Tool "${toolName}" has failed ${retryCount} times. Stop retrying the same approach — try a different command, check dependencies, or ask the user for guidance.`;
+    } else {
+      guidance = `Tool "${toolName}" failed. Analyze the error, fix the issue, and continue working.`;
+    }
+
+    console.log(JSON.stringify({
+      continue: true,
+      hookSpecificOutput: {
+        hookEventName: 'PostToolUseFailure',
+        additionalContext: guidance,
+      },
+    }));
   } catch (error) {
     // Never block on hook errors
-    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+    console.log(JSON.stringify({ continue: true }));
   }
 }
 

package/scripts/post-tool-verifier.mjs

@@ -134,6 +134,47 @@ function stripClaudeTempCwdErrors(output) {
   return output.replace(CLAUDE_TEMP_CWD_PATTERN, '');
 }
 
+// Pattern matching Claude Code's "Error: Exit code N" prefix line
+const CLAUDE_EXIT_CODE_PREFIX = /^Error: Exit code \d+\s*$/gm;
+
+/**
+ * Detect non-zero exit code with valid stdout (issue #960).
+ * Returns true when output has Claude Code's "Error: Exit code N" prefix
+ * AND substantial content that doesn't itself indicate real errors.
+ * Example: `gh pr checks` exits 8 (pending) but outputs valid CI status.
+ */
+export function isNonZeroExitWithOutput(output) {
+  if (!output) return false;
+  const cleaned = stripClaudeTempCwdErrors(output);
+
+  // Must contain Claude Code's exit code prefix
+  if (!CLAUDE_EXIT_CODE_PREFIX.test(cleaned)) return false;
+  // Reset regex state (global flag)
+  CLAUDE_EXIT_CODE_PREFIX.lastIndex = 0;
+
+  // Strip exit code prefix line(s) and check remaining content
+  const remaining = cleaned.replace(CLAUDE_EXIT_CODE_PREFIX, '').trim();
+  CLAUDE_EXIT_CODE_PREFIX.lastIndex = 0;
+
+  // Must have at least one non-empty line of real output
+  const contentLines = remaining.split('\n').filter(l => l.trim().length > 0);
+  if (contentLines.length === 0) return false;
+
+  // If remaining content has its own error indicators, it's a real failure
+  const contentErrorPatterns = [
+    /error:/i,
+    /failed/i,
+    /cannot/i,
+    /permission denied/i,
+    /command not found/i,
+    /no such file/i,
+    /fatal:/i,
+    /abort/i,
+  ];
+
+  return !contentErrorPatterns.some(p => p.test(remaining));
+}
+
 // Detect failures in Bash output
 export function detectBashFailure(output) {
   const cleaned = stripClaudeTempCwdErrors(output);
@@ -206,14 +247,19 @@ function processRememberTags(output, directory) {
 }
 
 // Detect write failure
+// Patterns are tightened to tool-level failure phrases to avoid false positives
+// when edited file content contains error-handling code (issue #1005)
 export function detectWriteFailure(output) {
   const cleaned = stripClaudeTempCwdErrors(output);
   const errorPatterns = [
-    /error/i,
-    /failed/i,
-    /permission denied/i,
-    /read-only/i,
-    /not found/i,
+    /\berror:/i,              // "error:" with word boundary — avoids "setError", "console.error"
+    /\bfailed to\b/i,        // "failed to write" — avoids "failedOidc", UI strings
+    /\bwrite failed\b/i,     // explicit write failure
+    /\boperation failed\b/i, // explicit operation failure
+    /permission denied/i,    // keep as-is (specific enough)
+    /read-only/i,            // keep as-is
+    /\bno such file\b/i,     // more specific than "not found"
+    /\bdirectory not found\b/i,
   ];
 
   return errorPatterns.some(pattern => pattern.test(cleaned));
@@ -251,7 +297,12 @@ function generateMessage(toolName, toolOutput, sessionId, toolCount, directory)
 
   switch (toolName) {
     case 'Bash':
-      if (detectBashFailure(toolOutput)) {
+      if (isNonZeroExitWithOutput(toolOutput)) {
+        // Non-zero exit with valid output — warning, not error (issue #960)
+        const exitMatch = toolOutput.match(/Exit code (\d+)/);
+        const code = exitMatch ? exitMatch[1] : 'non-zero';
+        message = `Command exited with code ${code} but produced valid output. This may be expected behavior.`;
+      } else if (detectBashFailure(toolOutput)) {
         message = 'Command failed. Please investigate the error and fix before continuing.';
       } else if (detectBackgroundOperation(toolOutput)) {
         message = 'Background operation detected. Remember to verify results before proceeding.';

package/scripts/pre-tool-enforcer.mjs

@@ -11,6 +11,17 @@ import { join } from 'path';
 import { pathToFileURL } from 'url';
 import { readStdin } from './lib/stdin.mjs';
 
+const SESSION_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,255}$/;
+const MODE_STATE_FILES = [
+  'autopilot-state.json',
+  'ultrapilot-state.json',
+  'ralph-state.json',
+  'ultrawork-state.json',
+  'ultraqa-state.json',
+  'pipeline-state.json',
+  'team-state.json',
+];
+
 // Simple JSON field extraction
 function extractJsonField(input, field, defaultValue = '') {
   try {
@@ -74,8 +85,88 @@ function getTodoStatus(directory) {
   return '';
 }
 
+function isValidSessionId(sessionId) {
+  return typeof sessionId === 'string' && SESSION_ID_PATTERN.test(sessionId);
+}
+
+function readJsonFile(filePath) {
+  try {
+    if (!existsSync(filePath)) return null;
+    return JSON.parse(readFileSync(filePath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function hasActiveJsonMode(stateDir, { allowSessionTagged = false } = {}) {
+  for (const file of MODE_STATE_FILES) {
+    const state = readJsonFile(join(stateDir, file));
+    if (!state || state.active !== true) continue;
+    if (!allowSessionTagged && state.session_id) continue;
+    return true;
+  }
+  return false;
+}
+
+function hasActiveSwarmMode(stateDir, { allowSessionTagged = false } = {}) {
+  const markerFile = join(stateDir, 'swarm-active.marker');
+  if (!existsSync(markerFile)) return false;
+
+  const summary = readJsonFile(join(stateDir, 'swarm-summary.json'));
+  if (!summary || summary.active !== true) return false;
+  if (!allowSessionTagged && summary.session_id) return false;
+
+  return true;
+}
+
+function hasActiveMode(directory, sessionId) {
+  const stateDir = join(directory, '.omc', 'state');
+
+  if (isValidSessionId(sessionId)) {
+    const sessionStateDir = join(stateDir, 'sessions', sessionId);
+    return (
+      hasActiveJsonMode(sessionStateDir, { allowSessionTagged: true }) ||
+      hasActiveSwarmMode(sessionStateDir, { allowSessionTagged: true })
+    );
+  }
+
+  return (
+    hasActiveJsonMode(stateDir, { allowSessionTagged: false }) ||
+    hasActiveSwarmMode(stateDir, { allowSessionTagged: false })
+  );
+}
+
+/**
+ * Check if team mode is active for the given directory/session.
+ * Reads team-state.json from session-scoped or legacy paths.
+ * Returns the team state object if active, null otherwise.
+ */
+function getActiveTeamState(directory, sessionId) {
+  const paths = [];
+
+  // Session-scoped path (preferred)
+  if (sessionId && SESSION_ID_PATTERN.test(sessionId)) {
+    paths.push(join(directory, '.omc', 'state', 'sessions', sessionId, 'team-state.json'));
+  }
+
+  // Legacy path
+  paths.push(join(directory, '.omc', 'state', 'team-state.json'));
+
+  for (const statePath of paths) {
+    const state = readJsonFile(statePath);
+    if (state && state.active === true) {
+      // Respect session isolation: skip state tagged to a different session
+      if (sessionId && state.session_id && state.session_id !== sessionId) {
+        continue;
+      }
+      return state;
+    }
+  }
+  return null;
+}
+
 // Generate agent spawn message with metadata
-function generateAgentSpawnMessage(toolInput, directory, todoStatus) {
+function generateAgentSpawnMessage(toolInput, directory, todoStatus, sessionId) {
   if (!toolInput || typeof toolInput !== 'object') {
     return `${todoStatus}Launch multiple agents in parallel when tasks are independent. Use run_in_background for long operations.`;
   }
@@ -86,6 +177,20 @@ function generateAgentSpawnMessage(toolInput, directory, todoStatus) {
   const bg = toolInput.run_in_background ? ' [BACKGROUND]' : '';
   const tracking = getAgentTrackingInfo(directory);
 
+  // Team-routing enforcement (issue #1006):
+  // When team state is active and Task is called WITHOUT team_name,
+  // inject a redirect message to use team agents instead of subagents.
+  const teamState = getActiveTeamState(directory, sessionId);
+  if (teamState && !toolInput.team_name) {
+    const teamName = teamState.team_name || teamState.teamName || 'team';
+    return `[TEAM ROUTING REQUIRED] Team "${teamName}" is active but you are spawning a regular subagent ` +
+      `without team_name. You MUST use TeamCreate first (if not already created), then spawn teammates with ` +
+      `Task(team_name="${teamName}", name="worker-N", subagent_type="${agentType}"). ` +
+      `Do NOT use Task without team_name during an active team session. ` +
+      `If TeamCreate is not available in your tools, tell the user to verify ` +
+      `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 is set in ~/.claude/settings.json and restart Claude Code.`;
+  }
+
   const parts = [`${todoStatus}Spawning agent: ${agentType} (${model})${bg}`];
   if (desc) parts.push(`Task: ${desc}`);
   if (tracking.running > 0) parts.push(`Active agents: ${tracking.running}`);
@@ -94,7 +199,7 @@ function generateAgentSpawnMessage(toolInput, directory, todoStatus) {
 }
 
 // Generate contextual message based on tool type
-function generateMessage(toolName, todoStatus) {
+function generateMessage(toolName, todoStatus, modeActive = false) {
   const messages = {
     TodoWrite: `${todoStatus}Mark todos in_progress BEFORE starting, completed IMMEDIATELY after finishing.`,
     Bash: `${todoStatus}Use parallel execution for independent tasks. Use run_in_background for long operations (npm install, builds, tests).`,
@@ -105,7 +210,9 @@ function generateMessage(toolName, todoStatus) {
     Glob: `${todoStatus}Combine searches in parallel when investigating multiple patterns.`,
   };
 
-  return messages[toolName] || `${todoStatus}The boulder never stops. Continue until all tasks complete.`;
+  if (messages[toolName]) return messages[toolName];
+  if (modeActive) return `${todoStatus}The boulder never stops. Continue until all tasks complete.`;
+  return '';
 }
 
 // Record Skill/Task invocations to flow trace (best-effort)
@@ -144,6 +251,14 @@ async function main() {
     try { data = JSON.parse(input); } catch {}
     recordToolInvocation(data, directory);
 
+    const sessionId =
+      typeof data.session_id === 'string'
+        ? data.session_id
+        : typeof data.sessionId === 'string'
+          ? data.sessionId
+          : '';
+    const modeActive = hasActiveMode(directory, sessionId);
+
     // Send notification when AskUserQuestion is about to execute (user input needed)
     // Fires in PreToolUse so users get notified BEFORE the tool blocks for input (#597)
     if (toolName === 'AskUserQuestion') {
@@ -174,9 +289,14 @@ async function main() {
     let message;
     if (toolName === 'Task' || toolName === 'TaskCreate' || toolName === 'TaskUpdate') {
       const toolInput = data.toolInput || data.tool_input || null;
-      message = generateAgentSpawnMessage(toolInput, directory, todoStatus);
+      message = generateAgentSpawnMessage(toolInput, directory, todoStatus, sessionId);
     } else {
-      message = generateMessage(toolName, todoStatus);
+      message = generateMessage(toolName, todoStatus, modeActive);
+    }
+
+    if (!message) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
     }
 
     console.log(JSON.stringify({

package/scripts/run.cjs

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * OMC Cross-platform hook runner (run.cjs)
+ *
+ * Uses process.execPath (the Node binary already running this script) to spawn
+ * the target .mjs hook, bypassing PATH / shell discovery issues.
+ *
+ * Replaces the `sh + find-node.sh` chain that fails on Windows because
+ * /usr/bin/sh is a PE32+ binary the OS refuses to execute natively.
+ * Fixes issues #909, #899, #892, #869.
+ *
+ * Usage (from hooks.json, after setup patches the absolute node path in):
+ *   /abs/path/to/node "${CLAUDE_PLUGIN_ROOT}/scripts/run.cjs" \
+ *       "${CLAUDE_PLUGIN_ROOT}/scripts/<hook>.mjs" [args...]
+ *
+ * During post-install setup, the leading `node` token is replaced with
+ * process.execPath so nvm/fnm users and Windows users all get the right binary.
+ */
+
+const { spawnSync } = require('child_process');
+const { existsSync, realpathSync } = require('fs');
+const { join, basename, dirname } = require('path');
+
+const target = process.argv[2];
+if (!target) {
+  // Nothing to run — exit cleanly so Claude Code hooks are never blocked.
+  process.exit(0);
+}
+
+/**
+ * Resolve the hook script target path, handling stale CLAUDE_PLUGIN_ROOT.
+ *
+ * When a plugin update replaces an old version directory with a symlink (or
+ * deletes it entirely), sessions that still reference the old version via
+ * CLAUDE_PLUGIN_ROOT will fail with MODULE_NOT_FOUND.
+ *
+ * Resolution strategy:
+ *   1. Use the target as-is if it exists.
+ *   2. Try resolving through realpathSync (follows symlinks).
+ *   3. Scan the plugin cache for the latest available version that has the
+ *      same script name and use that instead.
+ *   4. If all else fails, return null (caller exits cleanly).
+ *
+ * See: https://github.com/Yeachan-Heo/oh-my-claudecode/issues/1007
+ */
+function resolveTarget(targetPath) {
+  // Fast path: target exists (common case)
+  if (existsSync(targetPath)) return targetPath;
+
+  // Try realpath resolution (handles broken symlinks that resolve elsewhere)
+  try {
+    const resolved = realpathSync(targetPath);
+    if (existsSync(resolved)) return resolved;
+  } catch {
+    // realpathSync throws if the path doesn't exist at all — expected
+  }
+
+  // Fallback: scan plugin cache for the same script in the latest version.
+  // CLAUDE_PLUGIN_ROOT is e.g. ~/.claude/plugins/cache/omc/oh-my-claudecode/4.2.14
+  // We look one level up for sibling version directories.
+  try {
+    const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT;
+    if (!pluginRoot) return null;
+
+    const cacheBase = dirname(pluginRoot);          // .../oh-my-claudecode/
+    const scriptRelative = targetPath.slice(pluginRoot.length); // /scripts/persistent-mode.cjs
+
+    if (!scriptRelative || !existsSync(cacheBase)) return null;
+
+    // Find version directories (real dirs or valid symlinks), pick latest
+    const { readdirSync, lstatSync, readlinkSync } = require('fs');
+    const entries = readdirSync(cacheBase).filter(v => /^\d+\.\d+\.\d+/.test(v));
+
+    // Sort descending by semver
+    entries.sort((a, b) => {
+      const pa = a.split('.').map(Number);
+      const pb = b.split('.').map(Number);
+      for (let i = 0; i < 3; i++) {
+        if ((pa[i] || 0) !== (pb[i] || 0)) return (pb[i] || 0) - (pa[i] || 0);
+      }
+      return 0;
+    });
+
+    for (const version of entries) {
+      const candidate = join(cacheBase, version) + scriptRelative;
+      if (existsSync(candidate)) return candidate;
+    }
+  } catch {
+    // Any error in fallback scan — give up gracefully
+  }
+
+  return null;
+}
+
+const resolved = resolveTarget(target);
+if (!resolved) {
+  // Target not found anywhere — exit cleanly so hooks are never blocked.
+  // This is the graceful fallback for stale CLAUDE_PLUGIN_ROOT paths.
+  process.exit(0);
+}
+
+const result = spawnSync(
+  process.execPath,
+  [resolved, ...process.argv.slice(3)],
+  {
+    stdio: 'inherit',
+    env: process.env,
+    windowsHide: true,
+  }
+);
+
+// Propagate the child exit code (null → 0 to avoid blocking hooks).
+process.exit(result.status ?? 0);

package/scripts/session-start.mjs

@@ -6,7 +6,7 @@
  * Cross-platform: Windows, macOS, Linux
  */
 
-import { existsSync, readFileSync, readdirSync, rmSync, mkdirSync, writeFileSync } from 'fs';
+import { existsSync, readFileSync, readdirSync, rmSync, mkdirSync, writeFileSync, symlinkSync, lstatSync, readlinkSync, unlinkSync, renameSync } from 'fs';
 import { join, dirname } from 'path';
 import { homedir } from 'os';
 import { fileURLToPath, pathToFileURL } from 'url';
@@ -414,7 +414,10 @@ ${cleanContent}
       }
     }
 
-    // Cleanup old plugin cache versions (keep latest 2)
+    // Cleanup old plugin cache versions (keep latest 2, symlink the rest)
+    // Instead of deleting old versions, replace them with symlinks to the latest.
+    // This prevents "Cannot find module" errors for sessions started before a
+    // plugin update whose CLAUDE_PLUGIN_ROOT still points to the old version.
     try {
       const cacheBase = join(configDir, 'plugins', 'cache', 'omc', 'oh-my-claudecode');
       if (existsSync(cacheBase)) {
@@ -422,11 +425,57 @@ ${cleanContent}
           .filter(v => /^\d+\.\d+\.\d+/.test(v))
           .sort(semverCompare)
           .reverse();
-        const toRemove = versions.slice(2);
-        for (const version of toRemove) {
-          try {
-            rmSync(join(cacheBase, version), { recursive: true, force: true });
-          } catch {}
+
+        if (versions.length > 2) {
+          const latest = versions[0];
+          const toSymlink = versions.slice(2);
+          for (const version of toSymlink) {
+            try {
+              const versionPath = join(cacheBase, version);
+              const stat = lstatSync(versionPath);
+
+              const isWin = process.platform === 'win32';
+              const symlinkTarget = isWin ? join(cacheBase, latest) : latest;
+
+              if (stat.isSymbolicLink()) {
+                // Already a symlink — update only if pointing to wrong target.
+                // Use atomic temp-symlink + rename to avoid a window where
+                // the path doesn't exist (fixes race in issue #1007).
+                const target = readlinkSync(versionPath);
+                if (target === latest || target === join(cacheBase, latest)) continue;
+                try {
+                  const tmpLink = versionPath + '.tmp.' + process.pid;
+                  symlinkSync(symlinkTarget, tmpLink, isWin ? 'junction' : undefined);
+                  try {
+                    renameSync(tmpLink, versionPath);
+                  } catch {
+                    // rename failed (e.g. cross-device) — fall back to unlink+symlink
+                    try { unlinkSync(tmpLink); } catch {}
+                    unlinkSync(versionPath);
+                    symlinkSync(symlinkTarget, versionPath, isWin ? 'junction' : undefined);
+                  }
+                } catch (swapErr) {
+                  if (swapErr?.code !== 'EEXIST') {
+                    // Leave as-is rather than losing it
+                  }
+                }
+              } else if (stat.isDirectory()) {
+                // Directory → symlink: cannot be atomic, but run.cjs now
+                // handles missing targets gracefully (issue #1007).
+                rmSync(versionPath, { recursive: true, force: true });
+                try {
+                  symlinkSync(symlinkTarget, versionPath, isWin ? 'junction' : undefined);
+                } catch (symlinkErr) {
+                  // EEXIST: another session raced us — safe to ignore.
+                  if (symlinkErr?.code !== 'EEXIST') {
+                    // Symlink genuinely failed. Leave the path as-is.
+                  }
+                }
+              }
+            } catch {
+              // lstatSync / rmSync / unlinkSync failure — leave old directory as-is.
+            }
+          }
         }
       }
     } catch {}

package/scripts/status.mjs

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+import { spawnSync } from 'node:child_process';
+
+const SESSION_PREFIX = 'omc-team-';
+
+function runTmux(args) {
+  const result = spawnSync('tmux', args, {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  if (result.error) {
+    return {
+      ok: false,
+      code: 1,
+      stderr: result.error.message,
+      stdout: '',
+    };
+  }
+
+  return {
+    ok: result.status === 0,
+    code: result.status ?? 1,
+    stderr: (result.stderr || '').trim(),
+    stdout: (result.stdout || '').trimEnd(),
+  };
+}
+
+function printTable(rows) {
+  const headers = ['session', 'pane ID', 'command', 'status'];
+  const widths = [
+    headers[0].length,
+    headers[1].length,
+    headers[2].length,
+    headers[3].length,
+  ];
+
+  for (const row of rows) {
+    widths[0] = Math.max(widths[0], row.session.length);
+    widths[1] = Math.max(widths[1], row.paneId.length);
+    widths[2] = Math.max(widths[2], row.command.length);
+    widths[3] = Math.max(widths[3], row.status.length);
+  }
+
+  const format = (cols) =>
+    cols
+      .map((col, idx) => col.padEnd(widths[idx]))
+      .join('  ')
+      .trimEnd();
+
+  const separator = widths
+    .map((w) => '-'.repeat(w))
+    .join('  ')
+    .trimEnd();
+
+  console.log(format(headers));
+  console.log(separator);
+
+  for (const row of rows) {
+    console.log(format([row.session, row.paneId, row.command, row.status]));
+  }
+}
+
+function parsePaneLine(line, session) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+
+  const parts = trimmed.split(/\s+/);
+  if (parts.length < 3) return null;
+
+  const paneId = parts[0];
+  const paneDead = parts[parts.length - 1];
+  const command = parts.slice(1, -1).join(' ');
+
+  return {
+    session,
+    paneId,
+    command,
+    status: paneDead === '1' ? 'dead' : 'alive',
+  };
+}
+
+function main() {
+  const sessionsResult = runTmux(['list-sessions', '-F', '#{session_name}']);
+
+  if (!sessionsResult.ok) {
+    const err = sessionsResult.stderr || 'tmux is unavailable or no server is running.';
+    console.error(`Failed to list tmux sessions: ${err}`);
+    process.exit(1);
+  }
+
+  const sessions = sessionsResult.stdout
+    .split('\n')
+    .map((s) => s.trim())
+    .filter((s) => s.startsWith(SESSION_PREFIX));
+
+  if (sessions.length === 0) {
+    console.error(`No tmux sessions found with prefix '${SESSION_PREFIX}'.`);
+    process.exit(0);
+  }
+
+  const rows = [];
+  let sawDeadPane = false;
+
+  for (const session of sessions) {
+    const panesResult = runTmux([
+      'list-panes',
+      '-t',
+      session,
+      '-F',
+      '#{pane_id} #{pane_current_command} #{pane_dead}',
+    ]);
+
+    if (!panesResult.ok) {
+      const err = panesResult.stderr || `failed to list panes for session ${session}`;
+      console.error(`Failed to inspect panes for '${session}': ${err}`);
+      sawDeadPane = true;
+      continue;
+    }
+
+    const paneLines = panesResult.stdout
+      .split('\n')
+      .map((line) => parsePaneLine(line, session))
+      .filter(Boolean);
+
+    for (const pane of paneLines) {
+      if (pane.status === 'dead') {
+        sawDeadPane = true;
+      }
+      rows.push(pane);
+    }
+  }
+
+  if (rows.length === 0) {
+    console.error('No panes found for matching sessions.');
+    process.exit(sawDeadPane ? 1 : 0);
+  }
+
+  printTable(rows);
+  process.exit(sawDeadPane ? 1 : 0);
+}
+
+main();