z-clean 0.3.2 → 0.3.3

package/README.ko.md

@@ -71,10 +71,12 @@ npx --yes z-clean report
 계속 사용하려면 전역 설치하세요:
 
 ```bash
-npm install -g z-clean
+npm install --global z-clean --foreground-scripts
 zclean report
 ```
 
+`--foreground-scripts`를 사용하면 zclean 설치 워드마크가 표시됩니다. npm 7 이상은 lifecycle 출력을 기본적으로 숨기므로 `npm install -g z-clean`도 정상 설치되지만 완료 화면은 보이지 않을 수 있습니다.
+
 자동 실행은 선택 사항입니다:
 
 ```bash
@@ -93,12 +95,15 @@ zclean report --json    # 자동화용 JSON report
 zclean cache            # workspace cache dry-run scan
 zclean cache --yes      # 지원되는 cache directory 삭제
 zclean cache --json     # cache 후보 JSON 출력
+zclean --pattern=my-agent-worker  # 이번 scan에 literal orphan pattern 추가
 zclean history --json   # 정리 이력 JSON
 zclean protect list     # 보호 목록 확인
 zclean protect add mcp-server-keep
 zclean doctor --json    # 설치/탐지/스케줄러 상태 점검
 ```
 
+패턴을 계속 사용하려면 `~/.zclean/config.json`의 `customPatterns` 배열에 문자열을 추가하세요. 패턴은 정규식이 아닌 대소문자 무시 literal 문자열이며 3–80자의 출력 가능한 문자만 허용됩니다. `node`, `node /`, `ode` 같은 일반 runtime 이름과 부분 문자열은 거부되고, orphan이면서 `maxAge`(기본 24시간)를 넘은 process만 후보가 됩니다. 잘못되거나 0인 기간은 안전한 기본값 24시간으로 돌아갑니다. whitelist, PID 재검증, dry-run, `--yes` 안전장치는 그대로 유지됩니다.
+
 다른 workspace cache를 확인하려면:
 
 ```bash

package/README.md

@@ -15,7 +15,7 @@ AI coding runtime hygiene
 [![Node.js](https://img.shields.io/badge/node-%3E%3D18-339933?style=flat-square&logo=node.js&logoColor=white)](#)
 [![Platform](https://img.shields.io/badge/platform-macOS%20%7C%20Linux%20%7C%20Windows-lightgrey?style=flat-square)](#platform-status)
 [![Zero Dependencies](https://img.shields.io/badge/dependencies-0-blue?style=flat-square)](#)
-[![Tests](https://img.shields.io/badge/tests-105%20passing-brightgreen?style=flat-square)](#)
+[![Tests](https://img.shields.io/badge/tests-142%20passing-brightgreen?style=flat-square)](#)
 [![GitHub stars](https://img.shields.io/github/stars/TheStack-ai/zclean?style=flat-square)](https://github.com/TheStack-ai/zclean)
 [![Mentioned in Awesome Claude Code Toolkit](https://awesome.re/mentioned-badge.svg)](https://github.com/rohitg00/awesome-claude-code-toolkit)
 
@@ -67,10 +67,12 @@ npx --yes z-clean report
 Install the CLI when you are ready to keep using it:
 
 ```bash
-npm install -g z-clean
+npm install --global z-clean --foreground-scripts
 zclean report
 ```
 
+`--foreground-scripts` displays zclean's install wordmark. npm 7+ hides lifecycle output by default, so plain `npm install -g z-clean` still installs correctly but may not show the branded completion screen.
+
 Clean only when you decide:
 
 ```bash
@@ -111,6 +113,7 @@ When an agent crashes, a terminal closes, or a session ends abruptly, those chil
 | `zclean cache` | Dry-run scan for supported workspace cache directories |
 | `zclean cache --yes` | Remove supported workspace cache directories |
 | `zclean cache --json` | Machine-readable cache hygiene report |
+| `zclean --pattern=my-agent-worker` | Add one literal orphan-process pattern for this scan |
 | `zclean history` | Recent cleanup history |
 | `zclean history --json` | Sanitized cleanup history and cumulative stats |
 | `zclean protect list` | Show protected process patterns |
@@ -259,7 +262,8 @@ zclean doctor --json
   "sigterm_timeout": 10,
   "dryRunDefault": true,
   "logRetention": "30d",
-  "customAiDirs": []
+  "customAiDirs": [],
+  "customPatterns": []
 }
 ```
 
@@ -273,6 +277,9 @@ zclean doctor --json
 | `dryRunDefault` | `true` | Manual scans stay dry-run by default; cleanup still requires `--yes` |
 | `logRetention` | `"30d"` | Cleanup history retention |
 | `customAiDirs` | `[]` | Additional AI tool directories to detect, such as `[".mytool"]` |
+| `customPatterns` | `[]` | Case-insensitive literal command fragments for additional orphan processes |
+
+Custom patterns are deliberately restricted: values must contain 3–80 printable characters, generic runtime names and fragments such as `node`, `node /`, or `ode` are rejected, and values are treated as literal text rather than regular expressions. Candidates must be orphaned and older than `maxAge` (24 hours by default); invalid or zero durations fall back to that safe default. Whitelists, PID identity verification, batch limits, dry-run behavior, and the explicit `--yes` cleanup gate still apply.
 
 ## Supported tools
 

package/README.zh.md

@@ -71,10 +71,12 @@ npx --yes z-clean report
 准备长期使用时再全局安装：
 
 ```bash
-npm install -g z-clean
+npm install --global z-clean --foreground-scripts
 zclean report
 ```
 
+`--foreground-scripts` 会显示 zclean 安装字标。npm 7 及以上默认隐藏 lifecycle 输出，因此普通的 `npm install -g z-clean` 仍会正常安装，但可能不显示品牌完成画面。
+
 自动运行是可选项：
 
 ```bash
@@ -93,12 +95,15 @@ zclean report --json    # 自动化 JSON report
 zclean cache            # workspace cache dry-run scan
 zclean cache --yes      # 删除支持的 cache directory
 zclean cache --json     # 输出 cache 候选 JSON
