@lumenflow/cli 3.12.6 → 3.12.7

package/dist/chunk-RXRKBBSM.js

@@ -1,149 +0,0 @@
-// ../core/dist/error-handler.js
-import path from "path";
-var UNKNOWN_ERROR_MESSAGE = "Unknown error";
-function hasMessage(value) {
-  return typeof value === "object" && value !== null && "message" in value && typeof value.message === "string";
-}
-var ProcessExitError = class _ProcessExitError extends Error {
-  /** Process exit code to use when caught at CLI boundary */
-  exitCode;
-  /**
-   * Create a process exit error
-   * @param {string} message - Error message (already formatted by die() or caller)
-   * @param {number} [exitCode=1] - Process exit code
-   */
-  constructor(message, exitCode = 1) {
-    super(message);
-    this.name = "ProcessExitError";
-    this.exitCode = exitCode;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _ProcessExitError);
-    }
-  }
-};
-var WUError = class _WUError extends Error {
-  /** Error code (e.g., 'WU_NOT_FOUND') */
-  code;
-  /** Additional error context */
-  details;
-  /** Suggested commands or actions to try (optional) */
-  tryNext;
-  /** Alias for details for agent-friendly access */
-  context;
-  /**
-   * Create a WU error
-   * @param {string} code - Error code (e.g., 'WU_NOT_FOUND')
-   * @param {string} message - Human-readable error message
-   * @param {object} [details={}] - Additional error context
-   */
-  constructor(code, message, details = {}) {
-    super(message);
-    this.name = "WUError";
-    this.code = code;
-    this.details = details;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _WUError);
-    }
-  }
-};
-function toError(error, fallbackMessage = UNKNOWN_ERROR_MESSAGE) {
-  if (error instanceof Error) {
-    return error;
-  }
-  if (typeof error === "string" && error.length > 0) {
-    return new Error(error);
-  }
-  if (hasMessage(error)) {
-    return new Error(error.message);
-  }
-  return new Error(fallbackMessage);
-}
-function getErrorMessage(error, fallbackMessage = UNKNOWN_ERROR_MESSAGE) {
-  return toError(error, fallbackMessage).message;
-}
-function die(message, exitCode = 1) {
-  const scriptPath = process.argv[1] || "unknown";
-  const scriptName = path.basename(scriptPath, ".js");
-  const formattedMessage = `[${scriptName}] ${message}`;
-  console.error(formattedMessage);
-  throw new ProcessExitError(formattedMessage, exitCode);
-}
-function createError(code, message, details = {}) {
-  return new WUError(code, message, details);
-}
-var ErrorCodes = {
-  PROCESS_EXIT: "PROCESS_EXIT",
-  // WU-1538: Typed exit signal from library code
-  WU_NOT_FOUND: "WU_NOT_FOUND",
-  WU_ALREADY_CLAIMED: "WU_ALREADY_CLAIMED",
-  WU_NOT_CLAIMED: "WU_NOT_CLAIMED",
-  INVALID_WU_ID: "INVALID_WU_ID",
-  INVALID_LANE: "INVALID_LANE",
-  GATES_FAILED: "GATES_FAILED",
-  GIT_ERROR: "GIT_ERROR",
-  VALIDATION_ERROR: "VALIDATION_ERROR",
-  FILE_NOT_FOUND: "FILE_NOT_FOUND",
-  YAML_PARSE_ERROR: "YAML_PARSE_ERROR",
-  PARSE_ERROR: "PARSE_ERROR",
-  WORKTREE_ERROR: "WORKTREE_ERROR",
-  BRANCH_ERROR: "BRANCH_ERROR",
-  STATE_ERROR: "STATE_ERROR",
-  SECTION_NOT_FOUND: "SECTION_NOT_FOUND",
-  INTERNAL_ERROR: "INTERNAL_ERROR",
-  RECOVERY_ERROR: "RECOVERY_ERROR",
-  TRANSACTION_ERROR: "TRANSACTION_ERROR",
-  // WU-1369: Atomic transaction errors
-  LOCK_ERROR: "LOCK_ERROR",
-  // WU-1747: Merge lock errors
-  // Initiative system error codes (WU-1247)
-  INIT_NOT_FOUND: "INIT_NOT_FOUND",
-  INIT_ALREADY_EXISTS: "INIT_ALREADY_EXISTS",
-  INVALID_INIT_ID: "INVALID_INIT_ID",
-  INVALID_SLUG: "INVALID_SLUG",
-  INVALID_PHASE: "INVALID_PHASE",
-  DEPENDENCY_CYCLE: "DEPENDENCY_CYCLE",
-  // WU-2116: Structured error codes for migrated throw new Error() sites
-  MERGE_EXHAUSTION: "MERGE_EXHAUSTION",
-  REBASE_CONFLICT: "REBASE_CONFLICT",
-  DELEGATION_NOT_FOUND: "DELEGATION_NOT_FOUND",
-  DELEGATION_ALREADY_ESCALATED: "DELEGATION_ALREADY_ESCALATED",
-  SIGNAL_UNAVAILABLE: "SIGNAL_UNAVAILABLE",
-  ID_GENERATION_FAILED: "ID_GENERATION_FAILED",
-  SCOPE_VIOLATION: "SCOPE_VIOLATION",
-  TOOL_ALREADY_REGISTERED: "TOOL_ALREADY_REGISTERED",
-  INVALID_ARGUMENT: "INVALID_ARGUMENT",
-  DEPRECATED_API: "DEPRECATED_API",
-  CONFIG_ERROR: "CONFIG_ERROR",
-  TEMPLATE_VALIDATION_ERROR: "TEMPLATE_VALIDATION_ERROR",
-  INVARIANT_ERROR: "INVARIANT_ERROR",
-  RETRY_EXHAUSTION: "RETRY_EXHAUSTION",
-  PREFLIGHT_ERROR: "PREFLIGHT_ERROR",
-  INVALID_DURATION: "INVALID_DURATION",
-  // WU-2118: Structured error codes for memory/agent/mcp package migrations
-  NODE_NOT_FOUND: "NODE_NOT_FOUND",
-  SESSION_ERROR: "SESSION_ERROR",
-  ALREADY_EXISTS: "ALREADY_EXISTS",
-  // WU-2117: Structured error codes for CLI throw new Error() migration
-  COMMAND_EXECUTION_FAILED: "COMMAND_EXECUTION_FAILED",
-  PACK_ALREADY_EXISTS: "PACK_ALREADY_EXISTS",
-  CANCELLED_BY_USER: "CANCELLED_BY_USER",
-  REGISTRY_UPLOAD_FAILED: "REGISTRY_UPLOAD_FAILED",
-  WORKSPACE_NOT_FOUND: "WORKSPACE_NOT_FOUND",
-  WORKSPACE_MALFORMED: "WORKSPACE_MALFORMED",
-  ORPHAN_WU_ERROR: "ORPHAN_WU_ERROR",
-  REPAIR_FAILED: "REPAIR_FAILED",
-  ONBOARD_FAILED: "ONBOARD_FAILED",
-  DIRECTORY_NOT_EMPTY: "DIRECTORY_NOT_EMPTY",
-  AMBIGUOUS_MATCH: "AMBIGUOUS_MATCH",
-  STRING_NOT_FOUND: "STRING_NOT_FOUND",
-  FILE_SIZE_EXCEEDED: "FILE_SIZE_EXCEEDED",
-  PARENT_DIR_NOT_FOUND: "PARENT_DIR_NOT_FOUND"
-};
-
-export {
-  ProcessExitError,
-  getErrorMessage,
-  die,
-  createError,
-  ErrorCodes
-};

