@flowdot.ai/daemon 1.0.0

package/dist/goals/MetaGoalEnforcer.d.ts

@@ -0,0 +1,111 @@
+import { EventEmitter } from 'node:events';
+import type { Goal, GoalHash, MetaGoal, Task, TaskType, CreateTaskInput, Logger } from './types.js';
+import { GoalError } from './errors.js';
+import type { TaskSuggestion } from './TaskGenerator.js';
+export type MetaGoalLLMFunction = (prompt: string, options?: {
+    modelTier?: string;
+    maxTokens?: number;
+    temperature?: number;
+}) => Promise<string>;
+export interface ConstraintViolation {
+    readonly metaGoalId: number;
+    readonly constraintDescription: string;
+    readonly priority: number;
+    readonly explanation: string;
+    readonly severity: 'block' | 'warn';
+    readonly suggestedFix?: string;
+}
+export interface EnforcementResult {
+    readonly allowed: boolean;
+    readonly violations: ConstraintViolation[];
+    readonly warnings: ConstraintViolation[];
+    readonly modifiedTask?: TaskSuggestion | CreateTaskInput;
+    readonly wasModified: boolean;
+    readonly processingTime: number;
+}
+export interface ParsedConstraint {
+    readonly metaGoalId: number;
+    readonly type: ConstraintType;
+    readonly target: ConstraintTarget;
+    readonly pattern: string;
+    readonly priority: number;
+    readonly isBlocking: boolean;
+}
+export type ConstraintType = 'never_do' | 'always_do' | 'prefer' | 'avoid' | 'require' | 'limit' | 'time_restrict';
+export type ConstraintTarget = 'task_type' | 'task_title' | 'task_description' | 'file_path' | 'command' | 'time' | 'cost' | 'frequency' | 'any';
+export interface MetaGoalEnforcerOptions {
+    readonly logger?: Logger;
+    readonly llmFunction?: MetaGoalLLMFunction;
+    readonly cacheTtlMs?: number;
+    readonly useLlmForComplexConstraints?: boolean;
+    readonly defaultSeverity?: 'block' | 'warn';
+}
+export interface MetaGoalEnforcerEvents {
+    'violation-detected': [ConstraintViolation];
+    'task-blocked': [{
+        task: TaskSuggestion | CreateTaskInput;
+        violations: ConstraintViolation[];
+    }];
+    'task-modified': [{
+        original: TaskSuggestion | CreateTaskInput;
+        modified: TaskSuggestion | CreateTaskInput;
+    }];
+    'cache-updated': [{
+        metaGoalCount: number;
+    }];
+    'error': [Error];
+}
+export declare class MetaGoalEnforcementError extends GoalError {
+    constructor(message: string, cause?: Error);
+}
+export declare class MetaGoalEnforcer extends EventEmitter<MetaGoalEnforcerEvents> {
+    private readonly logger;
+    private readonly llmFunction?;
+    private readonly cacheTtlMs;
+    private readonly useLlmForComplexConstraints;
+    private readonly defaultSeverity;
+    private constraintCache;
+    private cacheTimestamps;
+    constructor(options?: MetaGoalEnforcerOptions);
+    enforceOnSuggestion(suggestion: TaskSuggestion, metaGoals: MetaGoal[], goalHash: GoalHash): Promise<EnforcementResult>;
+    enforceOnInput(input: CreateTaskInput, metaGoals: MetaGoal[], goalHash: GoalHash): Promise<EnforcementResult>;
+    enforceOnTask(task: Task, metaGoals: MetaGoal[], goalHash: GoalHash): Promise<EnforcementResult>;
+    canGenerateTasks(goal: Goal, metaGoals: MetaGoal[]): {
+        allowed: boolean;
+        reason?: string;
+    };
+    enforceOnBatch(suggestions: TaskSuggestion[], metaGoals: MetaGoal[], goalHash: GoalHash): Promise<{
+        allowed: TaskSuggestion[];
+        blocked: Array<{
+            suggestion: TaskSuggestion;
+            violations: ConstraintViolation[];
+        }>;
+        warnings: Array<{
+            suggestion: TaskSuggestion;
+            warnings: ConstraintViolation[];
+        }>;
+    }>;
+    private parseConstraints;
+    private parseMetaGoal;
+    private parsewithLLM;
+    private checkViolations;
+    private checkSingleConstraint;
+    private matchesPattern;
+    private extractKeyTerms;
+    private filterApplicableMetaGoals;
+    private getCachedConstraints;
+    private cacheConstraints;
+    clearCache(): void;
+    getCacheStats(): {
+        cachedMetaGoals: number;
+        totalConstraints: number;
+    };
+}
+export declare function metaGoalAppliesToGoal(metaGoal: MetaGoal, goalHash: GoalHash): boolean;
+export declare function sortMetaGoalsByPriority(metaGoals: MetaGoal[]): MetaGoal[];
+export declare function getBlockingMetaGoalsForType(metaGoals: MetaGoal[], taskType: TaskType): MetaGoal[];
+export declare function summarizeConstraints(metaGoals: MetaGoal[], goalHash: GoalHash): {
+    blocking: string[];
+    warnings: string[];
+};
+export declare function createMetaGoalEnforcer(options?: MetaGoalEnforcerOptions): MetaGoalEnforcer;