+zclean --pattern=my-agent-worker  # 为本次扫描添加 literal orphan pattern
 zclean history --json   # 清理历史 JSON
 zclean protect list     # 查看保护列表
 zclean protect add mcp-server-keep
 zclean doctor --json    # 检查安装、调度器和进程枚举状态
 ```
 
+如需长期使用，请把字符串加入 `~/.zclean/config.json` 的 `customPatterns` 数组。pattern 是忽略大小写的 literal 文本，不是正则表达式；只允许 3–80 个可打印字符，并拒绝 `node`、`node /`、`ode` 等通用 runtime 名称或片段。只有 orphan 且超过 `maxAge`（默认 24 小时）的 process 才会成为候选项；无效或为零的时长会回退到安全的 24 小时默认值。whitelist、PID 再验证、dry-run 和显式 `--yes` 安全限制仍然有效。
+
 扫描另一个 workspace：
 
 ```bash

package/bin/zclean.js

@@ -6,21 +6,21 @@ const { scan, hasScanErrors } = require('../src/scanner');
 const { killZombies } = require('../src/killer');
 const {
   loadConfig,
-  saveConfig,
   readLogs,
   pruneLogs,
-  DEFAULT_CONFIG,
   appendLog,
   getCumulativeStats,
   getConfigFile,
 } = require('../src/config');
 const { reportDryRun, reportKill, reportStatus, reportLogs, reportConfig, c, bold } = require('../src/reporter');
-const { installHook, removeHook } = require('../src/installer/hook');
+const { removeHook } = require('../src/installer/hook');
 const { runHistory, runProtect } = require('../src/commands/trust');
-const { installScheduler, uninstallScheduler } = require('../src/commands/scheduler');
+const { uninstallScheduler } = require('../src/commands/scheduler');
 const { runDoctor } = require('../src/doctor');
 const { runAudit } = require('../src/audit');
 const { runCache } = require('../src/cache');
+const { getCustomPatternError, normalizeCustomPattern } = require('../src/detector/patterns');
+const { runInit } = require('../src/commands/init');
 
 // Platform-specific installers (lazy loaded)
 const platform = os.platform();
