@lumenflow/core 3.2.0 → 3.2.1

package/dist/validators/supabase-docs-linter.js

@@ -0,0 +1,45 @@
+// Copyright (c) 2026 Hellmai Ltd
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * @file supabase-docs-linter.ts
+ * @description Runs Supabase docs linter when available (optional in consumer repos)
+ */
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+export async function runSupabaseDocsLinter(options = {}) {
+    const { cwd = process.cwd(), logger = console } = options;
+    const linterPath = path.join(cwd, 'packages', 'linters', 'supabase-docs-linter.js');
+    if (!existsSync(linterPath)) {
+        return {
+            ok: true,
+            skipped: true,
+            message: 'Supabase docs linter not found; skipping.',
+        };
+    }
+    const moduleUrl = pathToFileURL(linterPath).href;
+    const module = await import(moduleUrl);
+    const runFn = module.runSupabaseDocsLinter ?? module.default;
+    if (typeof runFn !== 'function') {
+        return {
+            ok: false,
+            skipped: false,
+            errors: ['Supabase docs linter does not export runSupabaseDocsLinter.'],
+        };
+    }
+    const result = await runFn({ cwd, logger });
+    if (result && typeof result === 'object' && 'ok' in result) {
+        return {
+            ok: Boolean(result.ok),
+            skipped: Boolean(result.skipped),
+            message: result.message,
+            errors: result.errors,
+        };
+    }
+    return {
+        ok: true,
+        skipped: false,
+        message: 'Supabase docs linter completed.',
+    };
+}
+//# sourceMappingURL=supabase-docs-linter.js.map

package/dist/validators/supabase-docs-linter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"supabase-docs-linter.js","sourceRoot":"","sources":["../../src/validators/supabase-docs-linter.ts"],"names":[],"mappings":"AAAA,iCAAiC;AACjC,yCAAyC;AAEzC;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAczC,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,UAAqC,EAAE;IAEvC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,GAAG,OAAO,EAAE,GAAG,OAAO,CAAC;IAC1D,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,SAAS,EAAE,yBAAyB,CAAC,CAAC;IAEpF,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;QAC5B,OAAO;YACL,EAAE,EAAE,IAAI;YACR,OAAO,EAAE,IAAI;YACb,OAAO,EAAE,2CAA2C;SACrD,CAAC;IACJ,CAAC;IAED,MAAM,SAAS,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC;IACjD,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,CAAC;IACvC,MAAM,KAAK,GAAG,MAAM,CAAC,qBAAqB,IAAI,MAAM,CAAC,OAAO,CAAC;IAE7D,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE,CAAC;QAChC,OAAO;YACL,EAAE,EAAE,KAAK;YACT,OAAO,EAAE,KAAK;YACd,MAAM,EAAE,CAAC,6DAA6D,CAAC;SACxE,CAAC;IACJ,CAAC;IAED,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC;IAC5C,IAAI,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,IAAI,IAAI,MAAM,EAAE,CAAC;QAC3D,OAAO;YACL,EAAE,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YACtB,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC;YAChC,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,MAAM,EAAE,MAAM,CAAC,MAAM;SACtB,CAAC;IACJ,CAAC;IAED,OAAO;QACL,EAAE,EAAE,IAAI;QACR,OAAO,EAAE,KAAK;QACd,OAAO,EAAE,iCAAiC;KAC3C,CAAC;AACJ,CAAC"}

package/dist/validators/wu-tasks.d.ts

@@ -0,0 +1,21 @@
+export interface ValidationResult {
+    valid: boolean;
+    warnings: string[];
+    errors: string[];
+}
+export interface ValidationSummary {
+    totalValid: number;
+    totalInvalid: number;
+    totalWarnings: number;
+    results: Array<{
+        wuId: string;
+    } & ValidationResult>;
+}
+export declare function validateSingleWU(wuPath: string, options?: {
+    strict?: boolean;
+}): ValidationResult;
+export declare function validateAllWUs(options?: {
+    strict?: boolean;
+    doneOnly?: boolean;
+}): ValidationSummary;
+//# sourceMappingURL=wu-tasks.d.ts.map

