@lumenflow/cli 3.18.1 → 3.20.0

package/dist/chunk-OMJD6A3S.js

@@ -1,235 +0,0 @@
-import {
-  LUMENFLOW_MEMORY_PATHS
-} from "./chunk-4N74J3UT.js";
-import {
-  ErrorCodes,
-  createError
-} from "./chunk-RXRKBBSM.js";
-
-// ../memory/dist/mem-signal-core.js
-import { randomBytes } from "crypto";
-import fs from "fs/promises";
-import path from "path";
-var SIGNAL_FILE_NAME = "signals.jsonl";
-var SIGNAL_RECEIPTS_FILE_NAME = "signal-receipts.jsonl";
-var WU_ID_PATTERN = /^WU-\d+$/;
-var SIGNAL_ID_PREFIX = "sig-";
-var SIGNAL_ID_LENGTH = 8;
-var ERROR_MESSAGES = {
-  MESSAGE_REQUIRED: "message is required and cannot be empty",
-  INVALID_WU_ID: "Invalid WU ID format. Expected WU-XXX (e.g., WU-1473)",
-  INVALID_SIGNAL_METADATA: "Signal metadata fields must be non-empty strings when provided",
-  LEGACY_SIGNAL_RECORD: "Legacy signal record is not supported by the strict signal contract. Migrate records before loading signals.",
-  INVALID_SIGNAL_RECORD: "Invalid signal record in signals.jsonl"
-};
-var DEFAULT_SIGNAL_TYPE = "coordination";
-var DEFAULT_SIGNAL_SENDER = "system";
-var DEFAULT_SIGNAL_ORIGIN = "local";
-function normalizeOptionalString(value, fieldName) {
-  if (value === void 0) {
-    return void 0;
-  }
-  const normalized = value.trim();
-  if (normalized.length === 0) {
-    throw createError(ErrorCodes.VALIDATION_ERROR, `${ERROR_MESSAGES.INVALID_SIGNAL_METADATA}: ${fieldName}`);
-  }
-  return normalized;
-}
-function isNonEmptyString(value) {
-  return typeof value === "string" && value.trim().length > 0;
-}
-function parseStrictSignalRecord(line, lineNumber) {
-  let parsed;
-  try {
-    parsed = JSON.parse(line);
-  } catch {
-    throw createError(ErrorCodes.VALIDATION_ERROR, `${ERROR_MESSAGES.INVALID_SIGNAL_RECORD} at line ${lineNumber}`);
-  }
-  if (typeof parsed !== "object" || parsed === null) {
-    throw createError(ErrorCodes.VALIDATION_ERROR, `${ERROR_MESSAGES.INVALID_SIGNAL_RECORD} at line ${lineNumber}`);
-  }
-  const candidate = parsed;
-  if (!isNonEmptyString(candidate.id) || !isNonEmptyString(candidate.message) || !isNonEmptyString(candidate.created_at) || typeof candidate.read !== "boolean") {
-    throw createError(ErrorCodes.VALIDATION_ERROR, `${ERROR_MESSAGES.INVALID_SIGNAL_RECORD} at line ${lineNumber}`);
-  }
-  if (!isNonEmptyString(candidate.type) || !isNonEmptyString(candidate.sender) || !isNonEmptyString(candidate.origin) || !isNonEmptyString(candidate.remote_id)) {
-    throw createError(ErrorCodes.VALIDATION_ERROR, `${ERROR_MESSAGES.LEGACY_SIGNAL_RECORD} (line ${lineNumber})`);
-  }
-  return {
-    ...candidate,
-    id: candidate.id,
-    message: candidate.message,
-    created_at: candidate.created_at,
-    read: candidate.read,
-    type: candidate.type,
-    sender: candidate.sender,
-    origin: candidate.origin,
-    remote_id: candidate.remote_id
-  };
-}
-function generateSignalId() {
-  const bytes = randomBytes(4);
-  const hex = bytes.toString("hex").slice(0, SIGNAL_ID_LENGTH);
-  return `${SIGNAL_ID_PREFIX}${hex}`;
-}
-function getMemoryDir(baseDir) {
-  return path.join(baseDir, LUMENFLOW_MEMORY_PATHS.MEMORY_DIR);
-}
-function getSignalsPath(baseDir) {
-  return path.join(getMemoryDir(baseDir), SIGNAL_FILE_NAME);
-}
-function getReceiptsPath(baseDir) {
-  return path.join(getMemoryDir(baseDir), SIGNAL_RECEIPTS_FILE_NAME);
-}
-async function loadReceiptIds(baseDir) {
-  const receiptsPath = getReceiptsPath(baseDir);
-  let content;
-  try {
-    content = await fs.readFile(receiptsPath, { encoding: "utf-8" });
-  } catch (err) {
-    const error = err;
-    if (error.code === "ENOENT") {
-      return /* @__PURE__ */ new Set();
-    }
-    throw error;
-  }
-  const lines = content.split("\n").filter((line) => line.trim());
-  const ids = /* @__PURE__ */ new Set();
-  for (const line of lines) {
-    const receipt = JSON.parse(line);
-    ids.add(receipt.signal_id);
-  }
-  return ids;
-}
-function isValidWuId(wuId) {
-  return WU_ID_PATTERN.test(wuId);
-}
-async function createSignal(baseDir, options) {
-  const { message, wuId, lane, type, sender, target_agent, origin, remote_id } = options;
-  if (!message || typeof message !== "string" || message.trim().length === 0) {
-    throw createError(ErrorCodes.VALIDATION_ERROR, ERROR_MESSAGES.MESSAGE_REQUIRED);
-  }
-  if (wuId !== void 0 && !isValidWuId(wuId)) {
-    throw createError(ErrorCodes.INVALID_WU_ID, ERROR_MESSAGES.INVALID_WU_ID);
-  }
-  const normalizedType = normalizeOptionalString(type, "type") ?? DEFAULT_SIGNAL_TYPE;
-  const normalizedSender = normalizeOptionalString(sender, "sender") ?? DEFAULT_SIGNAL_SENDER;
-  const normalizedTargetAgent = normalizeOptionalString(target_agent, "target_agent");
-  const normalizedOrigin = normalizeOptionalString(origin, "origin") ?? DEFAULT_SIGNAL_ORIGIN;
-  const normalizedRemoteId = normalizeOptionalString(remote_id, "remote_id");
-  const signal = {
-    id: generateSignalId(),
-    message: message.trim(),
-    created_at: (/* @__PURE__ */ new Date()).toISOString(),
-    read: false,
-    type: normalizedType,
-    sender: normalizedSender,
-    origin: normalizedOrigin,
-    remote_id: ""
-  };
-  signal.remote_id = normalizedRemoteId ?? signal.id;
-  if (wuId) {
-    signal.wu_id = wuId;
-  }
-  if (lane) {
-    signal.lane = lane;
-  }
-  if (normalizedTargetAgent) {
-    signal.target_agent = normalizedTargetAgent;
-  }
-  const memoryDir = getMemoryDir(baseDir);
-  await fs.mkdir(memoryDir, { recursive: true });
-  const signalsPath = getSignalsPath(baseDir);
-  const line = `${JSON.stringify(signal)}
-`;
-  await fs.appendFile(signalsPath, line, "utf-8");
-  return {
-    success: true,
-    signal
-  };
-}
-async function loadSignals(baseDir, options = {}) {
-  const { wuId, lane, unreadOnly, since } = options;
-  const signalsPath = getSignalsPath(baseDir);
-  let content;
-  try {
-    content = await fs.readFile(signalsPath, { encoding: "utf-8" });
-  } catch (err) {
-    const error = err;
-    if (error.code === "ENOENT") {
-      return [];
-    }
-    throw error;
-  }
-  const lines = content.split("\n").filter((line) => line.trim());
-  const signals = lines.map((line, index) => parseStrictSignalRecord(line, index + 1));
-  const receiptIds = await loadReceiptIds(baseDir);
-  for (const signal of signals) {
-    if (!signal.read && receiptIds.has(signal.id)) {
-      signal.read = true;
-    }
-  }
-  let filtered = signals;
-  if (wuId) {
-    filtered = filtered.filter((sig) => sig.wu_id === wuId);
-  }
-  if (lane) {
-    filtered = filtered.filter((sig) => sig.lane === lane);
-  }
-  if (unreadOnly) {
-    filtered = filtered.filter((sig) => sig.read === false);
-  }
-  if (since) {
-    const sinceTime = since instanceof Date ? since : new Date(since);
-    filtered = filtered.filter((sig) => new Date(sig.created_at) > sinceTime);
-  }
-  return filtered;
-}
-async function markSignalsAsRead(baseDir, signalIds) {
-  const signalsPath = getSignalsPath(baseDir);
-  const idSet = new Set(signalIds);
-  let signalContent;
-  try {
-    signalContent = await fs.readFile(signalsPath, { encoding: "utf-8" });
-  } catch (err) {
-    const error = err;
-    if (error.code === "ENOENT") {
-      return { markedCount: 0 };
-    }
-    throw error;
-  }
-  const lines = signalContent.split("\n").filter((line) => line.trim());
-  const inlineReadIds = /* @__PURE__ */ new Set();
-  const existingIds = /* @__PURE__ */ new Set();
-  for (const line of lines) {
-    const signal = JSON.parse(line);
-    existingIds.add(signal.id);
-    if (signal.read) {
-      inlineReadIds.add(signal.id);
-    }
-  }
-  const existingReceiptIds = await loadReceiptIds(baseDir);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const newReceipts = [];
-  for (const id of idSet) {
-    if (existingIds.has(id) && !inlineReadIds.has(id) && !existingReceiptIds.has(id)) {
-      newReceipts.push({ signal_id: id, read_at: now });
-    }
-  }
-  if (newReceipts.length > 0) {
-    const memoryDir = getMemoryDir(baseDir);
-    await fs.mkdir(memoryDir, { recursive: true });
-    const receiptsPath = getReceiptsPath(baseDir);
-    const receiptLines = newReceipts.map((r) => JSON.stringify(r)).join("\n") + "\n";
-    await fs.appendFile(receiptsPath, receiptLines, "utf-8");
-  }
-  return { markedCount: newReceipts.length };
-}
-
-export {
-  SIGNAL_FILE_NAME,
-  SIGNAL_RECEIPTS_FILE_NAME,
-  createSignal,
-  loadSignals,
-  markSignalsAsRead
-};

