triflux 10.0.0 → 10.0.2

package/scripts/claudemd-sync.mjs

@@ -0,0 +1,148 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { TFX_START, TFX_END, OMC_END, writeSection } from "./lib/claudemd-scanner.mjs";
+
+const PROJECT_ROOT = fileURLToPath(new URL("..", import.meta.url));
+const PROJECT_CLAUDE_MD_PATH = join(PROJECT_ROOT, "CLAUDE.md");
+const ROUTING_TAG_OPEN = "<routing>";
+const ROUTING_TAG_CLOSE = "</routing>";
+// Legacy heading fallback
+const ROUTING_SECTION_HEADING = "## triflux CLI 라우팅";
+
+function findRoutingSection(markdown) {
+  const content = String(markdown || "");
+
+  // XML 태그 기반 (우선)
+  const openIdx = content.indexOf(ROUTING_TAG_OPEN);
+  const closeIdx = content.indexOf(ROUTING_TAG_CLOSE);
+  if (openIdx !== -1 && closeIdx !== -1 && closeIdx > openIdx) {
+    const endIndex = closeIdx + ROUTING_TAG_CLOSE.length;
+    return {
+      found: true,
+      startIndex: openIdx,
+      endIndex: content[endIndex] === "\n" ? endIndex + 1 : endIndex,
+      section: content.slice(openIdx, endIndex),
+    };
+  }
+
+  // Legacy heading fallback
+  const headingPattern = new RegExp(`(^|\\n)${ROUTING_SECTION_HEADING.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}(?=\\n|$)`, "u");
+  const match = headingPattern.exec(content);
+
+  if (!match) {
+    return { found: false, startIndex: -1, endIndex: -1, section: "" };
+  }
+
+  const startIndex = match.index + match[1].length;
+  const nextHeadingIndex = content.indexOf("\n## ", startIndex + ROUTING_SECTION_HEADING.length);
+  const endIndex = nextHeadingIndex === -1 ? content.length : nextHeadingIndex + 1;
+
+  return {
+    found: true,
+    startIndex,
+    endIndex,
+    section: content.slice(startIndex, endIndex),
+  };
+}
+
+function normalizeRoutingSection(routingTable) {
+  const section = String(routingTable || "").trim();
+  return section ? `${section}\n` : "";
+}
+
+function buildNextMarkdown(currentMarkdown, routingSection) {
+  const current = String(currentMarkdown || "");
+  const nextSection = normalizeRoutingSection(routingSection);
+  const existing = findRoutingSection(current);
+
+  if (existing.found) {
+    return `${current.slice(0, existing.startIndex)}${nextSection}${current.slice(existing.endIndex)}`;
+  }
+
+  if (!current) {
+    return nextSection;
+  }
+
+  const separator = current.endsWith("\n\n") ? "" : current.endsWith("\n") ? "\n" : "\n\n";
+  return `${current}${separator}${nextSection}`;
+}
+
+function toSkippedResult(path, reason) {
+  return { action: "unchanged", path, skipped: true, reason };
+}
+
+export function getLatestRoutingTable() {
+  if (!existsSync(PROJECT_CLAUDE_MD_PATH)) {
+    throw new Error(`project CLAUDE.md not found: ${PROJECT_CLAUDE_MD_PATH}`);
+  }
+
+  const projectMarkdown = readFileSync(PROJECT_CLAUDE_MD_PATH, "utf8");
+  const section = findRoutingSection(projectMarkdown);
+
+  if (!section.found) {
+    throw new Error(`routing section not found in: ${PROJECT_CLAUDE_MD_PATH}`);
+  }
+
+  return section.section.trim();
+}
+
+export function ensureTfxSection(claudeMdPath, routingTable) {
+  if (!existsSync(claudeMdPath)) {
+    return toSkippedResult(claudeMdPath, "missing_file");
+  }
+
+  const currentMarkdown = readFileSync(claudeMdPath, "utf8");
+  const nextMarkdown = buildNextMarkdown(currentMarkdown, routingTable);
+
+  if (nextMarkdown === currentMarkdown) {
+    return { action: "unchanged", path: claudeMdPath };
+  }
+
+  writeFileSync(claudeMdPath, nextMarkdown, "utf8");
+
+  return {
+    action: findRoutingSection(currentMarkdown).found ? "updated" : "created",
+    path: claudeMdPath,
+  };
+}
+
+export function ensureTfxCrown(claudeMdPath, options = {}) {
+  const absolutePath = resolve(claudeMdPath);
+  if (!existsSync(absolutePath)) {
+    return toSkippedResult(absolutePath, "missing_file");
+  }
+
+  const content = readFileSync(absolutePath, "utf8");
+  const startIdx = content.indexOf(TFX_START);
+  const omcEndIdx = content.indexOf(OMC_END);
+
+  if (startIdx === -1) {
+    const result = writeSection(absolutePath, options);
+    return { action: result.action, path: absolutePath };
+  }
+
+  const expectedPos = omcEndIdx !== -1 ? omcEndIdx + OMC_END.length : 0;
+  const textBefore = content.slice(expectedPos, startIdx).trim();
+
+  if (textBefore.length === 0) {
+    return { action: "unchanged", path: absolutePath };
+  }
+
+  const result = writeSection(absolutePath, options);
+  return { action: "repositioned", path: absolutePath, detail: result.action };
+}
+
+export function ensureGlobalClaudeRoutingSection(claudeDir) {
+  const claudeMdPath = join(claudeDir, "CLAUDE.md");
+  if (!existsSync(claudeMdPath)) {
+    return toSkippedResult(claudeMdPath, "missing_file");
+  }
+
+  try {
+    return ensureTfxSection(claudeMdPath, getLatestRoutingTable());
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : "routing_table_unavailable";
+    return toSkippedResult(claudeMdPath, reason);
+  }
+}