package/dist/goals/MetaGoalEnforcer.js

@@ -0,0 +1,536 @@
+import { EventEmitter } from 'node:events';
+import { GoalError } from './errors.js';
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+const CONSTRAINT_PATTERNS = [
+    { regex: /never\s+(delete|remove|rm)\s+/i, type: 'never_do', target: 'command', isBlocking: true },
+    { regex: /never\s+(push|deploy)\s+to\s+production/i, type: 'never_do', target: 'command', isBlocking: true },
+    { regex: /never\s+(modify|change|edit)\s+/i, type: 'never_do', target: 'file_path', isBlocking: true },
+    { regex: /never\s+run\s+/i, type: 'never_do', target: 'command', isBlocking: true },
+    { regex: /don't\s+(ever|)\s*(delete|remove|modify)/i, type: 'never_do', target: 'any', isBlocking: true },
+    { regex: /prohibited|forbidden|banned/i, type: 'never_do', target: 'any', isBlocking: true },
+    { regex: /avoid\s+/i, type: 'avoid', target: 'any', isBlocking: false },
+    { regex: /try\s+not\s+to/i, type: 'avoid', target: 'any', isBlocking: false },
+    { regex: /minimize\s+/i, type: 'avoid', target: 'any', isBlocking: false },
+    { regex: /prefer\s+not\s+to/i, type: 'avoid', target: 'any', isBlocking: false },
+    { regex: /prefer\s+/i, type: 'prefer', target: 'any', isBlocking: false },
+    { regex: /prioritize\s+/i, type: 'prefer', target: 'any', isBlocking: false },
+    { regex: /when\s+possible,?\s+(use|prefer)/i, type: 'prefer', target: 'any', isBlocking: false },
+    { regex: /always\s+/i, type: 'always_do', target: 'any', isBlocking: true },
+    { regex: /must\s+(have|include|be)/i, type: 'require', target: 'any', isBlocking: true },
+    { regex: /require[sd]?\s+/i, type: 'require', target: 'any', isBlocking: true },
+    { regex: /limit\s+to\s+/i, type: 'limit', target: 'any', isBlocking: true },
+    { regex: /maximum\s+(of\s+)?\d+/i, type: 'limit', target: 'frequency', isBlocking: true },
+    { regex: /no\s+more\s+than\s+/i, type: 'limit', target: 'any', isBlocking: true },
+    { regex: /at\s+most\s+/i, type: 'limit', target: 'any', isBlocking: true },
+    { regex: /only\s+(during|between|after|before)/i, type: 'time_restrict', target: 'time', isBlocking: true },
+    { regex: /not\s+(during|between|after|before)/i, type: 'time_restrict', target: 'time', isBlocking: true },
+    { regex: /business\s+hours/i, type: 'time_restrict', target: 'time', isBlocking: true },
+    { regex: /quiet\s+hours/i, type: 'time_restrict', target: 'time', isBlocking: true },
+];
+const TASK_TYPE_KEYWORDS = {
+    research: ['research', 'search', 'find', 'look up', 'investigate', 'explore'],
+    draft: ['draft', 'write', 'create content', 'compose', 'document'],
+    code: ['code', 'implement', 'develop', 'program', 'build', 'fix'],
+    execute: ['execute', 'run', 'command', 'shell', 'terminal'],
+    recipe: ['recipe', 'workflow', 'automation', 'pipeline'],
+    loop: ['loop', 'recurring', 'scheduled', 'repeat'],
+    notify: ['notify', 'alert', 'message', 'remind'],
+};
+export class MetaGoalEnforcementError extends GoalError {
+    constructor(message, cause) {
+        super('ENFORCEMENT_ERROR', message, cause ? { cause } : {});
+    }
+}
+export class MetaGoalEnforcer extends EventEmitter {
+    logger;
+    llmFunction;
+    cacheTtlMs;
+    useLlmForComplexConstraints;
+    defaultSeverity;
+    constraintCache = new Map();
+    cacheTimestamps = new Map();
+    constructor(options = {}) {
+        super();
+        this.logger = options.logger ?? noopLogger;
+        this.llmFunction = options.llmFunction;
+        this.cacheTtlMs = options.cacheTtlMs ?? 5 * 60 * 1000;
+        this.useLlmForComplexConstraints = options.useLlmForComplexConstraints ?? false;
+        this.defaultSeverity = options.defaultSeverity ?? 'warn';
+    }
+    async enforceOnSuggestion(suggestion, metaGoals, goalHash) {
+        const startTime = Date.now();
+        try {
+            const applicable = this.filterApplicableMetaGoals(metaGoals, goalHash);
+            if (applicable.length === 0) {
+                return {
+                    allowed: true,
+                    violations: [],
+                    warnings: [],
+                    wasModified: false,
+                    processingTime: Date.now() - startTime,
+                };
+            }
+            const constraints = await this.parseConstraints(applicable);
+            const { violations, warnings } = await this.checkViolations(suggestion, constraints, 'suggestion');
+            for (const violation of violations) {
+                this.emit('violation-detected', violation);
+            }
+            const allowed = violations.length === 0;
+            if (!allowed) {
+                this.emit('task-blocked', { task: suggestion, violations });
+            }
+            return {
+                allowed,
+                violations,
+                warnings,
+                wasModified: false,
+                processingTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('META_GOAL_ENFORCER', 'Enforcement failed', { error: err.message });
+            this.emit('error', err);
+            return {
+                allowed: false,
+                violations: [{
+                        metaGoalId: -1,
+                        constraintDescription: 'Enforcement system error',
+                        priority: 999,
+                        explanation: err.message,
+                        severity: 'block',
+                    }],
+                warnings: [],
+                wasModified: false,
+                processingTime: Date.now() - startTime,
+            };
+        }
+    }
+    async enforceOnInput(input, metaGoals, goalHash) {
+        const startTime = Date.now();
+        try {
+            const applicable = this.filterApplicableMetaGoals(metaGoals, goalHash);
+            if (applicable.length === 0) {
+                return {
+                    allowed: true,
+                    violations: [],
+                    warnings: [],
+                    wasModified: false,
+                    processingTime: Date.now() - startTime,
+                };
+            }
+            const constraints = await this.parseConstraints(applicable);
+            const { violations, warnings } = await this.checkViolations(input, constraints, 'input');
+            for (const violation of violations) {
+                this.emit('violation-detected', violation);
+            }
+            const allowed = violations.length === 0;
+            if (!allowed) {
+                this.emit('task-blocked', { task: input, violations });
+            }
+            return {
+                allowed,
+                violations,
+                warnings,
+                wasModified: false,
+                processingTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('META_GOAL_ENFORCER', 'Enforcement failed', { error: err.message });
+            this.emit('error', err);
+            return {
+                allowed: false,
+                violations: [{
+                        metaGoalId: -1,
+                        constraintDescription: 'Enforcement system error',
+                        priority: 999,
+                        explanation: err.message,
+                        severity: 'block',
+                    }],
+                warnings: [],
+                wasModified: false,
+                processingTime: Date.now() - startTime,
+            };
+        }
+    }
+    async enforceOnTask(task, metaGoals, goalHash) {
+        const input = {
+            title: task.title,
+            description: task.description ?? undefined,
+            taskType: task.taskType,
+            scheduledFor: task.scheduledFor ? task.scheduledFor.toISOString() : undefined,
+            milestoneId: task.milestoneId ?? undefined,
+        };
+        return this.enforceOnInput(input, metaGoals, goalHash);
+    }
+    canGenerateTasks(goal, metaGoals) {
+        const applicable = this.filterApplicableMetaGoals(metaGoals, goal.hash);
+        for (const metaGoal of applicable) {
+            const description = metaGoal.description.toLowerCase();
+            if (description.includes('no tasks') ||
+                description.includes('pause task generation') ||
+                description.includes('stop generating')) {
+                return {
+                    allowed: false,
+                    reason: `Meta-goal "${metaGoal.description}" prevents task generation`,
+                };
+            }
+        }
+        return { allowed: true };
+    }
+    async enforceOnBatch(suggestions, metaGoals, goalHash) {
+        const allowed = [];
+        const blocked = [];
+        const warnings = [];
+        for (const suggestion of suggestions) {
+            const result = await this.enforceOnSuggestion(suggestion, metaGoals, goalHash);
+            if (result.allowed) {
+                allowed.push(suggestion);
+                if (result.warnings.length > 0) {
+                    warnings.push({ suggestion, warnings: result.warnings });
+                }
+            }
+            else {
+                blocked.push({ suggestion, violations: result.violations });
+            }
+        }
+        this.logger.debug('META_GOAL_ENFORCER', 'Batch enforcement complete', {
+            total: suggestions.length,
+            allowed: allowed.length,
+            blocked: blocked.length,
+        });
+        return { allowed, blocked, warnings };
+    }
+    async parseConstraints(metaGoals) {
+        const constraints = [];
+        for (const metaGoal of metaGoals) {
+            const cached = this.getCachedConstraints(metaGoal.id);
+            if (cached) {
+                constraints.push(...cached);
+                continue;
+            }
+            const parsed = await this.parseMetaGoal(metaGoal);
+            constraints.push(...parsed);
+            this.cacheConstraints(metaGoal.id, parsed);
+        }
+        constraints.sort((a, b) => b.priority - a.priority);
+        return constraints;
+    }
+    async parseMetaGoal(metaGoal) {
+        const description = metaGoal.description;
+        const constraints = [];
+        for (const pattern of CONSTRAINT_PATTERNS) {
+            if (pattern.regex.test(description)) {
+                constraints.push({
+                    metaGoalId: metaGoal.id,
+                    type: pattern.type,
+                    target: pattern.target,
+                    pattern: description,
+                    priority: metaGoal.priority,
+                    isBlocking: pattern.isBlocking,
+                });
+            }
+        }
+        if (constraints.length === 0 && this.useLlmForComplexConstraints && this.llmFunction) {
+            try {
+                const llmConstraints = await this.parsewithLLM(metaGoal);
+                constraints.push(...llmConstraints);
+            }
+            catch {
+                this.logger.warn('META_GOAL_ENFORCER', 'LLM parsing failed, using default', {
+                    metaGoalId: metaGoal.id,
+                });
+            }
+        }
+        if (constraints.length === 0) {
+            constraints.push({
+                metaGoalId: metaGoal.id,
+                type: 'avoid',
+                target: 'any',
+                pattern: description,
+                priority: metaGoal.priority,
+                isBlocking: false,
+            });
+        }
+        return constraints;
+    }
+    async parsewithLLM(metaGoal) {
+        if (!this.llmFunction) {
+            return [];
+        }
+        const prompt = `Analyze this behavioral constraint and extract structured rules:
+
+Constraint: "${metaGoal.description}"
+
+Respond with JSON array of rules, each with:
+- type: "never_do" | "always_do" | "prefer" | "avoid" | "require" | "limit" | "time_restrict"
+- target: "task_type" | "task_title" | "task_description" | "file_path" | "command" | "time" | "cost" | "frequency" | "any"
+- pattern: the specific thing to match
+- isBlocking: true if this should block tasks, false if just a warning
+
+Example response:
+[{"type":"never_do","target":"command","pattern":"delete production","isBlocking":true}]
+
+Only respond with the JSON array, nothing else.`;
+        const response = await this.llmFunction(prompt, {
+            modelTier: 'fast',
+            maxTokens: 500,
+            temperature: 0.1,
+        });
+        try {
+            const parsed = JSON.parse(response);
+            return parsed.map((p) => ({
+                metaGoalId: metaGoal.id,
+                type: p.type,
+                target: p.target,
+                pattern: p.pattern,
+                priority: metaGoal.priority,
+                isBlocking: p.isBlocking,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    async checkViolations(task, constraints, _taskSource) {
+        const violations = [];
+        const warnings = [];
+        const taskTitle = task.title.toLowerCase();
+        const taskDescription = ('description' in task ? task.description : '')?.toLowerCase() ?? '';
+        const taskType = 'taskType' in task ? task.taskType : ('type' in task ? task.type : undefined);
+        for (const constraint of constraints) {
+            const violation = this.checkSingleConstraint(constraint, taskTitle, taskDescription, taskType);
+            if (violation) {
+                if (violation.severity === 'block') {
+                    violations.push(violation);
+                }
+                else {
+                    warnings.push(violation);
+                }
+            }
+        }
+        return { violations, warnings };
+    }
+    checkSingleConstraint(constraint, taskTitle, taskDescription, taskType) {
+        const pattern = constraint.pattern.toLowerCase();
+        switch (constraint.type) {
+            case 'never_do': {
+                if (this.matchesPattern(pattern, taskTitle, taskDescription, taskType, constraint.target)) {
+                    return {
+                        metaGoalId: constraint.metaGoalId,
+                        constraintDescription: constraint.pattern,
+                        priority: constraint.priority,
+                        explanation: `Task matches forbidden pattern: "${constraint.pattern}"`,
+                        severity: 'block',
+                    };
+                }
+                break;
+            }
+            case 'avoid': {
+                if (this.matchesPattern(pattern, taskTitle, taskDescription, taskType, constraint.target)) {
+                    return {
+                        metaGoalId: constraint.metaGoalId,
+                        constraintDescription: constraint.pattern,
+                        priority: constraint.priority,
+                        explanation: `Task matches pattern that should be avoided: "${constraint.pattern}"`,
+                        severity: 'warn',
+                    };
+                }
+                break;
+            }
+            case 'limit': {
+                if (this.matchesPattern(pattern, taskTitle, taskDescription, taskType, constraint.target)) {
+                    return {
+                        metaGoalId: constraint.metaGoalId,
+                        constraintDescription: constraint.pattern,
+                        priority: constraint.priority,
+                        explanation: `Task is subject to limit constraint: "${constraint.pattern}"`,
+                        severity: 'warn',
+                    };
+                }
+                break;
+            }
+            case 'time_restrict': {
+                const now = new Date();
+                const hour = now.getHours();
+                if (pattern.includes('quiet hours') || pattern.includes('not during')) {
+                    if (hour >= 22 || hour < 6) {
+                        return {
+                            metaGoalId: constraint.metaGoalId,
+                            constraintDescription: constraint.pattern,
+                            priority: constraint.priority,
+                            explanation: `Current time is within restricted hours`,
+                            severity: constraint.isBlocking ? 'block' : 'warn',
+                        };
+                    }
+                }
+                if (pattern.includes('business hours') || pattern.includes('only during')) {
+                    if (hour < 9 || hour >= 17) {
+                        return {
+                            metaGoalId: constraint.metaGoalId,
+                            constraintDescription: constraint.pattern,
+                            priority: constraint.priority,
+                            explanation: `Current time is outside allowed hours`,
+                            severity: constraint.isBlocking ? 'block' : 'warn',
+                        };
+                    }
+                }
+                break;
+            }
+            default:
+                if (constraint.isBlocking) {
+                    if (this.matchesPattern(pattern, taskTitle, taskDescription, taskType, constraint.target)) {
+                        return {
+                            metaGoalId: constraint.metaGoalId,
+                            constraintDescription: constraint.pattern,
+                            priority: constraint.priority,
+                            explanation: `Task violates constraint: "${constraint.pattern}"`,
+                            severity: 'block',
+                        };
+                    }
+                }
+        }
+        return null;
+    }
+    matchesPattern(pattern, taskTitle, taskDescription, taskType, target) {
+        const terms = this.extractKeyTerms(pattern);
+        switch (target) {
+            case 'task_type': {
+                if (!taskType)
+                    return false;
+                const typeKeywords = TASK_TYPE_KEYWORDS[taskType];
+                return terms.some((term) => typeKeywords.some((kw) => term.includes(kw) || kw.includes(term)));
+            }
+            case 'task_title':
+                return terms.some((term) => taskTitle.includes(term));
+            case 'task_description':
+                return terms.some((term) => taskDescription.includes(term));
+            case 'command': {
+                const commandIndicators = ['run', 'execute', 'command', 'shell', 'terminal'];
+                const isCommandTask = taskType === 'execute' ||
+                    commandIndicators.some((i) => taskTitle.includes(i) || taskDescription.includes(i));
+                if (!isCommandTask)
+                    return false;
+                return terms.some((term) => taskTitle.includes(term) || taskDescription.includes(term));
+            }
+            case 'file_path': {
+                const pathPatterns = /(?:\/[\w.-]+)+|\w+\.\w+/g;
+                const pathsInTitle = taskTitle.match(pathPatterns) ?? [];
+                const pathsInDesc = taskDescription.match(pathPatterns) ?? [];
+                const allPaths = [...pathsInTitle, ...pathsInDesc];
+                return terms.some((term) => allPaths.some((path) => path.includes(term)));
+            }
+            case 'any':
+            default:
+                return terms.some((term) => taskTitle.includes(term) ||
+                    taskDescription.includes(term) ||
+                    (taskType && taskType.includes(term)));
+        }
+    }
+    extractKeyTerms(pattern) {
+        const stripped = pattern
+            .replace(/never|always|avoid|prefer|don't|do not|must|require|limit|prohibited|forbidden/gi, '')
+            .replace(/\b(the|a|an|to|in|on|at|for|of|with|that|this|is|are|be|been|was|were)\b/gi, '')
+            .trim();
+        const terms = stripped
+            .split(/[\s,;.]+/)
+            .map((t) => t.toLowerCase().trim())
+            .filter((t) => t.length > 2);
+        return terms;
+    }
+    filterApplicableMetaGoals(metaGoals, goalHash) {
+        return metaGoals.filter((mg) => {
+            if (!mg.isActive)
+                return false;
+            if (mg.scope === 'all')
+                return true;
+            if (Array.isArray(mg.scope)) {
+                return mg.scope.includes(goalHash);
+            }
+            return true;
+        });
+    }
+    getCachedConstraints(metaGoalId) {
+        const cached = this.constraintCache.get(metaGoalId);
+        const timestamp = this.cacheTimestamps.get(metaGoalId);
+        if (!cached || !timestamp)
+            return null;
+        if (Date.now() - timestamp > this.cacheTtlMs) {
+            this.constraintCache.delete(metaGoalId);
+            this.cacheTimestamps.delete(metaGoalId);
+            return null;
+        }
+        return cached;
+    }
+    cacheConstraints(metaGoalId, constraints) {
+        this.constraintCache.set(metaGoalId, constraints);
+        this.cacheTimestamps.set(metaGoalId, Date.now());
+        this.emit('cache-updated', { metaGoalCount: this.constraintCache.size });
+    }
+    clearCache() {
+        this.constraintCache.clear();
+        this.cacheTimestamps.clear();
+        this.logger.debug('META_GOAL_ENFORCER', 'Cache cleared');
+    }
+    getCacheStats() {
+        let totalConstraints = 0;
+        for (const constraints of this.constraintCache.values()) {
+            totalConstraints += constraints.length;
+        }
+        return {
+            cachedMetaGoals: this.constraintCache.size,
+            totalConstraints,
+        };
+    }
+}
+export function metaGoalAppliesToGoal(metaGoal, goalHash) {
+    if (!metaGoal.isActive)
+        return false;
+    if (metaGoal.scope === 'all')
+        return true;
+    if (Array.isArray(metaGoal.scope)) {
+        return metaGoal.scope.includes(goalHash);
+    }
+    return true;
+}
+export function sortMetaGoalsByPriority(metaGoals) {
+    return [...metaGoals].sort((a, b) => b.priority - a.priority);
+}
+export function getBlockingMetaGoalsForType(metaGoals, taskType) {
+    const typeKeywords = TASK_TYPE_KEYWORDS[taskType];
+    return metaGoals.filter((mg) => {
+        if (!mg.isActive)
+            return false;
+        const description = mg.description.toLowerCase();
+        if (!/never|prohibited|forbidden|don't|do not/i.test(description)) {
+            return false;
+        }
+        return typeKeywords.some((kw) => description.includes(kw));
+    });
+}
+export function summarizeConstraints(metaGoals, goalHash) {
+    const blocking = [];
+    const warnings = [];
+    for (const mg of metaGoals) {
+        if (!metaGoalAppliesToGoal(mg, goalHash))
+            continue;
+        const description = mg.description.toLowerCase();
+        if (/never|prohibited|forbidden|must not/i.test(description)) {
+            blocking.push(mg.description);
+        }
+        else if (/avoid|prefer not|minimize/i.test(description)) {
+            warnings.push(mg.description);
+        }
+    }
+    return { blocking, warnings };
+}
+export function createMetaGoalEnforcer(options = {}) {
+    return new MetaGoalEnforcer(options);
+}