@lumenflow/cli 3.18.0 → 3.18.1

package/dist/chunk-RXRKBBSM.js

@@ -0,0 +1,149 @@
+// ../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

@@ -0,0 +1,363 @@
+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

@@ -0,0 +1,113 @@
+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
+};