package/scripts/cli-route.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# cli-route.sh — backward-compat 래퍼
+exec bash "$(dirname "$0")/tfx-route.sh" "$@"

package/scripts/completions/tfx.bash

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+# Installation: source /path/to/tfx.bash 또는 ~/.bashrc에 추가
+
+_tfx_completion() {
+    local cur prev words cword
+    COMPREPLY=()
+    cur="${COMP_WORDS[COMP_CWORD]}"
+    prev="${COMP_WORDS[COMP_CWORD-1]}"
+    words=("${COMP_WORDS[@]}")
+    cword=$COMP_CWORD
+
+    local commands="setup doctor multi hub auto codex gemini"
+    local multi_cmds="status stop kill attach list"
+    local hub_cmds="start stop status restart"
+    local flags="--thorough --quick --tmux --psmux --agents --no-attach --timeout"
+
+    if [[ $cword -eq 1 ]]; then
+        COMPREPLY=( $(compgen -W "${commands}" -- "$cur") )
+        return 0
+    fi
+
+    local cmd="${words[1]}"
+    case "${cmd}" in
+        multi)
+            if [[ $cword -eq 2 && ! "$cur" == -* ]]; then
+                COMPREPLY=( $(compgen -W "${multi_cmds}" -- "$cur") )
+            else
+                COMPREPLY=( $(compgen -W "${flags}" -- "$cur") )
+            fi
+            ;;
+        hub)
+            if [[ $cword -eq 2 ]]; then
+                COMPREPLY=( $(compgen -W "${hub_cmds}" -- "$cur") )
+            fi
+            ;;
+        doctor)
+            COMPREPLY=( $(compgen -W "--fix --reset" -- "$cur") )
+            ;;
+        setup|auto|codex|gemini)
+            if [[ "$cur" == -* ]]; then
+                COMPREPLY=( $(compgen -W "${flags}" -- "$cur") )
+            fi
+            ;;
+    esac
+}
+
+complete -F _tfx_completion tfx

package/scripts/completions/tfx.fish