package/dist/validators/wu-tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wu-tasks.d.ts","sourceRoot":"","sources":["../../src/validators/wu-tasks.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,gBAAgB,CAAC,CAAC;CACrD;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GACjC,gBAAgB,CAqClB;AAED,wBAAgB,cAAc,CAC5B,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAO,GACrD,iBAAiB,CAsDnB"}

package/dist/validators/wu-tasks.js

@@ -0,0 +1,93 @@
+// Copyright (c) 2026 Hellmai Ltd
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * @file wu-tasks.ts
+ * @description WU YAML validation helpers (shared by CLI and preflight)
+ */
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { WU_PATHS } from '../wu-paths.js';
+import { parseYAML } from '../wu-yaml.js';
+import { validateWU, validateWUCompleteness } from '../wu-schema.js';
+import { FILE_SYSTEM, WU_STATUS } from '../wu-constants.js';
+export function validateSingleWU(wuPath, options = {}) {
+    const { strict = false } = options;
+    const errors = [];
+    const warnings = [];
+    if (!existsSync(wuPath)) {
+        errors.push(`WU file not found: ${wuPath}`);
+        return { valid: false, warnings, errors };
+    }
+    let doc;
+    try {
+        const text = readFileSync(wuPath, { encoding: FILE_SYSTEM.UTF8 });
+        doc = parseYAML(text);
+    }
+    catch (e) {
+        errors.push(`Failed to parse YAML: ${e.message}`);
+        return { valid: false, warnings, errors };
+    }
+    const schemaResult = validateWU(doc);
+    if (!schemaResult.success) {
+        const schemaErrors = schemaResult.error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`);
+        errors.push(...schemaErrors);
+        return { valid: false, warnings, errors };
+    }
+    const completenessResult = validateWUCompleteness(schemaResult.data);
+    warnings.push(...completenessResult.warnings);
+    if (strict && warnings.length > 0) {
+        errors.push(...warnings.map((w) => `[STRICT] ${w}`));
+        return { valid: false, warnings: [], errors };
+    }
+    return { valid: true, warnings, errors };
+}
+export function validateAllWUs(options = {}) {
+    const { strict = false, doneOnly = false } = options;
+    const wuDir = WU_PATHS.WU_DIR();
+    if (!existsSync(wuDir)) {
+        return {
+            totalValid: 0,
+            totalInvalid: 1,
+            totalWarnings: 0,
+            results: [
+                {
+                    wuId: 'DIRECTORY',
+                    valid: false,
+                    warnings: [],
+                    errors: [`WU directory not found: ${wuDir}`],
+                },
+            ],
+        };
+    }
+    const files = readdirSync(wuDir).filter((f) => f.endsWith('.yaml'));
+    const results = [];
+    let totalValid = 0;
+    let totalInvalid = 0;
+    let totalWarnings = 0;
+    for (const file of files) {
+        const wuPath = `${wuDir}/${file}`;
+        const wuId = file.replace('.yaml', '');
+        if (doneOnly) {
+            try {
+                const text = readFileSync(wuPath, { encoding: FILE_SYSTEM.UTF8 });
+                const doc = parseYAML(text);
+                if (doc.status !== WU_STATUS.DONE) {
+                    continue;
+                }
+            }
+            catch {
+                // If we can't read, still validate to catch the error
+            }
+        }
+        const result = validateSingleWU(wuPath, { strict });
+        results.push({ wuId, ...result });
+        if (result.valid) {
+            totalValid++;
+            totalWarnings += result.warnings.length;
+        }
+        else {
+            totalInvalid++;
+        }
+    }
+    return { totalValid, totalInvalid, totalWarnings, results };
+}
+//# sourceMappingURL=wu-tasks.js.map

package/dist/validators/wu-tasks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wu-tasks.js","sourceRoot":"","sources":["../../src/validators/wu-tasks.ts"],"names":[],"mappings":"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"}

package/dist/work-classifier.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Work domain enum-style constants
+ */
+export declare const WORK_DOMAINS: {
+    readonly UI: "ui";
+    readonly BACKEND: "backend";
+    readonly DOCS: "docs";
+    readonly INFRA: "infra";
+    readonly MIXED: "mixed";
+};
+export type WorkDomain = (typeof WORK_DOMAINS)[keyof typeof WORK_DOMAINS];
+/**
+ * Signal weights for each source type.
+ * Confidence = max(matched_signal_weights), not sum.
+ */
+export declare const SIGNAL_WEIGHTS: {
+    readonly CODE_PATHS: 1;
+    readonly LANE: 0.6;
+    readonly TYPE: 0.3;
+    readonly DESCRIPTION: 0.2;
+};
+/**
+ * Built-in default UI code path patterns (minimatch glob patterns).
+ * CSS/SCSS/LESS, components/pages directories, app page/layout files,
+ * module CSS, styled components.
+ */
+export declare const DEFAULT_UI_CODE_PATH_PATTERNS: readonly string[];
+/**
+ * Built-in default UI lane hints.
+ * Matched against the lane parent (part before the colon).
+ */
+export declare const DEFAULT_UI_LANE_HINTS: readonly string[];
+/**
+ * A signal that contributed to the classification.
+ */
+export interface WorkSignal {
+    /** Signal source: 'code_paths' | 'lane' | 'type' | 'description' */
+    source: string;
+    /** The domain this signal points to */
+    domain: WorkDomain;
+    /** The weight of this signal */
+    weight: number;
+    /** What matched (e.g., the pattern or keyword) */
+    match: string;
+}
+/**
+ * Result of classifyWork.
+ */
+export interface WorkClassification {
+    /** Detected work domain */
+    domain: WorkDomain;
+    /** Confidence score (max signal weight, 0 if no match) */
+    confidence: number;
+    /** Individual signals that contributed */
+    signals: WorkSignal[];
+    /** Abstract capability tags (NOT client skill names) */
+    capabilities: string[];
+    /** Test methodology hint, e.g. 'smoke-test' for UI work */
+    testMethodologyHint?: string;
+}
+/**
+ * Optional configuration to extend defaults.
+ * Maps to methodology.work_classification in workspace.yaml.
+ */
+export interface WorkClassificationConfig {
+    ui?: {
+        /** Additional code_path_patterns (extend defaults) */
+        code_path_patterns?: string[];
+        /** Additional lane_hints (extend defaults) */
+        lane_hints?: string[];
+    };
+}
+/**
+ * Classify work domain from multiple weighted signals.
+ *
+ * Signal weights:
+ * - code_paths patterns: 1.0
+ * - lane hints: 0.6
+ * - WU type: 0.3
+ * - description keywords: 0.2
+ *
+ * Confidence = max(matched signal weights for winning domain).
+ * Domain only assigned when confidence >= 0.3.
+ *
+ * @param doc - WU document (code_paths, lane, type, description)
+ * @param config - Optional config to extend default patterns
+ * @returns WorkClassification with domain, confidence, signals, capabilities, testMethodologyHint
+ */
+export declare function classifyWork(doc: {
+    code_paths?: string[];
+    lane?: string;
+    type?: string;
+    description?: string;
+}, config?: WorkClassificationConfig): WorkClassification;
+//# sourceMappingURL=work-classifier.d.ts.map

package/dist/work-classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"work-classifier.d.ts","sourceRoot":"","sources":["../src/work-classifier.ts"],"names":[],"mappings":"AAqBA;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;CAMf,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAE1E;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;CAKjB,CAAC;AAeX;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,EAAE,SAAS,MAAM,EA4BzD,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAKjD,CAAC;AA0FH;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,oEAAoE;IACpE,MAAM,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,MAAM,EAAE,UAAU,CAAC;IACnB,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,2BAA2B;IAC3B,MAAM,EAAE,UAAU,CAAC;IACnB,0DAA0D;IAC1D,UAAU,EAAE,MAAM,CAAC;IACnB,0CAA0C;IAC1C,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,wDAAwD;IACxD,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,2DAA2D;IAC3D,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACvC,EAAE,CAAC,EAAE;QACH,sDAAsD;QACtD,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;QAC9B,8CAA8C;QAC9C,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;KACvB,CAAC;CACH;AA4FD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,EACD,MAAM,CAAC,EAAE,wBAAwB,GAChC,kBAAkB,CAmLpB"}

package/dist/work-classifier.js

@@ -0,0 +1,407 @@
+// Copyright (c) 2026 Hellmai Ltd
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Signal-Based Work Classifier
+ *
+ * WU-1899: Determines work domain (ui/backend/docs/infra/mixed) from
+ * multiple weighted signals: code_paths patterns (weight 1.0), lane hints
+ * (0.6), type (0.3), description keywords (0.2).
+ *
+ * Returns abstract capability tags (not client skill names) for
+ * vendor-agnostic design. Configurable via methodology.work_classification
+ * in workspace.yaml with sensible built-in defaults.
+ *
+ * @module work-classifier
+ */
+import { minimatch } from 'minimatch';
+// ─── Constants ───────────────────────────────────────────────────────
+/**
+ * Work domain enum-style constants
+ */
+export const WORK_DOMAINS = {
+    UI: 'ui',
+    BACKEND: 'backend',
+    DOCS: 'docs',
+    INFRA: 'infra',
+    MIXED: 'mixed',
+};
+/**
+ * Signal weights for each source type.
+ * Confidence = max(matched_signal_weights), not sum.
+ */
+export const SIGNAL_WEIGHTS = {
+    CODE_PATHS: 1.0,
+    LANE: 0.6,
+    TYPE: 0.3,
+    DESCRIPTION: 0.2,
+};
+/**
+ * Confidence threshold: domain only assigned when max signal weight >= this.
+ */
+const CONFIDENCE_THRESHOLD = 0.3;
+/**
+ * Smoke-test hint threshold: testMethodologyHint only assigned when
+ * UI confidence >= this value.
+ */
+const SMOKE_TEST_THRESHOLD = 0.5;
+// ─── Default Patterns ────────────────────────────────────────────────
+/**
+ * Built-in default UI code path patterns (minimatch glob patterns).
+ * CSS/SCSS/LESS, components/pages directories, app page/layout files,
+ * module CSS, styled components.
+ */
+export const DEFAULT_UI_CODE_PATH_PATTERNS = Object.freeze([
+    // Stylesheets
+    '**/*.css',
+    '**/*.scss',
+    '**/*.less',
+    '**/*.module.css',
+    '**/*.module.scss',
+    // Styled components
+    '**/*.styled.ts',
+    '**/*.styled.tsx',
+    '**/*.styled.js',
+    '**/*.styled.jsx',
+    // Component / page directories
+    '**/components/**',
+    '**/pages/**',
+    // Next.js / app router conventions
+    '**/app/**/page.tsx',
+    '**/app/**/page.ts',
+    '**/app/**/page.jsx',
+    '**/app/**/page.js',
+    '**/app/**/layout.tsx',
+    '**/app/**/layout.ts',
+    '**/app/**/layout.jsx',
+    '**/app/**/layout.js',
+    '**/app/page.tsx',
+    '**/app/page.ts',
+    '**/app/layout.tsx',
+    '**/app/layout.ts',
+]);
+/**
+ * Built-in default UI lane hints.
+ * Matched against the lane parent (part before the colon).
+ */
+export const DEFAULT_UI_LANE_HINTS = Object.freeze([
+    'Experience',
+    'Frontend',
+    'UI',
+    'Design',
+]);
+/**
+ * Built-in docs code path patterns.
+ */
+const DEFAULT_DOCS_CODE_PATH_PATTERNS = Object.freeze([
+    'docs/**',
+    '**/*.md',
+    '**/*.mdx',
+    'README*',
+    'CHANGELOG*',
+]);
+/**
+ * Built-in docs lane hints.
+ */
+const DEFAULT_DOCS_LANE_HINTS = Object.freeze([
+    'Content',
+    'Documentation',
+    'Docs',
+]);
+/**
+ * Built-in infra code path patterns.
+ */
+const DEFAULT_INFRA_CODE_PATH_PATTERNS = Object.freeze([
+    '.github/**',
+    'Dockerfile*',
+    'docker-compose*',
+    '**/terraform/**',
+    '**/k8s/**',
+    '**/kubernetes/**',
+    'infrastructure/**',
+]);
+/**
+ * Built-in infra lane hints.
+ */
+const DEFAULT_INFRA_LANE_HINTS = Object.freeze([
+    'Operations',
+    'Infrastructure',
+    'DevOps',
+    'Platform',
+]);
+/**
+ * UI-related description keywords (case-insensitive).
+ */
+const UI_DESCRIPTION_KEYWORDS = Object.freeze([
+    'css',
+    'scss',
+    'less',
+    'stylesheet',
+    'component',
+    'layout',
+    'responsive',
+    'ui',
+    'frontend',
+    'styled',
+    'animation',
+    'theme',
+]);
+/**
+ * Docs-related description keywords (case-insensitive).
+ */
+const DOCS_DESCRIPTION_KEYWORDS = Object.freeze([
+    'documentation',
+    'readme',
+    'changelog',
+    'docs',
+    'guide',
+    'tutorial',
+]);
+/**
+ * Infra-related description keywords (case-insensitive).
+ */
+const INFRA_DESCRIPTION_KEYWORDS = Object.freeze([
+    'docker',
+    'kubernetes',
+    'terraform',
+    'ci/cd',
+    'pipeline',
+    'deploy',
+    'infrastructure',
+]);
+function createDomainSignals(domain) {
+    return { domain, maxWeight: 0, signals: [] };
+}
+function addSignal(ds, signal) {
+    ds.signals.push(signal);
+    if (signal.weight > ds.maxWeight) {
+        ds.maxWeight = signal.weight;
+    }
+}
+/**
+ * Check if any code_paths match a set of glob patterns.
+ */
+function matchCodePaths(codePaths, patterns) {
+    for (const path of codePaths) {
+        for (const pattern of patterns) {
+            if (minimatch(path, pattern)) {
+                return pattern;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Check if the lane parent matches any hints (case-insensitive).
+ */
+function matchLaneHint(lane, hints) {
+    const parts = lane.split(':');
+    const laneParent = (parts[0] ?? '').trim().toLowerCase();
+    const laneSublane = parts.length > 1 ? (parts[1] ?? '').trim().toLowerCase() : '';
+    for (const hint of hints) {
+        const hintLower = hint.toLowerCase();
+        if (laneParent === hintLower || laneSublane === hintLower) {
+            return hint;
+        }
+    }
+    return undefined;
+}
+/**
+ * Check if description contains any keywords (case-insensitive, word boundary).
+ */
+function matchDescriptionKeywords(description, keywords) {
+    const descLower = description.toLowerCase();
+    for (const keyword of keywords) {
+        if (descLower.includes(keyword.toLowerCase())) {
+            return keyword;
+        }
+    }
+    return undefined;
+}
+/**
+ * Domain-to-capabilities data map (OCP-compliant).
+ * Add new domains by extending the record, no switch modification needed.
+ */
+const DOMAIN_CAPABILITIES = {
+    [WORK_DOMAINS.UI]: ['ui-design-awareness', 'component-reuse-check'],
+    [WORK_DOMAINS.DOCS]: ['documentation-structure', 'link-validation'],
+    [WORK_DOMAINS.INFRA]: ['infrastructure-review', 'security-check'],
+    [WORK_DOMAINS.MIXED]: ['cross-domain-awareness'],
+    [WORK_DOMAINS.BACKEND]: [],
+};
+/**
+ * Map work domain to capabilities (abstract, vendor-agnostic).
+ */
+function getCapabilities(domain) {
+    return DOMAIN_CAPABILITIES[domain] ?? [];
+}
+// ─── Public API ──────────────────────────────────────────────────────
+/**
+ * Classify work domain from multiple weighted signals.
+ *
+ * Signal weights:
+ * - code_paths patterns: 1.0
+ * - lane hints: 0.6
+ * - WU type: 0.3
+ * - description keywords: 0.2
+ *
+ * Confidence = max(matched signal weights for winning domain).
+ * Domain only assigned when confidence >= 0.3.
+ *
+ * @param doc - WU document (code_paths, lane, type, description)
+ * @param config - Optional config to extend default patterns
+ * @returns WorkClassification with domain, confidence, signals, capabilities, testMethodologyHint
+ */
+export function classifyWork(doc, config) {
+    const codePaths = doc.code_paths ?? [];
+    const lane = doc.lane ?? '';
+    const type = doc.type ?? '';
+    const description = doc.description ?? '';
+    // Merge config patterns with defaults (config extends, not replaces)
+    const uiCodePathPatterns = [
+        ...DEFAULT_UI_CODE_PATH_PATTERNS,
+        ...(config?.ui?.code_path_patterns ?? []),
+    ];
+    const uiLaneHints = [...DEFAULT_UI_LANE_HINTS, ...(config?.ui?.lane_hints ?? [])];
+    // Collect signals per domain
+    const ui = createDomainSignals(WORK_DOMAINS.UI);
+    const docs = createDomainSignals(WORK_DOMAINS.DOCS);
+    const infra = createDomainSignals(WORK_DOMAINS.INFRA);
+    // ── Signal 1: code_paths (weight 1.0) ──
+    if (codePaths.length > 0) {
+        const uiMatch = matchCodePaths(codePaths, uiCodePathPatterns);
+        if (uiMatch) {
+            addSignal(ui, {
+                source: 'code_paths',
+                domain: WORK_DOMAINS.UI,
+                weight: SIGNAL_WEIGHTS.CODE_PATHS,
+                match: uiMatch,
+            });
+        }
+        const docsMatch = matchCodePaths(codePaths, DEFAULT_DOCS_CODE_PATH_PATTERNS);
+        if (docsMatch) {
+            addSignal(docs, {
+                source: 'code_paths',
+                domain: WORK_DOMAINS.DOCS,
+                weight: SIGNAL_WEIGHTS.CODE_PATHS,
+                match: docsMatch,
+            });
+        }
+        const infraMatch = matchCodePaths(codePaths, DEFAULT_INFRA_CODE_PATH_PATTERNS);
+        if (infraMatch) {
+            addSignal(infra, {
+                source: 'code_paths',
+                domain: WORK_DOMAINS.INFRA,
+                weight: SIGNAL_WEIGHTS.CODE_PATHS,
+                match: infraMatch,
+            });
+        }
+    }
+    // ── Signal 2: lane hints (weight 0.6) ──
+    if (lane) {
+        const uiLaneMatch = matchLaneHint(lane, uiLaneHints);
+        if (uiLaneMatch) {
+            addSignal(ui, {
+                source: 'lane',
+                domain: WORK_DOMAINS.UI,
+                weight: SIGNAL_WEIGHTS.LANE,
+                match: uiLaneMatch,
+            });
+        }
+        const docsLaneMatch = matchLaneHint(lane, DEFAULT_DOCS_LANE_HINTS);
+        if (docsLaneMatch) {
+            addSignal(docs, {
+                source: 'lane',
+                domain: WORK_DOMAINS.DOCS,
+                weight: SIGNAL_WEIGHTS.LANE,
+                match: docsLaneMatch,
+            });
+        }
+        const infraLaneMatch = matchLaneHint(lane, DEFAULT_INFRA_LANE_HINTS);
+        if (infraLaneMatch) {
+            addSignal(infra, {
+                source: 'lane',
+                domain: WORK_DOMAINS.INFRA,
+                weight: SIGNAL_WEIGHTS.LANE,
+                match: infraLaneMatch,
+            });
+        }
+    }
+    // ── Signal 3: WU type (weight 0.3) ──
+    if (type === 'documentation') {
+        addSignal(docs, {
+            source: 'type',
+            domain: WORK_DOMAINS.DOCS,
+            weight: SIGNAL_WEIGHTS.TYPE,
+            match: 'documentation',
+        });
+    }
+    // ── Signal 4: description keywords (weight 0.2) ──
+    if (description) {
+        const uiKeywordMatch = matchDescriptionKeywords(description, UI_DESCRIPTION_KEYWORDS);
+        if (uiKeywordMatch) {
+            addSignal(ui, {
+                source: 'description',
+                domain: WORK_DOMAINS.UI,
+                weight: SIGNAL_WEIGHTS.DESCRIPTION,
+                match: uiKeywordMatch,
+            });
+        }
+        const docsKeywordMatch = matchDescriptionKeywords(description, DOCS_DESCRIPTION_KEYWORDS);
+        if (docsKeywordMatch) {
+            addSignal(docs, {
+                source: 'description',
+                domain: WORK_DOMAINS.DOCS,
+                weight: SIGNAL_WEIGHTS.DESCRIPTION,
+                match: docsKeywordMatch,
+            });
+        }
+        const infraKeywordMatch = matchDescriptionKeywords(description, INFRA_DESCRIPTION_KEYWORDS);
+        if (infraKeywordMatch) {
+            addSignal(infra, {
+                source: 'description',
+                domain: WORK_DOMAINS.INFRA,
+                weight: SIGNAL_WEIGHTS.DESCRIPTION,
+                match: infraKeywordMatch,
+            });
+        }
+    }
+    // ── Determine winning domain ──
+    const candidates = [ui, docs, infra].filter((d) => d.maxWeight >= CONFIDENCE_THRESHOLD);
+    // Check for mixed: multiple domains with strong code_paths signals
+    const strongCodePathDomains = [ui, docs, infra].filter((d) => d.signals.some((s) => s.source === 'code_paths'));
+    if (strongCodePathDomains.length > 1) {
+        // Multiple code_paths domains detected - classify as mixed
+        const allSignals = strongCodePathDomains.flatMap((d) => d.signals);
+        return {
+            domain: WORK_DOMAINS.MIXED,
+            confidence: Math.max(...strongCodePathDomains.map((d) => d.maxWeight)),
+            signals: allSignals,
+            capabilities: getCapabilities(WORK_DOMAINS.MIXED),
+            testMethodologyHint: undefined,
+        };
+    }
+    if (candidates.length === 0) {
+        // No signals above threshold - default to backend
+        return {
+            domain: WORK_DOMAINS.BACKEND,
+            confidence: 0,
+            signals: [],
+            capabilities: [],
+            testMethodologyHint: undefined,
+        };
+    }
+    // Pick the domain with highest max weight
+    candidates.sort((a, b) => b.maxWeight - a.maxWeight);
+    const winner = candidates[0];
+    const testMethodologyHint = winner.domain === WORK_DOMAINS.UI && winner.maxWeight >= SMOKE_TEST_THRESHOLD
+        ? 'smoke-test'
+        : undefined;
+    return {
+        domain: winner.domain,
+        confidence: winner.maxWeight,
+        signals: winner.signals,
+        capabilities: getCapabilities(winner.domain),
+        testMethodologyHint,
+    };
+}
+//# sourceMappingURL=work-classifier.js.map