package/dist/chunk-RZOZMML6.js

@@ -1,363 +0,0 @@
-import {
-  VALIDATION_LIMITS
-} from "./chunk-2GXVIN57.js";
-import {
-  createWuPaths
-} from "./chunk-6HO4GWJE.js";
-import {
-  BRANCHES,
-  EXIT_CODES,
-  FILE_EXTENSIONS,
-  LUMENFLOW_PATHS,
-  PATTERNS,
-  STRING_LITERALS
-} from "./chunk-DWMLTXKQ.js";
-import {
-  INCIDENT_SEVERITY,
-  MS_PER_DAY,
-  MS_PER_HOUR,
-  MS_PER_MINUTE
-} from "./chunk-V6OJGLBA.js";
-import {
-  ErrorCodes,
-  createError
-} from "./chunk-RXRKBBSM.js";
-
-// ../agent/dist/agent-session.js
-import { randomUUID } from "crypto";
-import { readFile, writeFile, mkdir, unlink, access } from "fs/promises";
-import { join as join2 } from "path";
-import { simpleGit } from "simple-git";
-
-// ../agent/dist/agent-incidents.js
-import { z } from "zod";
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
-import { join } from "path";
-var SEVERITY_VALUES = ["blocker", "major", "minor", "info"];
-var CATEGORY_VALUES = ["workflow", "tooling", "confusion", "violation", "error"];
-var IncidentLogSchema = z.object({
-  timestamp: z.string().datetime(),
-  // ISO 8601 with timezone
-  session_id: z.string().uuid(),
-  wu_id: z.string().regex(/^WU-\d+$/, "Must match WU-XXX format"),
-  lane: z.string().min(1),
-  category: z.enum(CATEGORY_VALUES),
-  severity: z.enum(SEVERITY_VALUES),
-  title: z.string().min(VALIDATION_LIMITS.TITLE_MIN).max(VALIDATION_LIMITS.TITLE_MAX),
-  description: z.string().min(VALIDATION_LIMITS.DESCRIPTION_MIN).max(VALIDATION_LIMITS.DESCRIPTION_MAX),
-  resolution: z.string().optional(),
-  tags: z.array(z.string()).default([]),
-  context: z.object({
-    git_branch: z.string().optional(),
-    current_step: z.string().optional(),
-    related_files: z.array(z.string()).optional()
-  }).optional().default(() => ({}))
-});
-function appendIncident(incident, incidentsDir = LUMENFLOW_PATHS.INCIDENTS) {
-  const validated = IncidentLogSchema.parse(incident);
-  if (!existsSync(incidentsDir)) {
-    mkdirSync(incidentsDir, { recursive: true });
-  }
-  const logFile = join(incidentsDir, `${validated.category}${FILE_EXTENSIONS.NDJSON}`);
-  appendFileSync(logFile, `${JSON.stringify(validated)}
-`, { encoding: "utf-8" });
-}
-
-// ../agent/dist/agent-session.js
-var SESSION_DIR = LUMENFLOW_PATHS.SESSIONS;
-var SESSION_FILE = join2(SESSION_DIR, "current.json");
-var DEFAULT_AGENT_VERSION = "unknown";
-var DEFAULT_HOST_ID = "unknown";
-var DEFAULT_AGENT_CAPABILITIES = ["session_lifecycle", "incident_logging"];
-var AGENT_CAPABILITIES_ENV = "LUMENFLOW_AGENT_CAPABILITIES";
-var AGENT_VERSION_ENV = "LUMENFLOW_AGENT_VERSION";
-function asNonEmptyString(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
-}
-function parseCapabilities(rawValue) {
-  if (!rawValue) {
-    return [...DEFAULT_AGENT_CAPABILITIES];
-  }
-  const parsed = rawValue.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
-  return parsed.length > 0 ? parsed : [...DEFAULT_AGENT_CAPABILITIES];
-}
-function normalizeSessionData(session) {
-  return {
-    ...session,
-    client_type: session.client_type ?? session.agent_type,
-    capabilities: Array.isArray(session.capabilities) ? session.capabilities.filter((entry) => typeof entry === "string") : [...DEFAULT_AGENT_CAPABILITIES],
-    agent_version: session.agent_version ?? DEFAULT_AGENT_VERSION,
-    host_id: session.host_id ?? DEFAULT_HOST_ID
-  };
-}
-async function startSession(wuId, tier, agentType = "claude-code") {
-  const sessionExists = await access(SESSION_FILE).then(() => true).catch(() => false);
-  if (sessionExists) {
-    const content = await readFile(SESSION_FILE, { encoding: "utf-8" });
-    const existing = JSON.parse(content);
-    throw createError(ErrorCodes.SESSION_ERROR, `Session ${existing.session_id} already active for ${existing.wu_id}. Run 'pnpm agent:session:end' first.`);
-  }
-  if (!PATTERNS.WU_ID.test(wuId)) {
-    throw createError(ErrorCodes.INVALID_WU_ID, `Invalid WU ID format: ${wuId}. Must match WU-XXX.`);
-  }
-  if (![1, 2, 3].includes(tier)) {
-    throw createError(ErrorCodes.VALIDATION_ERROR, `Invalid context tier: ${tier}. Must be 1, 2, or 3.`);
-  }
-  const git = simpleGit();
-  let lane = "Unknown";
-  try {
-    const branch = await git.revparse(["--abbrev-ref", "HEAD"]);
-    const match = branch.match(/^lane\/([^/]+)\//);
-    if (match && match[1]) {
-      lane = match[1].split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(": ");
-    }
-  } catch {
-  }
-  const sessionId = randomUUID();
-  const capabilities = parseCapabilities(asNonEmptyString(process.env[AGENT_CAPABILITIES_ENV]));
-  const agentVersion = asNonEmptyString(process.env[AGENT_VERSION_ENV]) ?? DEFAULT_AGENT_VERSION;
-  const hostId = asNonEmptyString(process.env.HOSTNAME) ?? asNonEmptyString(process.env.COMPUTERNAME) ?? DEFAULT_HOST_ID;
-  const session = {
-    session_id: sessionId,
-    wu_id: wuId,
-    lane,
-    started: (/* @__PURE__ */ new Date()).toISOString(),
-    agent_type: agentType,
-    client_type: agentType,
-    capabilities,
-    agent_version: agentVersion,
-    host_id: hostId,
-    context_tier: tier,
-    incidents_logged: 0,
-    incidents_major: 0
-  };
-  const dirExists = await access(SESSION_DIR).then(() => true).catch(() => false);
-  if (!dirExists) {
-    await mkdir(SESSION_DIR, { recursive: true });
-  }
-  await writeFile(SESSION_FILE, JSON.stringify(session, null, 2));
-  return sessionId;
-}
-async function getCurrentSession() {
-  const sessionExists = await access(SESSION_FILE).then(() => true).catch(() => false);
-  if (!sessionExists)
-    return null;
-  const content = await readFile(SESSION_FILE, { encoding: "utf-8" });
-  return normalizeSessionData(JSON.parse(content));
-}
-async function logIncident(incidentData) {
-  const session = await getCurrentSession();
-  if (!session) {
-    throw createError(ErrorCodes.SESSION_ERROR, "No active session. Run: pnpm agent:session start --wu WU-XXX --tier N");
-  }
-  const git = simpleGit();
-  let gitBranch = "unknown";
-  try {
-    gitBranch = await git.revparse(["--abbrev-ref", "HEAD"]);
-  } catch {
-  }
-  const incident = {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    session_id: session.session_id,
-    wu_id: session.wu_id,
-    lane: session.lane,
-    ...incidentData,
-    context: {
-      git_branch: gitBranch,
-      ...incidentData.context ?? {}
-    }
-  };
-  appendIncident(incident);
-  session.incidents_logged++;
-  if (incident.severity === INCIDENT_SEVERITY.MAJOR || incident.severity === INCIDENT_SEVERITY.BLOCKER) {
-    session.incidents_major++;
-  }
-  await writeFile(SESSION_FILE, JSON.stringify(session, null, 2));
-}
-async function endSession() {
-  const session = await getCurrentSession();
-  if (!session) {
-    throw createError(ErrorCodes.SESSION_ERROR, "No active session to end.");
-  }
-  session.completed = (/* @__PURE__ */ new Date()).toISOString();
-  await unlink(SESSION_FILE);
-  return {
-    wu_id: session.wu_id,
-    lane: session.lane,
-    session_id: session.session_id,
-    started: session.started,
-    completed: session.completed,
-    agent_type: session.agent_type,
-    client_type: session.client_type,
-    capabilities: [...session.capabilities],
-    agent_version: session.agent_version,
-    host_id: session.host_id,
-    context_tier: session.context_tier,
-    incidents_logged: session.incidents_logged,
-    incidents_major: session.incidents_major
-    // artifacts can be added manually later
-  };
-}
-
-// ../agent/dist/agent-verification.js
-import { execSync } from "child_process";
-import { existsSync as existsSync2 } from "fs";
-import { fileURLToPath } from "url";
-function run(cmd) {
-  try {
-    return execSync(cmd, { stdio: "pipe", encoding: "utf-8" }).trim();
-  } catch {
-    return "";
-  }
-}
-function formatWUId(wuId) {
-  if (!wuId || typeof wuId !== "string") {
-    throw createError(ErrorCodes.VALIDATION_ERROR, "verifyWUComplete requires a WU id (e.g., WU-123)", { wuId, type: typeof wuId });
-  }
-  const normalized = wuId.trim().toUpperCase();
-  if (!PATTERNS.WU_ID.test(normalized)) {
-    throw createError(ErrorCodes.INVALID_WU_ID, `Invalid WU id "${wuId}". Expected format: WU-123`, { wuId, normalized });
-  }
-  return normalized;
-}
-function checkGitStatus(runFn = run) {
-  const status = runFn("git status --porcelain");
-  if (!status)
-    return null;
-  const lines = status.split(STRING_LITERALS.NEWLINE).filter(Boolean).slice(0, 10);
-  return `Working tree dirty (stage or discard changes): ${lines.join("; ")}`;
-}
-function stampPath(wuId, paths) {
-  return paths.STAMP(wuId);
-}
-function checkStamp(wuId, paths, existsFn = existsSync2) {
-  if (existsFn(stampPath(wuId, paths)))
-    return null;
-  return `Missing stamp ${paths.STAMPS_DIR()}/${wuId}.done`;
-}
-function checkCommit(wuId, paths, runFn = run) {
-  const history = runFn(`git log --oneline ${BRANCHES.MAIN} -- ${paths.WU(wuId)} | head -n 1`);
-  if (history)
-    return null;
-  return `No commit on ${BRANCHES.MAIN} touching ${paths.WU(wuId)}`;
-}
-function verifyWUComplete(wuId, overrides = {}) {
-  const normalized = formatWUId(wuId);
-  const failures = [];
-  const runFn = typeof overrides.run === "function" ? overrides.run : run;
-  const existsFn = typeof overrides.exists === "function" ? overrides.exists : (filePath) => existsSync2(filePath);
-  const paths = createWuPaths({ projectRoot: overrides.projectRoot });
-  const gitStatusFailure = checkGitStatus(runFn);
-  if (gitStatusFailure)
-    failures.push(gitStatusFailure);
-  const stampFailure = checkStamp(normalized, paths, existsFn);
-  if (stampFailure)
-    failures.push(stampFailure);
-  const commitFailure = checkCommit(normalized, paths, runFn);
-  if (commitFailure)
-    failures.push(commitFailure);
-  return {
-    complete: failures.length === 0,
-    failures
-  };
-}
-function debugSummary(result) {
-  if (!result || typeof result !== "object") {
-    return "No verification result";
-  }
-  if (result.complete) {
-    return "Verification passed: WU complete.";
-  }
-  const failures = Array.isArray(result.failures) ? result.failures : [];
-  if (!failures.length) {
-    return "Verification failed: unknown reason.";
-  }
-  return `Verification failed:${STRING_LITERALS.NEWLINE}- ${failures.join(`${STRING_LITERALS.NEWLINE}- `)}`;
-}
-var isDirectExecution = (() => {
-  if (typeof process === "undefined")
-    return false;
-  if (!Array.isArray(process.argv))
-    return false;
-  if (!process.argv[1])
-    return false;
-  try {
-    return fileURLToPath(import.meta.url) === process.argv[1];
-  } catch {
-    return false;
-  }
-})();
-if (isDirectExecution) {
-  const wuId = process.argv[2] ?? "";
-  try {
-    const result = verifyWUComplete(wuId);
-    const message = debugSummary(result);
-    console.log(message);
-    process.exit(result.complete ? EXIT_CODES.SUCCESS : EXIT_CODES.ERROR);
-  } catch (error) {
-    console.error(`Verification error: ${error instanceof Error ? error.message : String(error)}`);
-    process.exit(EXIT_CODES.ERROR);
-  }
-}
-
-// ../agent/dist/feedback-promote-core.js
-import fs from "fs/promises";
-import path from "path";
-var DRAFT_DIRECTORY = LUMENFLOW_PATHS.FEEDBACK_DRAFTS;
-var FEEDBACK_INDEX_PATH = LUMENFLOW_PATHS.FEEDBACK_INDEX;
-var LANES = {
-  OPERATIONS_TOOLING: "Operations: Tooling",
-  OPERATIONS_DOCUMENTATION: "Operations: Documentation",
-  OPERATIONS_SECURITY: "Operations: Security",
-  OPERATIONS_COMPLIANCE: "Operations: Compliance",
-  OPERATIONS: "Operations",
-  CORE_SYSTEMS: "Core Systems",
-  EXPERIENCE: "Experience",
-  INTELLIGENCE: "Intelligence"
-};
-var CATEGORY_TO_LANE = {
-  test: LANES.OPERATIONS_TOOLING,
-  tooling: LANES.OPERATIONS_TOOLING,
-  docs: LANES.OPERATIONS_DOCUMENTATION,
-  documentation: LANES.OPERATIONS_DOCUMENTATION,
-  infrastructure: LANES.CORE_SYSTEMS,
-  database: LANES.CORE_SYSTEMS,
-  api: LANES.CORE_SYSTEMS,
-  ui: LANES.EXPERIENCE,
-  frontend: LANES.EXPERIENCE,
-  ux: LANES.EXPERIENCE,
-  llm: LANES.INTELLIGENCE,
-  prompt: LANES.INTELLIGENCE,
-  ai: LANES.INTELLIGENCE,
-  security: LANES.OPERATIONS_SECURITY,
-  compliance: LANES.OPERATIONS_COMPLIANCE,
-  uncategorized: LANES.OPERATIONS
-};
-
-// ../agent/dist/feedback-review-core.js
-import fs2 from "fs/promises";
-import path2 from "path";
-var SEVERITY_WEIGHTS = {
-  [INCIDENT_SEVERITY.BLOCKER]: 4,
-  [INCIDENT_SEVERITY.MAJOR]: 3,
-  [INCIDENT_SEVERITY.MINOR]: 2,
-  [INCIDENT_SEVERITY.INFO]: 1
-};
-var RECENCY_DECAY_MS = 30 * MS_PER_DAY;
-var DURATION_MULTIPLIERS = {
-  m: MS_PER_MINUTE,
-  // minutes
-  h: MS_PER_HOUR,
-  // hours
-  d: MS_PER_DAY,
-  // days
-  w: 7 * MS_PER_DAY
-  // weeks
-};
-
-export {
-  startSession,
-  getCurrentSession,
-  logIncident,
-  endSession
-};

package/dist/chunk-U7I7FS7T.js

@@ -1,113 +0,0 @@
-import {
-  TEST_TYPES,
-  WU_TYPES
-} from "./chunk-V6OJGLBA.js";
-
-// ../core/dist/manual-test-validator.js
-import path from "path";
-var CODE_EXTENSIONS = Object.freeze([".js", ".ts", ".tsx", ".ts"]);
-var NON_CODE_EXTENSIONS = Object.freeze([".md", ".yaml", ".yml", ".json"]);
-var CONFIG_PATTERNS = Object.freeze([
-  /config\./i,
-  // vitest.config.ts, eslint.config.js
-  /\.config\./i,
-  // *.config.ts, *.config.js
-  /rc\.[jt]s$/i,
-  // .eslintrc.js, .prettierrc.ts
-  /^\.[a-z]+rc\./i
-  // .eslintrc.*, .prettierrc.*
-]);
-var HEX_CORE_CODE_PATTERNS = Object.freeze([
-  "packages/@lumenflow/core/",
-  "packages/@lumenflow/cli/",
-  "packages/@lumenflow/agent/"
-]);
-var EXEMPT_LANES = Object.freeze([]);
-var EXEMPT_TYPES = Object.freeze([WU_TYPES.DOCUMENTATION]);
-var TDD_EXCEPTION_MARKER = "tdd-exception:";
-function isCodeFile(filePath) {
-  if (!filePath || typeof filePath !== "string") {
-    return false;
-  }
-  const fileName = path.basename(filePath);
-  const ext = path.extname(filePath).toLowerCase();
-  if (NON_CODE_EXTENSIONS.includes(ext)) {
-    return false;
-  }
-  if (!CODE_EXTENSIONS.includes(ext)) {
-    return false;
-  }
-  const isConfig = CONFIG_PATTERNS.some((pattern) => pattern.test(fileName));
-  if (isConfig) {
-    return false;
-  }
-  return true;
-}
-function hasDocumentedTddException(notes) {
-  if (typeof notes === "string") {
-    return notes.toLowerCase().includes(TDD_EXCEPTION_MARKER);
-  }
-  if (Array.isArray(notes)) {
-    return notes.some((entry) => typeof entry === "string" && hasDocumentedTddException(entry));
-  }
-  return false;
-}
-function isExemptFromAutomatedTests(doc) {
-  if (!doc)
-    return false;
-  const type = doc.type || "";
-  if (typeof type === "string" && EXEMPT_TYPES.includes(type)) {
-    return true;
-  }
-  if (hasDocumentedTddException(doc.notes)) {
-    return true;
-  }
-  return false;
-}
-function hasAutomatedTest(tests) {
-  if (!tests || typeof tests !== "object")
-    return false;
-  const hasItems = (arr) => Array.isArray(arr) && arr.length > 0;
-  const t = tests;
-  return hasItems(t[TEST_TYPES.UNIT]) || hasItems(t[TEST_TYPES.E2E]) || hasItems(t[TEST_TYPES.INTEGRATION]);
-}
-function analyzeCodePaths(codePaths) {
-  if (!codePaths || !Array.isArray(codePaths) || codePaths.length === 0) {
-    return { hasCodeFiles: false, codeFiles: [] };
-  }
-  const codeFiles = codePaths.filter((p) => isCodeFile(p));
-  return {
-    hasCodeFiles: codeFiles.length > 0,
-    codeFiles
-  };
-}
-function validateAutomatedTestRequirement(doc) {
-  const errors = [];
-  if (!doc) {
-    return { valid: true, errors: [] };
-  }
-  if (isExemptFromAutomatedTests(doc)) {
-    return { valid: true, errors: [] };
-  }
-  const codePaths = doc.code_paths || [];
-  const { hasCodeFiles, codeFiles } = analyzeCodePaths(codePaths);
-  if (!hasCodeFiles) {
-    return { valid: true, errors: [] };
-  }
-  const tests = doc.tests || doc.test_paths || {};
-  if (!hasAutomatedTest(tests)) {
-    errors.push(`WU modifies code files but has no automated tests.
-  Code files: ${codeFiles.join(", ")}
-  Required: At least one automated test (unit, e2e, or integration)
-  Manual-only tests are not allowed for code changes.
-
-  Fix: Add tests to tests.unit, tests.e2e, or tests.integration in WU YAML.`);
-    return { valid: false, errors };
-  }
-  return { valid: true, errors: [] };
-}
-
-export {
-  isCodeFile,
-  validateAutomatedTestRequirement
-};