@@ -0,0 +1,44 @@
+# Installation: ~/.config/fish/completions/에 복사
+# e.g., cp /path/to/tfx.fish ~/.config/fish/completions/tfx.fish
+
+set -l commands setup doctor multi hub auto codex gemini
+set -l multi_cmds status stop kill attach list
+set -l hub_cmds start stop status restart
+
+complete -c tfx -f
+
+# Subcommands
+complete -c tfx -n "not __fish_seen_subcommand_from $commands" -a "setup" -d "Setup and sync files"
+complete -c tfx -n "not __fish_seen_subcommand_from $commands" -a "doctor" -d "Diagnose CLI and issues"
+complete -c tfx -n "not __fish_seen_subcommand_from $commands" -a "multi" -d "Multi-CLI team mode"
+complete -c tfx -n "not __fish_seen_subcommand_from $commands" -a "hub" -d "MCP message bus management"
+complete -c tfx -n "not __fish_seen_subcommand_from $commands" -a "auto" -d "Auto mode"
+complete -c tfx -n "not __fish_seen_subcommand_from $commands" -a "codex" -d "Codex mode"
+complete -c tfx -n "not __fish_seen_subcommand_from $commands" -a "gemini" -d "Gemini mode"
+
+# Doctor flags
+complete -c tfx -n "__fish_seen_subcommand_from doctor" -l fix -d "Auto fix issues"
+complete -c tfx -n "__fish_seen_subcommand_from doctor" -l reset -d "Reset all caches"
+
+# Multi subcommands
+complete -c tfx -n "__fish_seen_subcommand_from multi; and not __fish_seen_subcommand_from $multi_cmds" -a "status"
+complete -c tfx -n "__fish_seen_subcommand_from multi; and not __fish_seen_subcommand_from $multi_cmds" -a "stop"
+complete -c tfx -n "__fish_seen_subcommand_from multi; and not __fish_seen_subcommand_from $multi_cmds" -a "kill"
+complete -c tfx -n "__fish_seen_subcommand_from multi; and not __fish_seen_subcommand_from $multi_cmds" -a "attach"
+complete -c tfx -n "__fish_seen_subcommand_from multi; and not __fish_seen_subcommand_from $multi_cmds" -a "list"
+
+# Hub subcommands
+complete -c tfx -n "__fish_seen_subcommand_from hub; and not __fish_seen_subcommand_from $hub_cmds" -a "start"
+complete -c tfx -n "__fish_seen_subcommand_from hub; and not __fish_seen_subcommand_from $hub_cmds" -a "stop"
+complete -c tfx -n "__fish_seen_subcommand_from hub; and not __fish_seen_subcommand_from $hub_cmds" -a "status"
+complete -c tfx -n "__fish_seen_subcommand_from hub; and not __fish_seen_subcommand_from $hub_cmds" -a "restart"
+
+# Global or multi flags
+set -l flags_cond "__fish_seen_subcommand_from setup multi auto codex gemini"
+complete -c tfx -n "$flags_cond" -l thorough -d "Thorough execution"
+complete -c tfx -n "$flags_cond" -l quick -d "Quick execution"
+complete -c tfx -n "$flags_cond" -l tmux -d "Use tmux"
+complete -c tfx -n "$flags_cond" -l psmux -d "Use psmux"
+complete -c tfx -n "$flags_cond" -l agents -d "Specify agents"
+complete -c tfx -n "$flags_cond" -l no-attach -d "Do not attach"
+complete -c tfx -n "$flags_cond" -l timeout -d "Set timeout"

package/scripts/completions/tfx.zsh

