@lumenflow/core 1.0.0

package/dist/stamp-utils.js

@@ -0,0 +1,229 @@
+/**
+ * Stamp File Utilities
+ *
+ * Centralized stamp file operations (create, validate)
+ * Eliminates magic string for stamp body template
+ *
+ * WU-2242: Added format validation for corrupted stamp detection
+ *
+ * Stamp files (.beacon/stamps/WU-{id}.done) serve as completion markers
+ * Used by wu:done, wu:recovery, and validation tools
+ */
+/* eslint-disable security/detect-non-literal-fs-filename */
+import { existsSync, writeFileSync, mkdirSync } from 'node:fs';
+import { readFile, access } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import path from 'node:path';
+import { WU_PATHS } from './wu-paths.js';
+import { todayISO } from './date-utils.js';
+/**
+ * Stamp format error types (WU-2242)
+ * @readonly
+ * @enum {string}
+ */
+export const STAMP_FORMAT_ERRORS = Object.freeze({
+    /** Stamp file is empty or contains only whitespace */
+    EMPTY_FILE: 'EMPTY_FILE',
+    /** Missing WU identifier line (format: WU WU-123 (em dash) Title) */
+    MISSING_WU_LINE: 'MISSING_WU_LINE',
+    /** Missing Completed: YYYY-MM-DD line */
+    MISSING_COMPLETED_LINE: 'MISSING_COMPLETED_LINE',
+    /** Date is not in valid YYYY-MM-DD format or is invalid */
+    INVALID_DATE_FORMAT: 'INVALID_DATE_FORMAT',
+    /** WU ID in stamp does not match expected ID */
+    WU_ID_MISMATCH: 'WU_ID_MISMATCH',
+});
+/**
+ * Valid date regex: YYYY-MM-DD format
+ * @type {RegExp}
+ */
+const DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+/**
+ * Validate that a date string is a valid ISO date
+ * @param {string} dateStr - Date string in YYYY-MM-DD format
+ * @returns {boolean} True if date is valid
+ */
+function isValidDate(dateStr) {
+    const match = dateStr.match(DATE_PATTERN);
+    if (!match) {
+        return false;
+    }
+    const year = parseInt(match[1], 10);
+    const month = parseInt(match[2], 10);
+    const day = parseInt(match[3], 10);
+    // Basic validation
+    if (month < 1 || month > 12) {
+        return false;
+    }
+    // Check day validity for the month
+    const daysInMonth = new Date(year, month, 0).getDate();
+    if (day < 1 || day > daysInMonth) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Stamp file body template (eliminates magic string)
+ * Single source of truth for stamp format
+ */
+const STAMP_TEMPLATE = (id, title, timestamp) => `WU ${id} — ${title}\nCompleted: ${timestamp}\n`;
+/**
+ * Create stamp file (idempotent - safe to call multiple times)
+ *
+ * @param {object} params - Parameters
+ * @param {string} params.id - WU ID (e.g., 'WU-123')
+ * @param {string} params.title - WU title
+ * @returns {object} Result { created: boolean, path: string, reason?: string }
+ */
+export function createStamp({ id, title }) {
+    const stampsDir = WU_PATHS.STAMPS_DIR();
+    const stampPath = WU_PATHS.STAMP(id);
+    // Ensure stamps directory exists
+    if (!existsSync(stampsDir)) {
+        mkdirSync(stampsDir, { recursive: true });
+    }
+    // Idempotent: skip if stamp already exists
+    if (existsSync(stampPath)) {
+        return { created: false, path: stampPath, reason: 'already_exists' };
+    }
+    // Create stamp file
+    const body = STAMP_TEMPLATE(id, title, todayISO());
+    writeFileSync(stampPath, body, { encoding: 'utf-8' });
+    return { created: true, path: stampPath };
+}
+/**
+ * Validate stamp exists
+ *
+ * @param {string} stampPath - Path to stamp file
+ * @returns {boolean} True if stamp exists
+ */
+export function validateStamp(stampPath) {
+    return existsSync(stampPath);
+}
+/**
+ * Get stamp path using WU_PATHS (consistent with codebase)
+ *
+ * @param {string} id - WU ID
+ * @returns {string} Absolute path to stamp file
+ */
+export function getStampPath(id) {
+    return WU_PATHS.STAMP(id);
+}
+/**
+ * Validate WU line in stamp content
+ * Checks for format: "WU WU-123 (em dash) Title"
+ * @param {string[]} lines - Stamp file lines
+ * @param {string} expectedWuId - Expected WU ID
+ * @returns {string|null} Error type or null if valid
+ */
+function validateWuLine(lines, expectedWuId) {
+    const wuLine = lines.find((line) => line.startsWith('WU '));
+    if (!wuLine) {
+        return STAMP_FORMAT_ERRORS.MISSING_WU_LINE;
+    }
+    const wuIdMatch = wuLine.match(/^WU (WU-\d+)/);
+    if (!wuIdMatch) {
+        return STAMP_FORMAT_ERRORS.MISSING_WU_LINE;
+    }
+    if (wuIdMatch[1] !== expectedWuId) {
+        return STAMP_FORMAT_ERRORS.WU_ID_MISMATCH;
+    }
+    return null;
+}
+/**
+ * Validate Completed line in stamp content
+ * @param {string[]} lines - Stamp file lines
+ * @returns {string|null} Error type or null if valid
+ */
+function validateCompletedLine(lines) {
+    const completedLine = lines.find((line) => line.startsWith('Completed:'));
+    if (!completedLine) {
+        return STAMP_FORMAT_ERRORS.MISSING_COMPLETED_LINE;
+    }
+    const dateMatch = completedLine.match(/^Completed:\s*(.+)/);
+    if (!dateMatch) {
+        return STAMP_FORMAT_ERRORS.MISSING_COMPLETED_LINE;
+    }
+    const dateStr = dateMatch[1].trim();
+    if (!isValidDate(dateStr)) {
+        return STAMP_FORMAT_ERRORS.INVALID_DATE_FORMAT;
+    }
+    return null;
+}
+/**
+ * Validate stamp file format (WU-2242)
+ *
+ * Expected format:
+ * ```
+ * WU WU-123 (em dash) Title here
+ * Completed: 2025-12-31
+ * ```
+ *
+ * @param {string} wuId - WU ID (e.g., 'WU-123')
+ * @param {string} [projectRoot=process.cwd()] - Project root directory
+ * @returns {Promise<{valid: boolean, errors: string[], missing?: boolean}>}
+ */
+export async function validateStampFormat(wuId, projectRoot = process.cwd()) {
+    const stampPath = path.join(projectRoot, WU_PATHS.STAMP(wuId));
+    // Check if stamp file exists
+    try {
+        await access(stampPath, constants.R_OK);
+    }
+    catch {
+        return { valid: false, errors: [], missing: true };
+    }
+    // Read stamp content
+    let content;
+    try {
+        content = await readFile(stampPath, { encoding: 'utf-8' });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { valid: false, errors: [`Failed to read stamp: ${message}`] };
+    }
+    // Check for empty file
+    if (content.trim() === '') {
+        return { valid: false, errors: [STAMP_FORMAT_ERRORS.EMPTY_FILE] };
+    }
+    const lines = content.split('\n');
+    const errors = [];
+    // Validate WU line
+    const wuLineError = validateWuLine(lines, wuId);
+    if (wuLineError) {
+        errors.push(wuLineError);
+    }
+    // Validate Completed line
+    const completedError = validateCompletedLine(lines);
+    if (completedError) {
+        errors.push(completedError);
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Parse stamp content to extract metadata
+ *
+ * @param {string} content - Stamp file content
+ * @returns {StampMetadata}
+ */
+export function parseStampContent(content) {
+    const result = {};
+    const lines = content.split('\n');
+    // Parse WU line
+    const wuLine = lines.find((line) => line.startsWith('WU '));
+    if (wuLine) {
+        const match = wuLine.match(/^WU (WU-\d+)\s*[—-]\s*(.+)/);
+        if (match) {
+            result.wuId = match[1];
+            result.title = match[2].trim();
+        }
+    }
+    // Parse Completed line
+    const completedLine = lines.find((line) => line.startsWith('Completed:'));
+    if (completedLine) {
+        const match = completedLine.match(/^Completed:\s*(.+)/);
+        if (match) {
+            result.completedDate = match[1].trim();
+        }
+    }
+    return result;
+}

package/dist/state-machine.d.ts

@@ -0,0 +1,26 @@
+/**
+ * State Machine Validation Library
+ *
+ * Enforces canonical WU state transitions according to LumenFlow §2.4
+ * Prevents illegal state changes (e.g., done → in_progress) and ensures workflow integrity.
+ *
+ * Canonical state machine:
+ * - ready → in_progress (claim)
+ * - in_progress → blocked (block)
+ * - in_progress → waiting (implementation complete, awaiting sign-off)
+ * - in_progress → done (direct completion)
+ * - blocked → in_progress (unblock)
+ * - blocked → done (blocker resolved, direct completion)
+ * - waiting → in_progress (changes requested)
+ * - waiting → done (approved)
+ * - done → (terminal, no transitions)
+ */
+/**
+ * Validates a state transition and throws if illegal
+ *
+ * @param {string|null|undefined} from - Current WU status
+ * @param {string|null|undefined} to - Desired WU status
+ * @param {string} wuid - Work Unit ID (e.g., 'WU-416') for error messages
+ * @throws {Error} If transition is illegal or states are invalid
+ */
+export declare function assertTransition(from: any, to: any, wuid: any): void;

package/dist/state-machine.js

@@ -0,0 +1,83 @@
+/**
+ * State Machine Validation Library
+ *
+ * Enforces canonical WU state transitions according to LumenFlow §2.4
+ * Prevents illegal state changes (e.g., done → in_progress) and ensures workflow integrity.
+ *
+ * Canonical state machine:
+ * - ready → in_progress (claim)
+ * - in_progress → blocked (block)
+ * - in_progress → waiting (implementation complete, awaiting sign-off)
+ * - in_progress → done (direct completion)
+ * - blocked → in_progress (unblock)
+ * - blocked → done (blocker resolved, direct completion)
+ * - waiting → in_progress (changes requested)
+ * - waiting → done (approved)
+ * - done → (terminal, no transitions)
+ */
+import { createError, ErrorCodes } from './error-handler.js';
+/**
+ * Valid WU states as defined in LumenFlow §2.4
+ */
+const VALID_STATES = new Set(['ready', 'in_progress', 'blocked', 'waiting', 'done']);
+/**
+ * Transition table mapping each state to its allowed next states
+ * Based on LumenFlow §2.4 Flow States & Lanes
+ */
+const TRANSITIONS = {
+    ready: ['in_progress'],
+    in_progress: ['blocked', 'waiting', 'done'],
+    blocked: ['in_progress', 'done'],
+    waiting: ['in_progress', 'done'],
+    done: [], // Terminal state - no outgoing transitions
+};
+/**
+ * Validates a state transition and throws if illegal
+ *
+ * @param {string|null|undefined} from - Current WU status
+ * @param {string|null|undefined} to - Desired WU status
+ * @param {string} wuid - Work Unit ID (e.g., 'WU-416') for error messages
+ * @throws {Error} If transition is illegal or states are invalid
+ */
+export function assertTransition(from, to, wuid) {
+    // Validate states exist and are non-empty
+    if (from === null || from === undefined || from === '') {
+        throw createError(ErrorCodes.STATE_ERROR, `Invalid state: ${from}`, {
+            wuid,
+            from,
+            to,
+            reason: 'from state is null/undefined/empty',
+        });
+    }
+    if (to === null || to === undefined || to === '') {
+        throw createError(ErrorCodes.STATE_ERROR, `Invalid state: ${to}`, {
+            wuid,
+            from,
+            to,
+            reason: 'to state is null/undefined/empty',
+        });
+    }
+    // Validate states are recognized
+    if (!VALID_STATES.has(from)) {
+        throw createError(ErrorCodes.STATE_ERROR, `Invalid state: ${from}`, {
+            wuid,
+            from,
+            to,
+            validStates: Array.from(VALID_STATES),
+        });
+    }
+    if (!VALID_STATES.has(to)) {
+        throw createError(ErrorCodes.STATE_ERROR, `Invalid state: ${to}`, {
+            wuid,
+            from,
+            to,
+            validStates: Array.from(VALID_STATES),
+        });
+    }
+    // Check if transition is allowed
+    const allowedNextStates = TRANSITIONS[from];
+    if (!allowedNextStates.includes(to)) {
+        const terminalHint = from === 'done' ? ' (done is a terminal state)' : '';
+        throw createError(ErrorCodes.STATE_ERROR, `Illegal state transition for ${wuid}: ${from} → ${to}${terminalHint}`, { wuid, from, to, allowedNextStates });
+    }
+}

package/dist/system-map-validator.d.ts

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+/**
+ * System Map Validator Library
+ *
+ * Validates SYSTEM-MAP.yaml integrity:
+ * 1. All paths resolve to existing files/folders
+ * 2. No orphan docs not in map
+ * 3. Audience tags from canonical list
+ * 4. quick_queries resolve correctly
+ * 5. No PHI entries tagged for investor/public
+ *
+ * @module system-map-validator
+ */
+/**
+ * Canonical list of valid audience tags as defined in SYSTEM-MAP.yaml header
+ * @type {string[]}
+ */
+export declare const CANONICAL_AUDIENCES: string[];
+/**
+ * Canonical list of valid classification levels
+ * From least to most restrictive: public < internal < confidential < restricted
+ * @type {string[]}
+ */
+export declare const CANONICAL_CLASSIFICATIONS: string[];
+/**
+ * Validate all paths in system map exist
+ *
+ * @param {object} systemMap - Parsed SYSTEM-MAP.yaml
+ * @param {{exists: (path: string) => boolean}} deps - Dependencies
+ * @returns {Promise<string[]>} Array of error messages
+ */
+export declare function validatePaths(systemMap: any, deps: any): Promise<any[]>;
+/**
+ * Find orphan docs not indexed in system map
+ *
+ * @param {object} systemMap - Parsed SYSTEM-MAP.yaml
+ * @param {{glob: (pattern: string) => Promise<string[]>}} deps - Dependencies
+ * @returns {Promise<string[]>} Array of orphan file paths
+ */
+export declare function findOrphanDocs(systemMap: any, deps: any): Promise<any[]>;
+/**
+ * Validate audience tags against canonical list
+ *
+ * @param {object} systemMap - Parsed SYSTEM-MAP.yaml
+ * @returns {string[]} Array of error messages
+ */
+export declare function validateAudienceTags(systemMap: any): any[];
+/**
+ * Validate quick_queries reference valid document IDs
+ *
+ * @param {object} systemMap - Parsed SYSTEM-MAP.yaml
+ * @returns {string[]} Array of error messages
+ */
+export declare function validateQuickQueries(systemMap: any): any[];
+/**
+ * Validate classification prevents PHI routing to investor/public
+ *
+ * Rule: restricted (PHI) data should NOT be accessible to external audiences
+ * - restricted = PHI data, must NOT go to investor/patient/clinician
+ * - confidential = sensitive but OK for investor (investor docs ARE confidential)
+ *
+ * @param {object} systemMap - Parsed SYSTEM-MAP.yaml
+ * @returns {string[]} Array of error messages
+ */
+export declare function validateClassificationRouting(systemMap: any): any[];
+/**
+ * Validate entire system map
+ *
+ * @param {object} systemMap - Parsed SYSTEM-MAP.yaml
+ * @param {{exists: (path: string) => boolean, glob: (pattern: string) => Promise<string[]>}} deps - Dependencies
+ * @returns {Promise<{valid: boolean, pathErrors: string[], orphanDocs: string[], audienceErrors: string[], queryErrors: string[], classificationErrors: string[]}>}
+ */
+export declare function validateSystemMap(systemMap: any, deps: any): Promise<{
+    valid: boolean;
+    pathErrors: any[];
+    orphanDocs: any[];
+    audienceErrors: any[];
+    queryErrors: any[];
+    classificationErrors: any[];
+}>;

package/dist/system-map-validator.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+/**
+ * System Map Validator Library
+ *
+ * Validates SYSTEM-MAP.yaml integrity:
+ * 1. All paths resolve to existing files/folders
+ * 2. No orphan docs not in map
+ * 3. Audience tags from canonical list
+ * 4. quick_queries resolve correctly
+ * 5. No PHI entries tagged for investor/public
+ *
+ * @module system-map-validator
+ */
+/**
+ * Canonical list of valid audience tags as defined in SYSTEM-MAP.yaml header
+ * @type {string[]}
+ */
+export const CANONICAL_AUDIENCES = [
+    'ceo',
+    'cto',
+    'engineer',
+    'compliance',
+    'investor',
+    'agent',
+    'patient',
+    'clinician',
+];
+/**
+ * Canonical list of valid classification levels
+ * From least to most restrictive: public < internal < confidential < restricted
+ * @type {string[]}
+ */
+export const CANONICAL_CLASSIFICATIONS = ['public', 'internal', 'confidential', 'restricted'];
+/**
+ * Audiences that should NOT have access to restricted (PHI) data
+ * These are considered "external" audiences who should never see PHI
+ * Note: investor CAN see confidential (investor materials ARE confidential)
+ * @type {string[]}
+ */
+const PHI_RESTRICTED_AUDIENCES = ['investor', 'patient', 'clinician', 'public'];
+/**
+ * Extract all document entries from system map (flattens all layer arrays)
+ *
+ * @param {object} systemMap - Parsed SYSTEM-MAP.yaml
+ * @returns {Array<{id: string, path?: string, paths?: string[], audiences: string[], classification: string, summary: string}>}
+ */
+function extractAllEntries(systemMap) {
+    const entries = [];
+    const skipKeys = ['quick_queries'];
+    for (const [key, value] of Object.entries(systemMap)) {
+        if (skipKeys.includes(key))
+            continue;
+        if (Array.isArray(value)) {
+            entries.push(...value);
+        }
+    }
+    return entries;
+}
+/**
+ * Get all paths from an entry (handles both path and paths fields)
+ *
+ * @param {{path?: string, paths?: string[]}} entry - Document entry
+ * @returns {string[]}
+ */
+function getEntryPaths(entry) {
+    const result = [];
+    if (entry.path)
+        result.push(entry.path);
+    if (entry.paths && Array.isArray(entry.paths))
+        result.push(...entry.paths);
+    return result;
+}
+/**
+ * Build a set of all indexed paths from the system map
+ *
+ * @param {object} systemMap - Parsed SYSTEM-MAP.yaml
+ * @returns {Set<string>}
+ */
+function buildIndexedPathsSet(systemMap) {
+    const indexedPaths = new Set();
+    const entries = extractAllEntries(systemMap);
+    for (const entry of entries) {
+        const paths = getEntryPaths(entry);
+        for (const p of paths) {
+            indexedPaths.add(p);
+            // For directory paths, also add the prefix for matching
+            if (p.endsWith('/')) {
+                indexedPaths.add(p);
+            }
+        }
+    }
+    return indexedPaths;
+}
+/**
+ * Build a set of all document IDs from the system map
+ *
+ * @param {object} systemMap - Parsed SYSTEM-MAP.yaml
+ * @returns {Set<string>}
+ */
+function buildIdSet(systemMap) {
+    const idSet = new Set();
+    const entries = extractAllEntries(systemMap);
+    for (const entry of entries) {
+        if (entry.id) {
+            idSet.add(entry.id);
+        }
+    }
+    return idSet;
+}
+/**
+ * Validate all paths in system map exist
+ *
+ * @param {object} systemMap - Parsed SYSTEM-MAP.yaml
+ * @param {{exists: (path: string) => boolean}} deps - Dependencies
+ * @returns {Promise<string[]>} Array of error messages
+ */
+export async function validatePaths(systemMap, deps) {
+    const errors = [];
+    const entries = extractAllEntries(systemMap);
+    for (const entry of entries) {
+        const paths = getEntryPaths(entry);
+        for (const p of paths) {
+            if (!deps.exists(p)) {
+                errors.push(`Path not found: ${p} (entry: ${entry.id})`);
+            }
+        }
+    }
+    return errors;
+}
+/**
+ * Find orphan docs not indexed in system map
+ *
+ * @param {object} systemMap - Parsed SYSTEM-MAP.yaml
+ * @param {{glob: (pattern: string) => Promise<string[]>}} deps - Dependencies
+ * @returns {Promise<string[]>} Array of orphan file paths
+ */
+export async function findOrphanDocs(systemMap, deps) {
+    const indexedPaths = buildIndexedPathsSet(systemMap);
+    // Get all docs files
+    const allDocs = await deps.glob('docs/**/*.md');
+    const orphans = [];
+    for (const docPath of allDocs) {
+        // Check if this doc is directly indexed
+        if (indexedPaths.has(docPath))
+            continue;
+        // Check if this doc falls under an indexed directory
+        let isUnderIndexedDir = false;
+        for (const indexedPath of indexedPaths) {
+            const indexedPathStr = String(indexedPath);
+            if (indexedPathStr.endsWith('/') && docPath.startsWith(indexedPathStr)) {
+                isUnderIndexedDir = true;
+                break;
+            }
+        }
+        if (!isUnderIndexedDir) {
+            orphans.push(docPath);
+        }
+    }
+    return orphans;
+}
+/**
+ * Validate audience tags against canonical list
+ *
+ * @param {object} systemMap - Parsed SYSTEM-MAP.yaml
+ * @returns {string[]} Array of error messages
+ */
+export function validateAudienceTags(systemMap) {
+    const errors = [];
+    const entries = extractAllEntries(systemMap);
+    for (const entry of entries) {
+        if (!entry.audiences || !Array.isArray(entry.audiences)) {
+            errors.push(`Entry ${entry.id} missing audiences array`);
+            continue;
+        }
+        if (entry.audiences.length === 0) {
+            errors.push(`Entry ${entry.id} has empty audiences array (must have at least one)`);
+            continue;
+        }
+        for (const audience of entry.audiences) {
+            if (!CANONICAL_AUDIENCES.includes(audience)) {
+                errors.push(`Invalid audience '${audience}' in entry ${entry.id}`);
+            }
+        }
+    }
+    return errors;
+}
+/**
+ * Validate quick_queries reference valid document IDs
+ *
+ * @param {object} systemMap - Parsed SYSTEM-MAP.yaml
+ * @returns {string[]} Array of error messages
+ */
+export function validateQuickQueries(systemMap) {
+    const errors = [];
+    if (!systemMap.quick_queries) {
+        return errors;
+    }
+    const validIds = buildIdSet(systemMap);
+    for (const [queryKey, queryValue] of Object.entries(systemMap.quick_queries)) {
+        const query = queryValue;
+        // Check primary reference
+        if (query.primary && !validIds.has(query.primary)) {
+            errors.push(`Quick query '${queryKey}' references non-existent primary: ${query.primary}`);
+        }
+        // Check related references
+        if (query.related && Array.isArray(query.related)) {
+            for (const related of query.related) {
+                if (!validIds.has(related)) {
+                    errors.push(`Quick query '${queryKey}' references non-existent related: ${related}`);
+                }
+            }
+        }
+    }
+    return errors;
+}
+/**
+ * Validate classification prevents PHI routing to investor/public
+ *
+ * Rule: restricted (PHI) data should NOT be accessible to external audiences
+ * - restricted = PHI data, must NOT go to investor/patient/clinician
+ * - confidential = sensitive but OK for investor (investor docs ARE confidential)
+ *
+ * @param {object} systemMap - Parsed SYSTEM-MAP.yaml
+ * @returns {string[]} Array of error messages
+ */
+export function validateClassificationRouting(systemMap) {
+    const errors = [];
+    const entries = extractAllEntries(systemMap);
+    for (const entry of entries) {
+        const classification = entry.classification;
+        const audiences = entry.audiences || [];
+        // Only check restricted classification (PHI data)
+        // Confidential is OK for investors (investor materials are confidential by design)
+        if (classification !== 'restricted') {
+            continue;
+        }
+        // Check if any PHI-restricted audiences have access
+        for (const audience of audiences) {
+            if (PHI_RESTRICTED_AUDIENCES.includes(audience)) {
+                errors.push(`PHI routing violation: ${entry.id} has restricted (PHI) classification but is accessible to '${audience}'`);
+            }
+        }
+    }
+    return errors;
+}
+/**
+ * Validate entire system map
+ *
+ * @param {object} systemMap - Parsed SYSTEM-MAP.yaml
+ * @param {{exists: (path: string) => boolean, glob: (pattern: string) => Promise<string[]>}} deps - Dependencies
+ * @returns {Promise<{valid: boolean, pathErrors: string[], orphanDocs: string[], audienceErrors: string[], queryErrors: string[], classificationErrors: string[]}>}
+ */
+export async function validateSystemMap(systemMap, deps) {
+    const pathErrors = await validatePaths(systemMap, deps);
+    const orphanDocs = await findOrphanDocs(systemMap, deps);
+    const audienceErrors = validateAudienceTags(systemMap);
+    const queryErrors = validateQuickQueries(systemMap);
+    const classificationErrors = validateClassificationRouting(systemMap);
+    const valid = pathErrors.length === 0 &&
+        orphanDocs.length === 0 &&
+        audienceErrors.length === 0 &&
+        queryErrors.length === 0 &&
+        classificationErrors.length === 0;
+    return {
+        valid,
+        pathErrors,
+        orphanDocs,
+        audienceErrors,
+        queryErrors,
+        classificationErrors,
+    };
+}