@@ -33,8 +33,10 @@ const positional = [];
 
 for (const arg of args) {
   if (arg.startsWith('--')) {
-    const [key, value] = arg.substring(2).split('=');
-    flags[key] = value !== undefined ? value : true;
+    const body = arg.substring(2);
+    const separator = body.indexOf('=');
+    const key = separator === -1 ? body : body.slice(0, separator);
+    flags[key] = separator === -1 ? true : body.slice(separator + 1);
   } else if (arg.startsWith('-') && arg.length === 2) {
     flags[arg.substring(1)] = true;
   } else {
@@ -64,7 +66,7 @@ async function main() {
 
   switch (command) {
     case 'init':
-      return cmdInit(config);
+      return runInit({ config, platform });
 
     case 'status':
       return cmdStatus(config);
@@ -114,17 +116,19 @@ async function main() {
  * Dry-run unless --yes is passed.
  */
 function cmdScan(config) {
+  const scanConfig = withPatternFlag(config);
+  if (!scanConfig) return;
   const sessionPid = parseSessionPidFlag();
   const force = flags.yes || flags.y;
 
   console.log(bold('\n  zclean') + c('gray', ' — scanning for zombie processes...\n'));
 
-  const zombies = scan(config, { sessionPid });
+  const zombies = scan(scanConfig, { sessionPid });
 
   if (hasScanErrors(zombies)) {
     reportDryRun(zombies);
     appendLog({ action: 'scan-failed', errors: zombies.errors.length });
-    pruneLogs(config);
+    pruneLogs(scanConfig);
     process.exitCode = 1;
     return;
   }
@@ -137,12 +141,12 @@ function cmdScan(config) {
       return;
     }
     appendLog({ action: 'scan', found: zombies.length });
-    const results = killZombies(zombies, config);
+    const results = killZombies(zombies, scanConfig);
     results.cumulative = getCumulativeStats();
     reportKill(results);
   } else {
     // Dry-run mode
-    if (config.dryRunDefault === false) {
+    if (scanConfig.dryRunDefault === false) {
       console.log(c('yellow', '  dryRunDefault=false is not an auto-kill switch; pass --yes to clean.\n'));
     }
     reportDryRun(zombies);
@@ -152,40 +156,16 @@ function cmdScan(config) {
   }
 
   // Prune old logs
-  pruneLogs(config);
-}
-
-/**
- * init: Install hooks + scheduler.
- */
-function cmdInit(config) {
-  console.log(bold('\n  zclean init') + c('gray', ' — installing hooks and scheduler...\n'));
-
-  // 1. Save default config if none exists
-  const existingConfig = loadConfig();
-  if (JSON.stringify(existingConfig) === JSON.stringify(DEFAULT_CONFIG)) {
-    saveConfig(DEFAULT_CONFIG);
-    console.log(c('green', '  Config created:') + ` ${getConfigFile()}`);
-  } else {
-    console.log(c('gray', '  Config exists:') + ` ${getConfigFile()}`);
-  }
-
-  // 2. Install Claude Code hook
-  const hookResult = installHook();
-  const hookIcon = hookResult.installed ? c('green', '  Hook:') : c('yellow', '  Hook:');
-  console.log(`${hookIcon} ${hookResult.message}`);
-
-  // 3. Install platform-specific scheduler
-  installScheduler(platform);
-
-  console.log();
+  pruneLogs(scanConfig);
 }
 
 /**
  * status: Show current zombies and last cleanup info.
  */
 function cmdStatus(config) {
-  const zombies = scan(config);
+  const scanConfig = withPatternFlag(config);
+  if (!scanConfig) return;
+  const zombies = scan(scanConfig);
   const logs = readLogs(100);
   reportStatus(zombies, logs);
   if (hasScanErrors(zombies)) process.exitCode = 1;
@@ -232,8 +212,10 @@ function cmdDoctor(config) {
 }
 
 function cmdAudit(config, commandName = 'audit') {
+  const scanConfig = withPatternFlag(config);
+  if (!scanConfig) return;
   const sessionPid = parseSessionPidFlag();
-  const report = runAudit(config, { json: Boolean(flags.json), sessionPid, commandName });
+  const report = runAudit(scanConfig, { json: Boolean(flags.json), sessionPid, commandName });
   if (!report.risk.enumerationComplete) process.exitCode = 1;
 }
 
@@ -257,6 +239,19 @@ function parseSessionPidFlag() {
   process.exit(1);
 }
 
+function withPatternFlag(config) {
+  if (flags.pattern === undefined) return config;
+  const error = getCustomPatternError(flags.pattern);
+  if (error) {
+    console.error(c('red', `  ${error}`));
+    process.exitCode = 1;
+    return null;
+  }
+  const literal = normalizeCustomPattern(flags.pattern);
+  const configured = Array.isArray(config.customPatterns) ? config.customPatterns : [];
+  return { ...config, customPatterns: [...configured, literal] };
+}
+
 // ─── Help ───────────────────────────────────────────────────────────────────
 
 function printHelp() {
@@ -285,6 +280,7 @@ function printHelp() {
   ${bold('Options:')}
     --yes, -y             Kill found zombies (default: dry-run)
     --session-pid=PID     Filter by parent session PID
+    --pattern=TEXT        Add a literal orphan-process pattern
     --path=DIR            Workspace path for zclean cache
     --json                Print machine-readable output for supported commands
     --version, -v         Show version

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "z-clean",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "AI coding runtime hygiene reports, zombie cleanup, and safe workspace cache cleanup",
   "bin": {
     "zclean": "bin/zclean.js"
   },
   "scripts": {
-    "test": "node --test test/patterns.test.js test/scanner.test.js test/process-tree.test.js test/killer.test.js test/config.test.js test/installer-fallback.test.js test/cli.test.js test/cli-history-protect.test.js test/cli-doctor.test.js test/audit.test.js test/cache.test.js",
+    "test": "node --test test/patterns.test.js test/scanner.test.js test/process-tree.test.js test/killer.test.js test/config.test.js test/installer-fallback.test.js test/install-experience.test.js test/reporter.test.js test/cli.test.js test/cli-history-protect.test.js test/cli-doctor.test.js test/audit.test.js test/cache.test.js",
     "syntax": "node -e \"const fs=require('node:fs');const path=require('node:path');const {execFileSync}=require('node:child_process');const files=['bin/zclean.js'];function walk(dir){if(!fs.existsSync(dir))return;for(const entry of fs.readdirSync(dir,{withFileTypes:true})){const file=path.join(dir,entry.name);if(entry.isDirectory())walk(file);else if(entry.name.endsWith('.js'))files.push(file);}}for(const dir of ['src','test','scripts'])walk(dir);for(const file of files)execFileSync(process.execPath,['-c',file],{stdio:'inherit'});\"",
     "smoke": "node scripts/smoke.js",
-    "pack:check": "npm pack --dry-run --json"
+    "pack:check": "npm pack --dry-run --json",
+    "postinstall": "node scripts/postinstall.js"
   },
   "keywords": [
     "claude-code",
@@ -40,6 +41,7 @@
   "files": [
     "bin/",
     "src/",
+    "scripts/postinstall.js",
     "assets/zclean-hero.png",
     "LICENSE",
     "README.md",

package/scripts/postinstall.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+'use strict';
+
+const { version } = require('../package.json');
+const { renderPostinstall } = require('../src/cli-brand');
+
+process.stdout.write(renderPostinstall({ version }));

package/src/cli-brand.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const { c, bold } = require('./reporter');
+const { sanitizeTerminalText } = require('./terminal-text');
+
+const WORDMARK = [
+  '  ███████  ██████ ██      ███████  █████  ███    ██',
+  '       ██ ██      ██      ██      ██   ██ ████   ██',
+  '     ███  ██      ██      █████   ███████ ██ ██  ██',
+  '   ██     ██      ██      ██      ██   ██ ██  ██ ██',
+  '  ███████  ██████ ███████ ███████ ██   ██ ██   ████',
+];
+
+const RULE = '  --------------------------------------------------------';
+const FRAME_WIDTH = 55;
+
+function renderPostinstall({ version }) {
+  return [
+    '',
+    c('gray', '     .   +  .'),
+    c('gray', '  +    .     :'),
+    ...WORDMARK.map((line) => c('cyan', line)),
+    '',
+    `  ${bold('Z / CLEAN')}  ${c('gray', `v${version}`)}`,
+    c('gray', '  AI CODING RUNTIME HYGIENE'),
+    c('gray', RULE),
+    '',
+    `  ${c('green', 'INSTALLED')}   z-clean`,
+    `  ${c('gray', 'COMMAND')}     zclean`,
+    `  ${c('gray', 'SAFETY')}      dry-run by default`,
+    '',
+    c('gray', '  Continue setup'),
+    `    ${c('cyan', '$ zclean init')}`,
+    '',
+    c('gray', '  Inspect first. Clean only when you decide.'),
+    '',
+  ].join('\n');
+}
+
+function renderInit({ version, steps, warningCount }) {
+  const lines = [
+    '',
+    c('gray', '     .   +  .'),
+    c('gray', '  +    .     :'),
+    ...WORDMARK.map((line) => c('cyan', line)),
+    '',
+    `  ${bold('Z / CLEAN')}  ${c('gray', `v${version}`)}`,
+    c('gray', '  RUNTIME HYGIENE SYSTEM'),
+    '',
+    c('gray', `  +${'-- SETUP '.padEnd(FRAME_WIDTH, '-')}+`),
+    c('gray', `  |${''.padEnd(FRAME_WIDTH)}|`),
+  ];
+
+  for (const step of steps) {
+    lines.push(renderStep(step));
+  }
+
+  const ready = warningCount === 0;
+  lines.push(
+    c('gray', `  |${''.padEnd(FRAME_WIDTH)}|`),
+    c('gray', `  +${''.padEnd(FRAME_WIDTH, '-')}+`),
+    '',
+    ready
+      ? c('green', '  SYSTEM READY')
+      : c('yellow', `  SETUP COMPLETED WITH ${warningCount} WARNING${warningCount === 1 ? '' : 'S'}`),
+    '',
+    `  ${c('gray', 'Inspect runtime leftovers')}   ${c('cyan', 'zclean audit')}`,
+    `  ${c('gray', 'Verify this installation')}    ${c('cyan', 'zclean doctor')}`,
+    '',
+    c('gray', '  Cleanup remains locked until you pass --yes.'),
+    ''
+  );
+
+  return lines.join('\n');
+}
+
+function renderStep(step) {
+  const state = String(step.state).padEnd(10);
+  const label = String(step.label).padEnd(14);
+  const tone = step.state === 'WARNING' ? 'yellow' : step.state === 'EXISTS' ? 'gray' : 'green';
+  const statusPrefix = `  ${step.index}  ${label} `;
+  const statusSpacing = ''.padEnd(FRAME_WIDTH - statusPrefix.length - state.length);
+  const detail = padToWidth(`      ${fitDetail(step.detail)}`, FRAME_WIDTH);
+  return [
+    `  |${c('gray', statusPrefix)}${c(tone, state)}${statusSpacing}|`,
+    `  |${c('gray', detail)}|`,
+  ].join('\n');
+}
+
+function fitDetail(value) {
+  const text = sanitizeTerminalText(value).replace(/\s+/g, ' ').trim();
+  if (displayWidth(text) <= 45) return text;
+  let output = '';
+  let width = 0;
+  for (const char of text) {
+    const next = charWidth(char);
+    if (width + next > 42) break;
+    output += char;
+    width += next;
+  }
+  return `${output}...`;
+}
+
+function padToWidth(value, width) {
+  return `${value}${''.padEnd(Math.max(0, width - displayWidth(value)))}`;
+}
+
+function displayWidth(value) {
+  return [...value].reduce((width, char) => width + charWidth(char), 0);
+}
+
+function charWidth(char) {
+  if (/\p{Mark}/u.test(char)) return 0;
+  const code = char.codePointAt(0);
+  const wide = code >= 0x1100 && (
+    code <= 0x115f || code === 0x2329 || code === 0x232a ||
+    (code >= 0x2e80 && code <= 0xa4cf && code !== 0x303f) ||
+    (code >= 0xac00 && code <= 0xd7a3) ||
+    (code >= 0xf900 && code <= 0xfaff) ||
+    (code >= 0xfe10 && code <= 0xfe6f) ||
+    (code >= 0xff00 && code <= 0xff60) ||
+    (code >= 0xffe0 && code <= 0xffe6) ||
+    (code >= 0x1f300 && code <= 0x1f9ff) ||
+    (code >= 0x20000 && code <= 0x3fffd)
+  );
+  return wide ? 2 : 1;
+}
+
+module.exports = { renderPostinstall, renderInit };

package/src/commands/init.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const { saveConfig, getConfigFile } = require('../config');
+const { installHook } = require('../installer/hook');
+const { installScheduler, getSchedulerState } = require('./scheduler');
+const { renderInit } = require('../cli-brand');
+const { version } = require('../../package.json');
+
+function runInit({ config, platform }) {
+  const configFile = getConfigFile();
+  const configExists = fs.existsSync(configFile);
+  if (!configExists) saveConfig(config);
+
+  const hookResult = installHook();
+  const schedulerResult = installScheduler(platform);
+  const schedulerState = getSchedulerState(schedulerResult);
+  const steps = [
+    {
+      index: '01',
+      label: 'CONFIG',
+      state: configExists ? 'EXISTS' : 'READY',
+      detail: configFile.replace(os.homedir(), '~'),
+    },
+    {
+      index: '02',
+      label: 'CLAUDE HOOK',
+      state: hookResult.installed ? 'INSTALLED' : 'WARNING',
+      detail: hookResult.installed ? 'SessionEnd cleanup hook registered' : hookResult.message,
+    },
+    {
+      index: '03',
+      label: 'SCHEDULER',
+      state: schedulerState,
+      detail: schedulerState === 'ACTIVE' ? schedulerLabel(platform) : schedulerResult.message,
+    },
+  ];
+  const warningCount = steps.filter((step) => step.state === 'WARNING').length;
+  console.log(renderInit({ version, steps, warningCount }));
+}
+
+function schedulerLabel(platform) {
+  if (platform === 'darwin') return 'Hourly launchd hygiene check';
+  if (platform === 'linux') return 'Hourly systemd hygiene timer';
+  if (platform === 'win32') return 'Hourly Task Scheduler check';
+  return 'Runtime hygiene scheduler';
+}
+
+module.exports = { runInit };

package/src/commands/scheduler.js

@@ -6,53 +6,57 @@ function installScheduler(platform) {
   switch (platform) {
     case 'darwin': {
       const { installLaunchd } = require('../installer/launchd');
-      const result = installLaunchd();
-      const icon = result.installed ? c('green', '  Scheduler:') : c('yellow', '  Scheduler:');
-      console.log(`${icon} ${result.message}`);
-      break;
+      return installLaunchd();
     }
     case 'linux': {
       const { installSystemd } = require('../installer/systemd');
-      const result = installSystemd();
-      const icon = result.installed ? c('green', '  Scheduler:') : c('yellow', '  Scheduler:');
-      console.log(`${icon} ${result.message}`);
-      break;
+      return installSystemd();
     }
     case 'win32': {
       const { installTaskScheduler } = require('../installer/taskscheduler');
-      const result = installTaskScheduler();
-      const icon = result.installed ? c('green', '  Scheduler:') : c('yellow', '  Scheduler:');
-      console.log(`${icon} ${result.message}`);
-      break;
+      return installTaskScheduler();
     }
     default:
-      console.log(c('yellow', `  Scheduler: Unsupported platform (${platform}). Install a cron job manually.`));
+      return {
+        installed: false,
+        message: `Unsupported platform (${platform}). Install a cron job manually.`,
+      };
   }
 }
 
-function uninstallScheduler(platform) {
+function uninstallScheduler(platform, options = {}) {
+  const log = options.log || console.log;
+  let result;
   switch (platform) {
     case 'darwin': {
       const { removeLaunchd } = require('../installer/launchd');
-      const result = removeLaunchd();
-      console.log(`  Scheduler: ${result.message}`);
+      result = (options.remove || removeLaunchd)();
+      log(`  Scheduler: ${result.message}`);
       break;
     }
     case 'linux': {
       const { removeSystemd } = require('../installer/systemd');
-      const result = removeSystemd();
-      console.log(`  Scheduler: ${result.message}`);
+      result = (options.remove || removeSystemd)();
+      log(`  Scheduler: ${result.message}`);
       break;
     }
     case 'win32': {
       const { removeTaskScheduler } = require('../installer/taskscheduler');
-      const result = removeTaskScheduler();
-      console.log(`  Scheduler: ${result.message}`);
+      result = (options.remove || removeTaskScheduler)();
+      log(`  Scheduler: ${result.message}`);
       break;
     }
-    default:
-      console.log(c('yellow', `  Scheduler: Remove manually for ${platform}.`));
+    default: {
+      result = { removed: false, failed: false, message: `Remove manually for ${platform}.` };
+      log(c('yellow', `  Scheduler: ${result.message}`));
+    }
   }
+  if (result.failed) process.exitCode = 1;
+  return result;
+}
+
+function getSchedulerState(result) {
+  return result.installed && result.active !== false ? 'ACTIVE' : 'WARNING';
 }
 
-module.exports = { installScheduler, uninstallScheduler };
+module.exports = { installScheduler, uninstallScheduler, getSchedulerState };

package/src/config.js

@@ -40,6 +40,7 @@ const DEFAULT_CONFIG = {
   logRetention: '30d',
   maxKillBatch: 20,
   customAiDirs: [],
+  customPatterns: [],
 };
 
 /**
@@ -91,7 +92,9 @@ function loadConfig() {
     try {
       const raw = fs.readFileSync(configFile, 'utf-8');
       const userConfig = JSON.parse(raw);
-      return { ...DEFAULT_CONFIG, ...userConfig };
+      const config = { ...DEFAULT_CONFIG, ...userConfig };
+      if (!(parseDuration(config.maxAge) > 0)) config.maxAge = DEFAULT_CONFIG.maxAge;
+      return config;
     } catch {
       // Corrupted config — use defaults
       return { ...DEFAULT_CONFIG };

package/src/detector/custom-patterns.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const { parseDuration } = require('../config');
+
+const CUSTOM_PATTERN_MIN = 3;
+const CUSTOM_PATTERN_MAX = 80;
+const SAFE_CUSTOM_MAX_AGE = '24h';
+const GENERIC_CUSTOM_PATTERNS = new Set([
+  'bash', 'bun', 'bunx', 'cargo', 'chrome', 'chromium', 'cmd', 'corepack', 'cscript', 'deno', 'dotnet', 'esbuild', 'fish',
+  'go', 'java', 'javaw', 'node', 'nodejs', 'npm', 'npx', 'perl', 'php', 'pip', 'pip3', 'pipx', 'pnpm',
+  'powershell', 'powershell_ise', 'pwsh', 'py', 'pyw', 'python', 'python3', 'pythonw', 'ruby', 'server', 'sh', 'sleep', 'ts-node', 'tsx',
+  'uv', 'vite', 'worker', 'wscript', 'yarn', 'zsh',
+]);
+
+function getCustomPatternError(value) {
+  if (typeof value !== 'string') return '--pattern must be a literal between 3 and 80 characters.';
+  const literal = value.trim();
+  if (literal.length < CUSTOM_PATTERN_MIN || literal.length > CUSTOM_PATTERN_MAX) {
+    return '--pattern must be a literal between 3 and 80 characters.';
+  }
+  if (/[\p{Cc}\p{Cf}]/u.test(literal)) {
+    return '--pattern must contain printable characters only.';
+  }
+  const lower = literal.toLowerCase();
+  const genericFragment = [...GENERIC_CUSTOM_PATTERNS].some((name) => name.includes(lower));
+  const genericExecutable = lower.split(/[\s/\\'"`]+/).some(isGenericExecutableToken);
+  if (genericFragment || genericExecutable) {
+    return '--pattern must be specific; generic runtime names are not allowed.';
+  }
+  return null;
+}
+
+function isGenericExecutableToken(token) {
+  const basename = token
+    .replace(/^[^a-z0-9]+|[^a-z0-9.]+$/g, '')
+    .replace(/\.(?:exe|cmd|bat|com)$/i, '');
+  const executableName = basename
+    .replace(/\.(?:cjs|mjs|js)$/i, '')
+    .replace(/-cli$/i, '');
+  return GENERIC_CUSTOM_PATTERNS.has(executableName)
+    || isVersionedGenericRuntime(executableName);
+}
+
+function isVersionedGenericRuntime(value) {
+  const match = value.match(/^([a-z][a-z_-]*?)(?:\d[\d.]*(?:[a-z][a-z0-9]*)?)$/);
+  return Boolean(match && GENERIC_CUSTOM_PATTERNS.has(match[1]));
+}
+
+function normalizeCustomPattern(value) {
+  if (getCustomPatternError(value)) return null;
+  return value.trim();
+}
+
+function getCustomPatterns(config) {
+  if (!Array.isArray(config?.customPatterns)) return [];
+  return [...new Set(config.customPatterns.map(normalizeCustomPattern).filter(Boolean))];
+}
+
+function createCustomPattern(literal, config) {
+  const configuredAge = config?.maxAge;
+  const maxOrphanAge = parseDuration(configuredAge) > 0
+    ? configuredAge
+    : SAFE_CUSTOM_MAX_AGE;
+  return {
+    name: `custom:${literal}`,
+    literal,
+    minAge: 0,
+    maxOrphanAge,
+    orphanOnly: true,
+    strictOrphan: true,
+  };
+}
+
+module.exports = {
+  createCustomPattern,
+  getCustomPatternError,
+  getCustomPatterns,
+  normalizeCustomPattern,
+};

package/src/detector/patterns.js

@@ -1,5 +1,12 @@
 'use strict';
 
+const {
+  createCustomPattern,
+  getCustomPatternError,
+  getCustomPatterns,
+  normalizeCustomPattern,
+} = require('./custom-patterns');
+
 /**
  * Process patterns to detect AI tool zombies.
  *
@@ -211,7 +218,7 @@ const PATTERNS = [
  * @param {object} [config] — optional config with customAiDirs
  * @returns {object|null} matched pattern or null
  */
-function matchPattern(cmdline, config) {
+function matchPattern(cmdline, config, customPatterns = getCustomPatterns(config)) {
   const aiRegex = config && config.customAiDirs && config.customAiDirs.length > 0
     ? buildAiDirRegex(config.customAiDirs)
     : AI_DIR_REGEX;
@@ -225,7 +232,28 @@ function matchPattern(cmdline, config) {
       return pattern;
     }
   }
+
+  const command = String(cmdline).toLowerCase();
+  for (const literal of customPatterns) {
+    if (command.includes(literal.toLowerCase())) {
+      return createCustomPattern(literal, config);
+    }
+  }
   return null;
 }
 
-module.exports = { PATTERNS, AI_TOOL_DIRS, AI_DIR_REGEX, buildAiDirRegex, matchPattern };
+function createPatternMatcher(config) {
+  const customPatterns = getCustomPatterns(config);
+  return (cmdline) => matchPattern(cmdline, config, customPatterns);
+}
+
+module.exports = {
+  PATTERNS,
+  AI_TOOL_DIRS,
+  AI_DIR_REGEX,
+  buildAiDirRegex,
+  createPatternMatcher,
+  getCustomPatternError,
+  matchPattern,
+  normalizeCustomPattern,
+};

package/src/installer/launchd.js

@@ -3,7 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const { execSync } = require('child_process');
+const { execFileSync, execSync } = require('child_process');
 const { LOCAL_BIN_HINT, resolveZcleanBin } = require('./bin-path');
 
 const PLIST_NAME = 'com.zclean.hourly';
@@ -136,12 +136,14 @@ function installLaunchd() {
   } catch (err) {
     return {
       installed: true,
+      active: false,
       message: `Plist written to ${PLIST_PATH} but launchctl load failed: ${err.message}. Try: launchctl bootstrap gui/$(id -u) ${PLIST_PATH}`,
     };
   }
 
   return {
     installed: true,
+    active: true,
     message: `Hourly launchd agent installed: ${PLIST_PATH}`,
   };
 }
@@ -151,32 +153,79 @@ function installLaunchd() {
  *
  * @returns {{ removed: boolean, message: string }}
  */
-function removeLaunchd() {
-  if (os.platform() !== 'darwin') {
-    return { removed: false, message: 'launchd is macOS only.' };
-  }
-
-  if (!fs.existsSync(PLIST_PATH)) {
-    return { removed: false, message: 'Plist not found. Already uninstalled.' };
+function removeLaunchd(options = {}) {
+  const platform = options.platform || os.platform();
+  const plistPath = options.plistPath || PLIST_PATH;
+  const uid = options.uid ?? process.getuid?.();
+  const run = options.execFileSync || execFileSync;
+
+  if (platform !== 'darwin') {
+    return { removed: false, failed: false, message: 'launchd is macOS only.' };
   }
 
+  const hasPlist = fs.existsSync(plistPath);
+  let unloaded = false;
+  let serviceRemoved = false;
+  let stateUnknown = false;
   try {
-    execSync(`launchctl bootout gui/${process.getuid()} ${PLIST_PATH}`, {
-      encoding: 'utf-8',
-      timeout: 5000,
-    });
+    run('launchctl', ['bootout', `gui/${uid}/${PLIST_NAME}`], launchctlOptions());
+    unloaded = true;
+    serviceRemoved = true;
   } catch {
-    // Might not be loaded
+    if (hasPlist) {
+      try {
+        run('launchctl', ['bootout', `gui/${uid}`, plistPath], launchctlOptions());
+        unloaded = true;
+        serviceRemoved = true;
+      } catch {}
+    }
+  }
+
+  if (!unloaded) {
+    try {
+      run('launchctl', ['print', `gui/${uid}/${PLIST_NAME}`], launchctlOptions());
+    } catch (err) {
+      if (isLaunchdServiceMissing(err)) {
+        unloaded = true;
+      } else {
+        stateUnknown = true;
+      }
+    }
+  }
+
+  if (!unloaded) {
+    return {
+      removed: false,
+      failed: true,
+      message: stateUnknown
+        ? 'Could not verify launchd service removal; plist preserved when present.'
+        : 'launchd agent is still loaded; plist preserved for a later retry.',
+    };
   }
 
-  fs.unlinkSync(PLIST_PATH);
+  if (hasPlist) fs.unlinkSync(plistPath);
+  if (!hasPlist && !serviceRemoved) {
+    return { removed: false, failed: false, message: 'Plist and launchd service not found. Already uninstalled.' };
+  }
 
   return {
     removed: true,
-    message: `launchd agent removed: ${PLIST_PATH}`,
+    failed: false,
+    message: hasPlist
+      ? `launchd agent removed: ${plistPath}`
+      : 'launchd service removed; plist was already absent.',
   };
 }
 
+function launchctlOptions() {
+  return { encoding: 'utf-8', timeout: 5000 };
+}
+
+function isLaunchdServiceMissing(err) {
+  const output = `${err?.message || ''}\n${String(err?.stdout || '')}\n${String(err?.stderr || '')}`;
+  return /could not find service|service not found|no such process/i.test(output);
+}
+
 function escapeXml(value) {
   return String(value)
     .replace(/&/g, '&')

package/src/installer/systemd.js

@@ -3,7 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const { execSync } = require('child_process');
+const { execFileSync, execSync } = require('child_process');
 const { LOCAL_BIN_HINT, quoteSystemdArg, resolveZcleanBin } = require('./bin-path');
 
 const SYSTEMD_USER_DIR = path.join(os.homedir(), '.config', 'systemd', 'user');
@@ -72,6 +72,7 @@ function installSystemd() {
 
   // Reload and enable
   const messages = [];
+  let active = true;
   try {
     execSync('systemctl --user daemon-reload', { encoding: 'utf-8', timeout: 5000 });
     execSync(`systemctl --user enable --now ${SERVICE_NAME}.timer`, {
@@ -80,6 +81,7 @@ function installSystemd() {
     });
     messages.push(`Timer installed and enabled: ${TIMER_PATH}`);
   } catch (err) {
+    active = false;
     messages.push(`Files written but systemctl failed: ${err.message}`);
     messages.push(`Try manually: systemctl --user enable --now ${SERVICE_NAME}.timer`);
   }
@@ -96,6 +98,7 @@ function installSystemd() {
 
   return {
     installed: true,
+    active,
     message: messages.join('\n'),
   };
 }
@@ -105,41 +108,57 @@ function installSystemd() {
  *
  * @returns {{ removed: boolean, message: string }}
  */
-function removeSystemd() {
-  if (os.platform() !== 'linux') {
-    return { removed: false, message: 'systemd is Linux only.' };
+function removeSystemd(options = {}) {
+  const platform = options.platform || os.platform();
+  const servicePath = options.servicePath || SERVICE_PATH;
+  const timerPath = options.timerPath || TIMER_PATH;
+  const run = options.execFileSync || execFileSync;
+  if (platform !== 'linux') {
+    return { removed: false, failed: false, message: 'systemd is Linux only.' };
   }
 
-  // Disable timer
+  const hasFiles = fs.existsSync(servicePath) || fs.existsSync(timerPath);
   try {
-    execSync(`systemctl --user disable --now ${SERVICE_NAME}.timer`, {
-      encoding: 'utf-8',
-      timeout: 5000,
-    });
-  } catch {
-    // Might not be running
+    run('systemctl', ['--user', 'disable', '--now', `${SERVICE_NAME}.timer`], systemctlOptions());
+  } catch (err) {
+    if (!hasFiles && isSystemdUnitMissing(err)) {
+      return { removed: false, failed: false, message: 'Files and timer not found. Already uninstalled.' };
+    }
+    return {
+      removed: false,
+      failed: true,
+      message: 'Could not disable systemd timer; unit files preserved for a later retry.',
+    };
   }
 
-  // Remove files
-  let removed = false;
-  for (const filepath of [SERVICE_PATH, TIMER_PATH]) {
+  for (const filepath of [servicePath, timerPath]) {
     if (fs.existsSync(filepath)) {
       fs.unlinkSync(filepath);
-      removed = true;
     }
   }
 
-  // Reload daemon
   try {
-    execSync('systemctl --user daemon-reload', { encoding: 'utf-8', timeout: 5000 });
-  } catch { /* ignore */ }
+    run('systemctl', ['--user', 'daemon-reload'], systemctlOptions());
+  } catch {
+    return { removed: true, failed: true, message: 'Timer disabled, but systemd daemon-reload failed.' };
+  }
 
   return {
-    removed,
-    message: removed ? 'systemd timer and service removed.' : 'Files not found. Already uninstalled.',
+    removed: true,
+    failed: false,
+    message: 'systemd timer and service removed.',
   };
 }
 
+function systemctlOptions() {
+  return { encoding: 'utf-8', timeout: 5000 };
+}
+
+function isSystemdUnitMissing(err) {
+  const output = `${err?.message || ''}\n${String(err?.stdout || '')}\n${String(err?.stderr || '')}`;
+  return /unit .* (?:does not exist|not found|could not be found)/i.test(output);
+}
+
 module.exports = {
   installSystemd,
   removeSystemd,

package/src/installer/taskscheduler.js

@@ -45,11 +45,13 @@ function installTaskScheduler() {
     execFileSync('schtasks', args, { encoding: 'utf-8', timeout: 10000 });
     return {
       installed: true,
+      active: true,
       message: `Task Scheduler task created: ${TASK_NAME} (hourly)`,
     };
   } catch (err) {
     return {
       installed: false,
+      active: false,
       message: `Failed to create scheduled task: ${err.message}\nTry running as administrator.`,
     };
   }
@@ -60,31 +62,40 @@ function installTaskScheduler() {
  *
  * @returns {{ removed: boolean, message: string }}
  */
-function removeTaskScheduler() {
-  if (os.platform() !== 'win32') {
-    return { removed: false, message: 'Task Scheduler is Windows only.' };
+function removeTaskScheduler(options = {}) {
+  const platform = options.platform || os.platform();
+  const run = options.execFileSync || execFileSync;
+  if (platform !== 'win32') {
+    return { removed: false, failed: false, message: 'Task Scheduler is Windows only.' };
   }
 
   try {
-    execFileSync('schtasks', ['/delete', '/TN', TASK_NAME, '/F'], {
+    run('schtasks', ['/delete', '/TN', TASK_NAME, '/F'], {
       encoding: 'utf-8',
       timeout: 10000,
     });
     return {
       removed: true,
+      failed: false,
       message: `Task Scheduler task removed: ${TASK_NAME}`,
     };
   } catch (err) {
-    if (err.message.includes('does not exist') || err.message.includes('ERROR')) {
-      return { removed: false, message: 'Task not found. Already uninstalled.' };
+    if (isTaskMissing(err)) {
+      return { removed: false, failed: false, message: 'Task not found. Already uninstalled.' };
     }
     return {
       removed: false,
+      failed: true,
       message: `Failed to remove task: ${err.message}`,
     };
   }
 }
 
+function isTaskMissing(err) {
+  const output = `${err?.message || ''}\n${String(err?.stdout || '')}\n${String(err?.stderr || '')}`;
+  return /task name(?: .*?)? does not exist|cannot find the (?:file|task)|task .* not found/i.test(output);
+}
+
 module.exports = {
   installTaskScheduler,
   removeTaskScheduler,

package/src/killer.js

@@ -118,6 +118,9 @@ function verifyProcessUnix(proc, runtime = runtimeOptions()) {
     if (scanPrefix !== currentPrefix) {
       return { valid: false, reason: 'cmd-mismatch' };
     }
+    if (!matchesCustomLiteral(proc, cmd)) {
+      return { valid: false, reason: 'pattern-mismatch' };
+    }
 
     // Verify start time if available
     if (proc.startTime) {
@@ -154,6 +157,9 @@ function verifyProcessWindows(proc, runtime = runtimeOptions({ platform: 'win32'
   if (scanPrefix !== currentPrefix) {
     return { valid: false, reason: 'cmd-mismatch' };
   }
+  if (!matchesCustomLiteral(proc, currentCmd)) {
+    return { valid: false, reason: 'pattern-mismatch' };
+  }
 
   if (proc.startTime && current.startTime && current.startTime !== proc.startTime) {
     return { valid: false, reason: 'start-time-mismatch' };
@@ -166,6 +172,11 @@ function verifyProcessWindows(proc, runtime = runtimeOptions({ platform: 'win32'
   return { valid: true, reason: 'verified' };
 }
 
+function matchesCustomLiteral(proc, currentCmd) {
+  if (!proc.matchLiteral) return true;
+  return String(currentCmd).toLowerCase().includes(String(proc.matchLiteral).toLowerCase());
+}
+
 /**
  * Kill a process with graceful shutdown sequence.
  *

package/src/reporter.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { sanitizeTerminalText } = require('./terminal-text');
+
 /**
  * ANSI color codes — no external dependencies.
  */
@@ -78,7 +80,7 @@ function formatDiagnostic(item) {
   const providers = Array.isArray(item.providers) && item.providers.length > 0
     ? ` (providers: ${item.providers.join(', ')})`
     : '';
-  return `${code}${item.message || 'process scan diagnostic'}${providers}`;
+  return sanitizeTerminalText(`${code}${item.message || 'process scan diagnostic'}${providers}`);
 }
 
 function reportScanDiagnostics(result) {
@@ -123,8 +125,8 @@ function reportDryRun(zombies) {
   const totalMem = zombies.reduce((sum, z) => sum + z.mem, 0);
 
   for (const z of zombies) {
-    console.log(`  ${c('red', 'PID')} ${c('bold', String(z.pid).padStart(6))}  ${c('cyan', z.name.padEnd(16))}  ${c('yellow', formatBytes(z.mem).padStart(8))}  ${c('gray', formatDuration(z.age).padStart(6))}`);
-    console.log(`  ${c('gray', '  cmd:')} ${truncate(z.cmd, 72)}`);
+    console.log(`  ${c('red', 'PID')} ${c('bold', String(z.pid).padStart(6))}  ${c('cyan', truncate(z.name, 16).padEnd(16))}  ${c('yellow', formatBytes(z.mem).padStart(8))}  ${c('gray', formatDuration(z.age).padStart(6))}`);
+    console.log(`  ${c('gray', '  cmd:')} ${truncate(sanitizeTerminalText(z.cmd), 72)}`);
     console.log(`  ${c('gray', '  why:')} ${z.reason}`);
     console.log();
   }
@@ -155,7 +157,7 @@ function reportKill(results) {
     const totalMem = killed.reduce((sum, p) => sum + p.mem, 0);
     console.log(c('green', `  Killed ${killed.length} zombie process${killed.length === 1 ? '' : 'es'}:`));
     for (const p of killed) {
-      console.log(`    ${c('green', 'KILLED')} PID ${String(p.pid).padStart(6)}  ${p.name.padEnd(16)}  ${formatBytes(p.mem).padStart(8)}`);
+      console.log(`    ${c('green', 'KILLED')} PID ${String(p.pid).padStart(6)}  ${truncate(p.name, 16).padEnd(16)}  ${formatBytes(p.mem).padStart(8)}`);
     }
     console.log(c('green', `\n  Memory freed: ${formatBytes(totalMem)}`));
 
@@ -170,14 +172,14 @@ function reportKill(results) {
   if (skipped.length > 0) {
     console.log(c('yellow', `\n  Skipped ${skipped.length} (re-verification failed):`));
     for (const p of skipped) {
-      console.log(`    ${c('yellow', 'SKIP')}   PID ${String(p.pid).padStart(6)}  ${p.name.padEnd(16)}  reason: ${p.skipReason}`);
+      console.log(`    ${c('yellow', 'SKIP')}   PID ${String(p.pid).padStart(6)}  ${truncate(p.name, 16).padEnd(16)}  reason: ${sanitizeTerminalText(p.skipReason)}`);
     }
   }
 
   if (failed.length > 0) {
     console.log(c('red', `\n  Failed to kill ${failed.length}:`));
     for (const p of failed) {
-      console.log(`    ${c('red', 'FAIL')}   PID ${String(p.pid).padStart(6)}  ${p.name.padEnd(16)}  error: ${p.error}`);
+      console.log(`    ${c('red', 'FAIL')}   PID ${String(p.pid).padStart(6)}  ${truncate(p.name, 16).padEnd(16)}  error: ${sanitizeTerminalText(p.error)}`);
     }
   }
 
@@ -233,7 +235,7 @@ function reportLogs(logs) {
         console.log(`  ${time}  ${c('green', 'KILL')}  PID ${String(entry.pid).padStart(6)}  ${(entry.name || '').padEnd(16)}  ${formatBytes(entry.memFreed || 0)}`);
         break;
       case 'kill-failed':
-        console.log(`  ${time}  ${c('red', 'FAIL')}  PID ${String(entry.pid).padStart(6)}  ${(entry.name || '').padEnd(16)}  ${entry.error || ''}`);
+        console.log(`  ${time}  ${c('red', 'FAIL')}  PID ${String(entry.pid).padStart(6)}  ${(entry.name || '').padEnd(16)}  ${sanitizeTerminalText(entry.error || '')}`);
         break;
       case 'cleanup-summary':
         console.log(`  ${time}  ${c('cyan', 'DONE')}  killed:${entry.killed} failed:${entry.failed} skipped:${entry.skipped}  freed:${formatBytes(entry.totalMemFreed || 0)}`);
@@ -258,7 +260,7 @@ function reportConfig(config, configPath) {
     const displayValue = Array.isArray(value)
       ? (value.length === 0 ? '[]' : JSON.stringify(value))
       : String(value);
-    console.log(`  ${c('cyan', key.padEnd(20))} ${displayValue}`);
+    console.log(`  ${c('cyan', key.padEnd(20))} ${sanitizeTerminalText(displayValue)}`);
   }
 
   console.log();

package/src/scanner.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { ProcessTree } = require('./process-tree');
-const { matchPattern, AI_DIR_REGEX, buildAiDirRegex } = require('./detector/patterns');
+const { createPatternMatcher, AI_DIR_REGEX, buildAiDirRegex } = require('./detector/patterns');
 const { isWhitelisted } = require('./detector/whitelist');
 const { parseDuration, parseMemory } = require('./config');
 
@@ -18,6 +18,7 @@ const { parseDuration, parseMemory } = require('./config');
 function scan(config, opts = {}) {
   const tree = ProcessTree.build();
   const aiDirRegex = buildAiDirRegex(config.customAiDirs);
+  const matchConfiguredPattern = createPatternMatcher(config);
   const zombies = [];
   const warnings = Array.isArray(tree.warnings) ? [...tree.warnings] : [];
   const errors = Array.isArray(tree.errors) ? [...tree.errors] : [];
@@ -35,7 +36,7 @@ function scan(config, opts = {}) {
   // Iterate all processes in the tree
   for (const [, proc] of tree.byPid) {
     // Match against known AI tool patterns
-    const pattern = matchPattern(proc.cmd, config);
+    const pattern = matchConfiguredPattern(proc.cmd);
     if (!pattern) continue;
 
     // AI path filter: skip generic patterns if command isn't in an AI tool directory
@@ -47,6 +48,8 @@ function scan(config, opts = {}) {
       ? tree.hasAncestorMatching(proc.pid, (p) => p.pid === sessionPid)
       : false;
 
+    if (pattern.strictOrphan && !orphanResult.isOrphan) continue;
+
     // If pattern requires orphan status and process isn't orphaned, skip
     if (pattern.orphanOnly && !orphanResult.isOrphan && !sessionRelated) continue;
 
@@ -90,6 +93,7 @@ function scan(config, opts = {}) {
       startTime: proc.startTime,
       reason: reasons.join(', '),
       pattern: pattern.name,
+      matchLiteral: pattern.literal || null,
     });
   }
 

package/src/terminal-text.js

@@ -0,0 +1,11 @@
+'use strict';
+
+function sanitizeTerminalText(value) {
+  return String(value ?? '')
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '')
+    .replace(/[\r\n]+/g, ' ')
+    .replace(/[\p{Cc}\p{Cf}]/gu, '');
+}
+
+module.exports = { sanitizeTerminalText };