@@ -0,0 +1,83 @@
+#compdef tfx
+# Installation: fpath에 추가 후 compinit
+# e.g., fpath=(/path/to/dir $fpath) && compinit
+
+_tfx() {
+    local line state
+    local -a commands multi_cmds hub_cmds flags
+
+    commands=(
+        'setup:Setup and sync files'
+        'doctor:Diagnose CLI and issues'
+        'multi:Multi-CLI team mode'
+        'hub:MCP message bus management'
+        'auto:Auto mode'
+        'codex:Codex mode'
+        'gemini:Gemini mode'
+    )
+
+    multi_cmds=(
+        'status:Show status'
+        'stop:Stop multi'
+        'kill:Kill multi'
+        'attach:Attach to multi'
+        'list:List multi sessions'
+    )
+
+    hub_cmds=(
+        'start:Start hub'
+        'stop:Stop hub'
+        'status:Show hub status'
+        'restart:Restart hub'
+    )
+
+    _arguments -C \
+        '1: :->cmds' \
+        '*: :->args'
+
+    case $state in
+        cmds)
+            _describe -t commands 'tfx commands' commands
+            ;;
+        args)
+            case $words[2] in
+                multi)
+                    if (( CURRENT == 3 )) && [[ $words[CURRENT] != -* ]]; then
+                        _describe -t multi_cmds 'multi commands' multi_cmds
+                    else
+                        _arguments \
+                            '--thorough[Thorough execution]' \
+                            '--quick[Quick execution]' \
+                            '--tmux[Use tmux]' \
+                            '--psmux[Use psmux]' \
+                            '--agents[Specify agents]' \
+                            '--no-attach[Do not attach]' \
+                            '--timeout[Set timeout]'
+                    fi
+                    ;;
+                hub)
+                    if (( CURRENT == 3 )); then
+                        _describe -t hub_cmds 'hub commands' hub_cmds
+                    fi
+                    ;;
+                doctor)
+                    _arguments \
+                        '--fix[Auto fix issues]' \
+                        '--reset[Reset all caches]'
+                    ;;
+                *)
+                    _arguments \
+                        '--thorough[Thorough execution]' \
+                        '--quick[Quick execution]' \
+                        '--tmux[Use tmux]' \
+                        '--psmux[Use psmux]' \
+                        '--agents[Specify agents]' \
+                        '--no-attach[Do not attach]' \
+                        '--timeout[Set timeout]'
+                    ;;
+            esac
+            ;;
+    esac
+}
+
+_tfx "$@"

package/scripts/cross-review-gate.mjs

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { nudge, deny } from "./lib/hook-utils.mjs";
+import {
+  readStdin,
+  parseJson,
+  nowSec,
+  resolveBaseDir,
+  shouldTrackPath,
+  expectedReviewer,
+  SESSION_TTL_SEC,
+  STATE_REL_PATH,
+} from "./lib/cross-review-utils.mjs";
+
+function loadState(statePath) {
+  if (!existsSync(statePath)) return null;
+
+  try {
+    const state = JSON.parse(readFileSync(statePath, "utf8"));
+    const startedAt = Number(state?.session_start || 0);
+    const expired = !startedAt || nowSec() - startedAt > SESSION_TTL_SEC;
+    if (expired) {
+      try {
+        unlinkSync(statePath);
+      } catch {}
+      return null;
+    }
+    return state;
+  } catch {
+    return null;
+  }
+}
+
+function isGitCommitCommand(command) {
+  if (typeof command !== "string") return false;
+  return /\bgit\s+commit\b/i.test(command);
+}
+
+function summarizePending(entries) {
+  return entries
+    .map((item) => {
+      const reviewer = item.expectedReviewer || "cross-reviewer";
+      return `  * ${item.path} (author=${item.author}, reviewer=${reviewer})`;
+    })
+    .join("\n");
+}
+
+async function main() {
+  if (process.env.TFX_SKIP_CROSS_REVIEW === "1") {
+    process.exit(0);
+  }
+
+  const raw = await readStdin();
+  if (!raw.trim()) process.exit(0);
+
+  const payload = parseJson(raw);
+  if (!payload) process.exit(0);
+
+  const toolName = payload.tool_name || "";
+  const toolInput = payload.tool_input || {};
+
+  if (toolName !== "Bash") process.exit(0);
+  if (!isGitCommitCommand(toolInput.command || "")) process.exit(0);
+
+  // cwd 전파: tracker와 동일한 resolveBaseDir 사용
+  const baseDir = resolveBaseDir(payload);
+  const statePath = join(baseDir, STATE_REL_PATH);
+
+  const state = loadState(statePath);
+  if (!state || !state.files || typeof state.files !== "object") process.exit(0);
+
+  const pending = [];
+  const selfApproved = [];
+
+  for (const [path, info] of Object.entries(state.files)) {
+    if (!shouldTrackPath(path)) continue;
+    const meta = info && typeof info === "object" ? info : {};
+    const author = String(meta.author || "").toLowerCase();
+    const reviewer = String(meta.reviewer || "").toLowerCase();
+    const reviewed = meta.reviewed === true;
+    const requiredReviewer = expectedReviewer(author);
+
+    // tracker가 설정한 self_approved 플래그 명시적 체크
+    if (meta.self_approved === true) {
+      selfApproved.push({ path, author, reviewer: meta.reviewer || author, expectedReviewer: requiredReviewer });
+      continue;
+    }
+
+    if (reviewed && reviewer && reviewer === author) {
+      selfApproved.push({ path, author, reviewer, expectedReviewer: requiredReviewer });
+      continue;
+    }
+
+    if (reviewed && requiredReviewer && reviewer && reviewer !== requiredReviewer) {
+      selfApproved.push({ path, author, reviewer, expectedReviewer: requiredReviewer });
+      continue;
+    }
+
+    if (!reviewed) {
+      pending.push({ path, author, expectedReviewer: requiredReviewer });
+    }
+  }
+
+  if (selfApproved.length > 0) {
+    const lines = selfApproved
+      .map((item) => `  * ${item.path} (author=${item.author}, reviewer=${item.reviewer}, required=${item.expectedReviewer || "n/a"})`)
+      .join("\n");
+    deny(
+      `[cross-review] self-approve 차단: 동일/비허용 reviewer가 감지되었습니다.\n${lines}\n` +
+      "규칙: author=claude -> reviewer=codex, author=codex -> reviewer=claude",
+    );
+  }
+
+  if (pending.length > 0) {
+    nudge(
+      `[cross-review] git commit 전에 교차 검증이 필요합니다.\n${summarizePending(pending)}\n` +
+      "규칙: author=claude -> reviewer=codex, author=codex -> reviewer=claude",
+    );
+  }
+
+  process.exit(0);
+}
+
+main().catch(() => process.exit(0));