package/dist/chunk-QB6SJD4T.js

@@ -1,430 +0,0 @@
-import {
-  INLINE_KEYWORD_MAX_OFFSET
-} from "./chunk-2GXVIN57.js";
-import {
-  extractParent
-} from "./chunk-JONWQUB5.js";
-import {
-  getGitForCwd
-} from "./chunk-2UFQ3A3C.js";
-import {
-  BRANCHES,
-  EMOJI,
-  GIT_COMMANDS,
-  LANE_PATH_PATTERNS,
-  LOG_PREFIX,
-  STRING_LITERALS
-} from "./chunk-DWMLTXKQ.js";
-import {
-  ErrorCodes,
-  createError
-} from "./chunk-RXRKBBSM.js";
-
-// ../core/dist/code-path-validator.js
-import path from "path";
-import { existsSync, readFileSync } from "fs";
-import { execSync } from "child_process";
-import micromatch from "micromatch";
-var VALIDATION_MODES = Object.freeze({
-  /** Check file existence - used by wu:done */
-  EXIST: "exist",
-  /** Check lane pattern matching - used by wu:claim */
-  LANE: "lane",
-  /** Check code quality (TODOs, mocks) - used by wu:done */
-  QUALITY: "quality"
-});
-function isTestFile(filePath) {
-  const normalized = filePath.replace(/\\/g, "/");
-  const testPatterns = [
-    /\.test\.(ts|tsx|js|jsx|mjs)$/,
-    /\.spec\.(ts|tsx|js|jsx|mjs)$/,
-    /__tests__\//,
-    /\.test-utils\./,
-    /\.mock\./
-  ];
-  return testPatterns.some((pattern) => pattern.test(normalized));
-}
-function isMarkdownFile(filePath) {
-  const normalized = filePath.replace(/\\/g, "/");
-  return /\.md$/i.test(normalized);
-}
-function getRepoRoot() {
-  try {
-    return execSync("git rev-parse --show-toplevel", {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "ignore"]
-    }).trim();
-  } catch {
-    return process.cwd();
-  }
-}
-function validateExistenceInWorktree(codePaths, worktreePath) {
-  const missing = [];
-  const errors = [];
-  for (const filePath of codePaths) {
-    const fullPath = path.join(worktreePath, filePath);
-    if (!existsSync(fullPath)) {
-      missing.push(filePath);
-    }
-  }
-  if (missing.length > 0) {
-    errors.push(`code_paths validation failed - ${missing.length} file(s) not found in worktree:
-${missing.map((p) => `  - ${p}`).join(STRING_LITERALS.NEWLINE)}
-
-Ensure all files listed in code_paths exist before running wu:done.`);
-  }
-  return { valid: errors.length === 0, errors, missing };
-}
-async function validateExistenceOnBranch(codePaths, targetBranch) {
-  const missing = [];
-  const errors = [];
-  try {
-    const gitAdapter = getGitForCwd();
-    for (const filePath of codePaths) {
-      try {
-        const result = await gitAdapter.raw([GIT_COMMANDS.LS_TREE, targetBranch, "--", filePath]);
-        if (!result || result.trim() === "") {
-          missing.push(filePath);
-        }
-      } catch {
-        missing.push(filePath);
-      }
-    }
-    if (missing.length > 0) {
-      errors.push(`code_paths validation failed - ${missing.length} file(s) not found on ${targetBranch}:
-${missing.map((p) => `  - ${p}`).join(STRING_LITERALS.NEWLINE)}
-
-\u274C POTENTIAL FALSE COMPLETION DETECTED
-
-These files are listed in code_paths but do not exist on ${targetBranch}.
-This prevents creating a stamp for incomplete work.
-
-Fix options:
-  1. Ensure all code is committed and merged to ${targetBranch}
-  2. Update code_paths in WU YAML to match actual files
-  3. Remove files that were intentionally not created
-
-Context: WU-1351 prevents false completions from INIT-WORKFLOW-INTEGRITY`);
-    }
-  } catch (err) {
-    const errMessage = err instanceof Error ? err.message : String(err);
-    console.warn(`${LOG_PREFIX.DONE} ${EMOJI.WARNING} Could not validate code_paths: ${errMessage}`);
-    return { valid: true, errors: [], missing: [] };
-  }
-  return { valid: errors.length === 0, errors, missing };
-}
-function validateLanePatterns(codePaths, lane) {
-  if (!codePaths || codePaths.length === 0) {
-    return {
-      hasWarnings: false,
-      warnings: [],
-      violations: [],
-      skipped: true
-    };
-  }
-  const parentLane = extractParent(lane);
-  const patterns = LANE_PATH_PATTERNS[parentLane];
-  if (!patterns) {
-    return {
-      hasWarnings: false,
-      warnings: [],
-      violations: [],
-      skipped: true
-    };
-  }
-  const { exclude = [], allowExceptions = [] } = patterns;
-  const violations = codePaths.filter((codePath) => {
-    const matchesExclude = micromatch.isMatch(codePath, exclude, { nocase: true });
-    if (!matchesExclude)
-      return false;
-    if (allowExceptions.length > 0) {
-      const matchesException = micromatch.isMatch(codePath, allowExceptions, { nocase: true });
-      if (matchesException)
-        return false;
-    }
-    return true;
-  });
-  if (violations.length === 0) {
-    return {
-      hasWarnings: false,
-      warnings: [],
-      violations: [],
-      skipped: false
-    };
-  }
-  const warnings = violations.map((violatingPath) => {
-    return `Lane "${lane}" typically doesn't include "${violatingPath}" (expected for different lane)`;
-  });
-  return {
-    hasWarnings: true,
-    warnings,
-    violations,
-    skipped: false
-  };
-}
-function scanFileForTODOs(filePath) {
-  if (!existsSync(filePath)) {
-    return { found: false, matches: [] };
-  }
-  if (isTestFile(filePath)) {
-    return { found: false, matches: [] };
-  }
-  if (isMarkdownFile(filePath)) {
-    return { found: false, matches: [] };
-  }
-  try {
-    const content = readFileSync(filePath, { encoding: "utf-8" });
-    const lines = content.split(/\r?\n/);
-    const matches = [];
-    const checkForActionableMarker = (line) => {
-      const trimmed = line.trim();
-      if (trimmed.includes("// TODO:,") || trimmed.includes("/* TODO */")) {
-        return { found: false, pattern: null };
-      }
-      if (trimmed.includes("@todo,") || trimmed.includes("@-prefixed:")) {
-        return { found: false, pattern: null };
-      }
-      const atTagMatch = trimmed.match(/^\*\s+@(todo|fixme|hack|xxx)\b/i);
-      if (atTagMatch) {
-        const atTag = atTagMatch[1];
-        return atTag ? { found: true, pattern: atTag.toUpperCase() } : { found: false, pattern: null };
-      }
-      const commentStartMatch = trimmed.match(/^(?:\/\/|\/\*+|\*|<!--|#)\s*(TODO|FIXME|HACK|XXX)(?::|[\s]|$)/i);
-      if (commentStartMatch) {
-        const commentKeyword = commentStartMatch[1];
-        if (!commentKeyword) {
-          return { found: false, pattern: null };
-        }
-        const afterKeyword = trimmed.slice(trimmed.indexOf(commentKeyword) + commentKeyword.length);
-        if (!afterKeyword.startsWith("/")) {
-          return { found: true, pattern: commentKeyword.toUpperCase() };
-        }
-      }
-      const inlineCommentMatch = line.match(/\/\/\s*(TODO|FIXME|HACK|XXX)(?::|[\s]|$)/i);
-      if (inlineCommentMatch && !line.match(/\/\/\s*(TODO|FIXME|HACK|XXX)\//i)) {
-        const inlineKeyword = inlineCommentMatch[1];
-        if (!inlineKeyword) {
-          return { found: false, pattern: null };
-        }
-        const doubleSlashIndex = line.indexOf("//");
-        const beforeSlash = line.slice(0, doubleSlashIndex);
-        const singleQuotes = (beforeSlash.match(/(?<!\\)'/g) || []).length;
-        const doubleQuotes = (beforeSlash.match(/(?<!\\)"/g) || []).length;
-        const backticks = (beforeSlash.match(/(?<!\\)`/g) || []).length;
-        if (singleQuotes % 2 !== 0 || doubleQuotes % 2 !== 0 || backticks % 2 !== 0) {
-          return { found: false, pattern: null };
-        }
-        const commentPart = line.slice(doubleSlashIndex);
-        const keywordIndex = commentPart.search(/\b(TODO|FIXME|HACK|XXX)\b/i);
-        if (keywordIndex >= 0 && keywordIndex <= INLINE_KEYWORD_MAX_OFFSET) {
-          return { found: true, pattern: inlineKeyword.toUpperCase() };
-        }
-      }
-      if (trimmed.match(/\bWU-XXX\b/i)) {
-        return { found: false, pattern: null };
-      }
-      return { found: false, pattern: null };
-    };
-    lines.forEach((line, index) => {
-      const lineNumber = index + 1;
-      const trimmed = line.trim();
-      const isComment = /^(\/\/|\/\*|\*|<!--|#)/.test(trimmed) || line.includes("//") || line.includes("/*");
-      if (isComment) {
-        const result = checkForActionableMarker(line);
-        if (result.found) {
-          matches.push({
-            line: lineNumber,
-            text: trimmed,
-            pattern: result.pattern
-          });
-        }
-      }
-    });
-    return { found: matches.length > 0, matches };
-  } catch {
-    return { found: false, matches: [] };
-  }
-}
-function scanFileForMocks(filePath) {
-  if (!existsSync(filePath)) {
-    return { found: false, matches: [] };
-  }
-  if (isTestFile(filePath)) {
-    return { found: false, matches: [] };
-  }
-  try {
-    const content = readFileSync(filePath, { encoding: "utf-8" });
-    const lines = content.split(/\r?\n/);
-    const matches = [];
-    const mockPatterns = [
-      { name: "Mock", regex: /\b(class|export\s+class)\s+(\w*Mock\w*)/i },
-      { name: "Stub", regex: /\b(class|export\s+class)\s+(\w*Stub\w*)/i },
-      { name: "Fake", regex: /\b(class|export\s+class)\s+(\w*Fake\w*)/i },
-      { name: "Placeholder", regex: /\b(class|export\s+class)\s+(\w*Placeholder\w*)/i },
-      { name: "Mock", regex: /\b(function|const|let|var)\s+(\w*mock\w*)/i },
-      { name: "Stub", regex: /\b(function|const|let|var)\s+(\w*stub\w*)/i },
-      { name: "Fake", regex: /\b(function|const|let|var)\s+(\w*fake\w*)/i },
-      { name: "Placeholder", regex: /\b(function|const|let|var)\s+(\w*placeholder\w*)/i }
-    ];
-    lines.forEach((line, index) => {
-      const lineNumber = index + 1;
-      mockPatterns.forEach(({ name, regex }) => {
-        const match = regex.exec(line);
-        if (match) {
-          matches.push({
-            line: lineNumber,
-            text: line.trim(),
-            type: name
-          });
-        }
-      });
-    });
-    return { found: matches.length > 0, matches };
-  } catch {
-    return { found: false, matches: [] };
-  }
-}
-function formatTODOFindings(findings) {
-  let msg = "\n\u274C TODO/FIXME/HACK/XXX comments found in production code:\n";
-  findings.forEach(({ path: filePath, matches }) => {
-    msg += `
-  ${filePath}:
-`;
-    matches.forEach(({ line, text }) => {
-      msg += `    Line ${line}: ${text}
-`;
-    });
-  });
-  msg += "\nThese indicate incomplete work and must be resolved before WU completion.";
-  msg += "\nEither complete the work or use --allow-todo with justification in WU notes.";
-  return msg;
-}
-function formatMockFindings(findings) {
-  let msg = "\n\u26A0\uFE0F  Mock/Stub/Fake/Placeholder classes found in production code:\n";
-  findings.forEach(({ path: filePath, matches }) => {
-    msg += `
-  ${filePath}:
-`;
-    matches.forEach(({ line, text }) => {
-      msg += `    Line ${line}: ${text}
-`;
-    });
-  });
-  msg += "\nThese suggest incomplete implementation (interface \u2260 implementation).";
-  msg += "\nVerify these are actual implementations, not placeholder code.";
-  return msg;
-}
-function validateCodeQuality(codePaths, options = {}) {
-  const { allowTodos = false, worktreePath = null } = options;
-  const errors = [];
-  const warnings = [];
-  const repoRoot = worktreePath || getRepoRoot();
-  if (!codePaths || codePaths.length === 0) {
-    return { valid: true, errors, warnings };
-  }
-  const todoFindings = [];
-  const mockFindings = [];
-  for (const codePath of codePaths) {
-    const absolutePath = path.join(repoRoot, codePath);
-    if (!existsSync(absolutePath)) {
-      errors.push(`
-\u274C Code path validation failed: File does not exist: ${codePath}
-
-This indicates the WU claims to have created/modified a file that doesn't exist.
-Either create the file, or remove it from code_paths in the WU YAML.
-`);
-      continue;
-    }
-    const todoResult = scanFileForTODOs(absolutePath);
-    if (todoResult.found) {
-      todoFindings.push({ path: codePath, ...todoResult });
-    }
-    const mockResult = scanFileForMocks(absolutePath);
-    if (mockResult.found) {
-      mockFindings.push({ path: codePath, ...mockResult });
-    }
-  }
-  if (todoFindings.length > 0) {
-    const message = formatTODOFindings(todoFindings);
-    if (allowTodos) {
-      warnings.push(message);
-    } else {
-      errors.push(message);
-    }
-  }
-  if (mockFindings.length > 0) {
-    warnings.push(formatMockFindings(mockFindings));
-  }
-  return { valid: errors.length === 0, errors, warnings };
-}
-async function validate(codePaths, options = {}) {
-  const { mode = VALIDATION_MODES.EXIST } = options;
-  switch (mode) {
-    case VALIDATION_MODES.EXIST: {
-      const { worktreePath, targetBranch = BRANCHES.MAIN } = options;
-      if (!codePaths || codePaths.length === 0) {
-        return { valid: true, errors: [], missing: [] };
-      }
-      if (worktreePath && existsSync(worktreePath)) {
-        return validateExistenceInWorktree(codePaths, worktreePath);
-      }
-      return validateExistenceOnBranch(codePaths, targetBranch);
-    }
-    case VALIDATION_MODES.LANE: {
-      const { lane } = options;
-      if (!lane) {
-        throw createError(ErrorCodes.INVALID_ARGUMENT, "Lane name is required for lane validation mode");
-      }
-      return validateLanePatterns(codePaths, lane);
-    }
-    case VALIDATION_MODES.QUALITY: {
-      const { worktreePath, allowTodos } = options;
-      return validateCodeQuality(codePaths, { worktreePath, allowTodos });
-    }
-    default:
-      throw createError(ErrorCodes.INVALID_ARGUMENT, `Unknown validation mode: ${mode}`);
-  }
-}
-async function validateCodePathsExist(doc, _id, options = {}) {
-  const codePaths = doc.code_paths || [];
-  const { targetBranch = BRANCHES.MAIN, worktreePath = null } = options;
-  if (codePaths.length === 0) {
-    console.log(`${LOG_PREFIX.DONE} ${EMOJI.INFO} No code_paths to validate for ${_id}`);
-    return { valid: true, errors: [], missing: [] };
-  }
-  console.log(`${LOG_PREFIX.DONE} Validating ${codePaths.length} code_paths exist...`);
-  const result = await validate(codePaths, {
-    mode: VALIDATION_MODES.EXIST,
-    worktreePath: worktreePath ?? void 0,
-    targetBranch
-  });
-  if (result.valid) {
-    console.log(`${LOG_PREFIX.DONE} ${EMOJI.SUCCESS} All ${codePaths.length} code_paths verified`);
-  }
-  return result;
-}
-function validateLaneCodePaths(doc, lane) {
-  const codePaths = doc.code_paths || [];
-  return validateLanePatterns(codePaths, lane);
-}
-function validateWUCodePaths(codePaths, options = {}) {
-  const { allowTodos = false, worktreePath = null } = options;
-  return validateCodeQuality(codePaths, { worktreePath, allowTodos });
-}
-function logLaneValidationWarnings(result, logPrefix = "[wu-claim]") {
-  if (!result.hasWarnings) {
-    return;
-  }
-  console.warn(`${logPrefix} Lane/code_paths mismatch detected (advisory only):`);
-  for (const warning of result.warnings) {
-    console.warn(`${logPrefix}   ${warning}`);
-  }
-  console.warn(`${logPrefix} This is a warning only - proceeding with claim.`);
-}
-
-export {
-  validateCodePathsExist,
-  validateLaneCodePaths,
-  validateWUCodePaths,
-  logLaneValidationWarnings
-};