package/scripts/cross-review-tracker.mjs

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import {
+  readStdin,
+  parseJson,
+  nowSec,
+  resolveBaseDir,
+  shouldTrackPath,
+  expectedReviewer,
+  SESSION_TTL_SEC,
+  STATE_REL_PATH,
+} from "./lib/cross-review-utils.mjs";
+
+function resolveStatePath(baseDir) {
+  return join(baseDir, STATE_REL_PATH);
+}
+
+function createEmptyState() {
+  return {
+    files: {},
+    session_start: nowSec(),
+  };
+}
+
+function loadState(statePath) {
+  if (!existsSync(statePath)) return createEmptyState();
+
+  try {
+    const parsed = JSON.parse(readFileSync(statePath, "utf8"));
+    const sessionStart = Number(parsed?.session_start || 0);
+    const expired = !sessionStart || nowSec() - sessionStart > SESSION_TTL_SEC;
+    if (expired) {
+      try {
+        unlinkSync(statePath);
+      } catch {}
+      return createEmptyState();
+    }
+
+    return {
+      files: parsed?.files && typeof parsed.files === "object" ? parsed.files : {},
+      session_start: sessionStart,
+    };
+  } catch {
+    return createEmptyState();
+  }
+}
+
+function saveState(statePath, state) {
+  mkdirSync(dirname(statePath), { recursive: true });
+  writeFileSync(statePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+
+function normalizePath(filePath, baseDir) {
+  if (typeof filePath !== "string" || !filePath.trim()) return "";
+
+  const raw = filePath.trim();
+  let normalized = raw;
+
+  if (isAbsolute(raw)) {
+    const relPath = relative(baseDir, raw);
+    if (relPath.startsWith("..")) return "";
+    normalized = relPath;
+  }
+
+  return normalized.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+
+function extractFilePath(toolInput) {
+  if (!toolInput || typeof toolInput !== "object") return "";
+  const candidate = toolInput.file_path ?? toolInput.path ?? toolInput.filePath ?? "";
+  return typeof candidate === "string" ? candidate : "";
+}
+
+function extractCandidatePaths(payload, baseDir) {
+  const candidates = new Set();
+
+  const looksLikePath = (value) => {
+    if (typeof value !== "string") return false;
+    const trimmed = value.trim();
+    if (!trimmed || /\s/.test(trimmed)) return false;
+    if (trimmed.length > 260) return false;
+    if (!trimmed.includes(".") && !trimmed.includes("/") && !trimmed.includes("\\")) return false;
+    return /^[./\\A-Za-z0-9_-]/.test(trimmed);
+  };
+
+  const addPath = (value) => {
+    if (!looksLikePath(value)) return;
+    const normalized = normalizePath(value, baseDir);
+    if (shouldTrackPath(normalized)) candidates.add(normalized);
+  };
+
+  const scanValue = (value, depth = 0) => {
+    if (depth > 3 || value == null) return;
+    if (typeof value === "string") {
+      addPath(value);
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) scanValue(item, depth + 1);
+      return;
+    }
+    if (typeof value !== "object") return;
+
+    for (const [key, child] of Object.entries(value)) {
+      const keyLower = key.toLowerCase();
+      if (keyLower.includes("file") || keyLower.includes("path")) {
+        scanValue(child, depth + 1);
+      }
+    }
+  };
+
+  addPath(extractFilePath(payload?.tool_input));
+
+  scanValue(payload?.tool_response);
+  scanValue(payload?.tool_output);
+  scanValue(payload?.result);
+  scanValue(payload?.output);
+
+  return [...candidates];
+}
+
+function collectStrings(value, out = [], depth = 0) {
+  if (depth > 4) return out;
+  if (typeof value === "string") {
+    out.push(value);
+    return out;
+  }
+  if (!value || typeof value !== "object") return out;
+  if (Array.isArray(value)) {
+    for (const item of value) collectStrings(item, out, depth + 1);
+    return out;
+  }
+
+  for (const key of Object.keys(value)) {
+    collectStrings(value[key], out, depth + 1);
+  }
+  return out;
+}
+
+function detectCliActor(payload) {
+  const lines = collectStrings(payload).join("\n");
+  const match = lines.match(/\bcli\s*[:=]\s*(claude|codex|gemini)\b/i);
+  return match ? match[1].toLowerCase() : "";
+}
+
+function detectAuthor(payload) {
+  const actor = detectCliActor(payload);
+  if (actor) return actor;
+  return "claude";
+}
+
+function applyReviewer(state, reviewer, ts) {
+  for (const [filePath, meta] of Object.entries(state.files)) {
+    if (!meta || typeof meta !== "object") continue;
+    if (!shouldTrackPath(filePath)) continue;
+
+    const author = String(meta.author || "").toLowerCase();
+    const expected = expectedReviewer(author);
+
+    if (expected && reviewer === expected) {
+      meta.reviewed = true;
+      meta.reviewer = reviewer;
+      meta.reviewed_ts = ts;
+      delete meta.self_approved;
+      continue;
+    }
+
+    if (reviewer === author) {
+      meta.reviewed = false;
+      meta.reviewer = reviewer;
+      meta.reviewed_ts = ts;
+      meta.self_approved = true;
+    }
+  }
+}
+
+async function main() {
+  if (process.env.TFX_SKIP_CROSS_REVIEW === "1") {
+    process.exit(0);
+  }
+
+  const raw = await readStdin();
+  if (!raw.trim()) {
+    process.exit(0);
+  }
+
+  const payload = parseJson(raw);
+  if (!payload) {
+    process.exit(0);
+  }
+
+  const baseDir = resolveBaseDir(payload);
+  const statePath = resolveStatePath(baseDir);
+  const state = loadState(statePath);
+  const toolName = payload.tool_name || "";
+  const ts = nowSec();
+  let changed = false;
+
+  if (toolName === "Edit" || toolName === "Write") {
+    const toolInput = payload.tool_input || {};
+    const normalizedPath = normalizePath(extractFilePath(toolInput), baseDir);
+    if (shouldTrackPath(normalizedPath)) {
+      state.files[normalizedPath] = {
+        author: detectAuthor(payload),
+        ts,
+        reviewed: false,
+      };
+      changed = true;
+    }
+  } else if (toolName === "Bash") {
+    const actor = detectCliActor(payload);
+    if (actor) {
+      const paths = extractCandidatePaths(payload, baseDir);
+      if (paths.length > 0) {
+        for (const path of paths) {
+          state.files[path] = {
+            author: actor,
+            ts,
+            reviewed: false,
+          };
+        }
+      } else {
+        applyReviewer(state, actor, ts);
+      }
+      changed = true;
+    }
+  }
+
+  if (changed) {
+    saveState(statePath, state);
+  }
+
+  process.exit(0);
+}
+
+main().catch(() => process.exit(0));