@amsterdamdatalabs/enact-factory 0.1.1

package/dist/core/config.js

@@ -0,0 +1,780 @@
+// ============================================
+// Enact Factory - Configuration
+// ============================================
+import { readFileSync, existsSync } from 'node:fs';
+import { join, resolve, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { getWorkspaceConfigPath, readWorkspaceRootConfig } from '../core/workspaceConfig.js';
+import { z } from 'zod';
+import YAML from 'yaml';
+import TOML from '@iarna/toml';
+import { setTimeWindowConfig, DEFAULT_TIME_WINDOW } from '../support/timeWindow.js';
+import { validateRuntimeStageConfig } from '../core/agentLifecycle.js';
+import { validateAzdoStateMapConfig } from '../azureDevOps/stateMapping.js';
+// Constants
+const CONFIG_FILENAMES = ['config.toml'];
+// Directories searched for config, in priority order.
+// 1. global baseline ~/.enact/factory/config.toml
+// 2. nearest workspace config.toml discovered by walking up from cwd to $HOME
+function getConfigSearchDirs() {
+    const home = homedir();
+    const dirs = [join(home, '.enact', 'factory')];
+    let current = resolve(process.cwd());
+    const stop = resolve(home);
+    while (true) {
+        dirs.push(current);
+        if (current === stop)
+            break;
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..', '..');
+    dirs.push(repoRoot);
+    return [...new Set(dirs)];
+}
+function getConfigSearchPaths() {
+    const paths = [];
+    for (const dir of getConfigSearchDirs()) {
+        for (const name of CONFIG_FILENAMES) {
+            paths.push(join(dir, name));
+        }
+    }
+    return paths;
+}
+const DEFAULT_HEARTBEAT_INTERVAL = 30 * 60 * 1000; // 30 minutes
+const AdapterNameSchema = z.enum(['claude', 'codex', 'responses', 'cursor', 'hermes', 'opencode']);
+const DEFAULT_POSTGRES_PORT = 45432;
+const DEFAULT_POSTGRES_DATABASE = 'enact_factory_dev';
+// Zod Schemas
+const ProjectConfigSchema = z.object({
+    name: z.string().min(1, 'Project name is required'),
+    path: z.string().min(1, 'Project path is required'),
+    heartbeatMs: z.number().positive().optional(),
+    azdoLabel: z.string().optional(),
+    enabled: z.boolean().default(true),
+    paused: z.boolean().default(false),
+    operators: z.array(z.string()).optional(),
+});
+const WorkItemRecordStatusSchema = z.enum([
+    'backlog',
+    'todo',
+    'blocked',
+    'in_progress',
+    'in_review',
+    'done',
+    'duplicate',
+    'cancelled',
+]);
+const AzdoConfigSchema = z.object({
+    apiKey: z.string().min(1, 'Azdo API key is required'),
+    teamId: z.string().min(1, 'Azdo team ID is required'),
+}).optional();
+const TimeRangeSchema = z.object({
+    start: z.string().regex(/^\d{2}:\d{2}$/, 'Format: HH:MM'),
+    end: z.string().regex(/^\d{2}:\d{2}$/, 'Format: HH:MM'),
+});
+const TimeWindowConfigSchema = z.object({
+    enabled: z.boolean().default(true),
+    allowedWindows: z.array(TimeRangeSchema).default([]),
+    blockedWindows: z.array(TimeRangeSchema).default([]),
+    restrictedDays: z.array(z.number().min(0).max(6)).optional(),
+    timezone: z.string().default('Asia/Seoul'),
+}).optional();
+const PairModeConfigSchema = z.object({
+    /** Enable pair mode */
+    enabled: z.boolean().default(false),
+    /** Executor max attempts */
+    maxAttempts: z.number().min(1).max(10).default(3),
+    /** Executor timeout (ms) */
+    executorTimeoutMs: z.number().positive().default(300000), // 5 min
+    /** Reviewer timeout (ms) */
+    reviewerTimeoutMs: z.number().positive().default(180000), // 3 min
+    /** Webhook URL (notification on complete/failure) */
+    webhookUrl: z.string().url().optional(),
+    /** Auto Azdo status update */
+    autoAzdoUpdate: z.boolean().default(true),
+}).optional();
+const ModelConfigSchema = z.object({
+    /** Executor agent model */
+    executor: z.string().default('claude-sonnet-4-5-20250929'),
+    /** Reviewer agent model */
+    reviewer: z.string().default('claude-sonnet-4-5-20250929'),
+}).optional();
+/** Per-role configuration schema */
+const ReviewerConsensusConfigSchema = z.object({
+    /** Enable multi-reviewer consensus checks */
+    enabled: z.boolean().default(false),
+    /** Additional reviewer models to run in addition to primary reviewer */
+    models: z.array(z.string()).default([]),
+    /** Required approvals to pass (defaults to all configured reviewer runs) */
+    requiredApprovals: z.number().int().positive().optional(),
+});
+const StageConfigSchema = z.object({
+    enabled: z.boolean().default(true),
+    adapter: AdapterNameSchema,
+    model: z.string(),
+    timeoutMs: z.number().min(0).default(0),
+    escalateModel: z.string().optional(),
+    escalateAfterIteration: z.number().min(1).optional(),
+    consensus: ReviewerConsensusConfigSchema.optional(),
+});
+/** Default stages configuration schema */
+const DefaultStagesConfigSchema = z.object({
+    coder: StageConfigSchema.default({
+        enabled: true,
+        adapter: 'claude',
+        model: 'claude-haiku-4-5-20251001',
+        timeoutMs: 0,
+        escalateModel: 'claude-sonnet-4-5-20250929',
+        escalateAfterIteration: 3,
+    }),
+    critic: StageConfigSchema.default({
+        enabled: true,
+        adapter: 'claude',
+        model: 'claude-haiku-4-5-20251001',
+        timeoutMs: 0,
+    }),
+    tester: StageConfigSchema.optional(),
+    documenter: StageConfigSchema.optional(),
+    auditor: StageConfigSchema.optional(),
+    'stage-documenter': StageConfigSchema.optional(),
+}).optional();
+/** Per-project stage override schema */
+const ProjectStagesOverrideSchema = z.object({
+    coder: StageConfigSchema.partial().optional(),
+    critic: StageConfigSchema.partial().optional(),
+    tester: StageConfigSchema.partial().optional(),
+    documenter: StageConfigSchema.partial().optional(),
+    auditor: StageConfigSchema.partial().optional(),
+    'stage-documenter': StageConfigSchema.partial().optional(),
+}).optional();
+/** Per-project agent configuration schema */
+const ProjectAgentConfigSchema = z.object({
+    path: z.string().min(1),
+    azdoProjectId: z.string().optional(),
+    stages: ProjectStagesOverrideSchema,
+});
+/** WorkItem decomposition (Planner) configuration schema */
+const DecompositionConfigSchema = z.object({
+    /** Enable decomposition */
+    enabled: z.boolean().default(false),
+    /** Decomposition threshold (minutes) - workItems exceeding this estimate are decomposed */
+    thresholdMinutes: z.number().min(10).max(120).default(30),
+    /** Max decomposition depth (default: 2) - prevents infinite nesting */
+    maxDepth: z.number().min(1).max(5).default(2).optional(),
+    /** Max children per workItem (default: 5) - prevents workItem explosion */
+    maxChildrenPerWorkItem: z.number().min(1).max(20).default(5).optional(),
+    /** Daily workItem creation limit (default: 20) - prevents runaway creation */
+    dailyLimit: z.number().min(1).max(100).default(20).optional(),
+    /** Auto-move to backlog if too complex or failing (default: true) */
+    autoBacklog: z.boolean().default(true).optional(),
+    /** Planner model */
+    plannerModel: z.string().default('claude-sonnet-4-5-20250929'),
+    /** Planner timeout (ms) - default 600000 (10min) */
+    plannerTimeoutMs: z.number().min(60000).default(600000),
+}).optional();
+const PipelineStageSchema = z.enum(['coder', 'critic', 'evaluator', 'tester', 'documenter', 'auditor', 'stage-documenter']);
+const JobProfileSchema = z.object({
+    name: z.string().min(1),
+    minMinutes: z.number().min(0).optional(),
+    maxMinutes: z.number().min(0).optional(),
+    priority: z.number().int().min(1).max(4).optional(),
+    roles: z.record(PipelineStageSchema, z.string()).optional(),
+});
+const PaseoDispatchConfigSchema = z.object({
+    cliPath: z.string().default('paseo'),
+    provider: z.string().default('codex/gpt-5.3-codex-spark'),
+    mode: z.string().default('default'),
+    detached: z.boolean().default(true),
+    useWorktree: z.boolean().default(true),
+    baseBranch: z.string().optional(),
+    titlePrefix: z.string().default('Factory'),
+    labels: z.record(z.string(), z.string()).default({}),
+    env: z.record(z.string(), z.string()).default({}),
+}).default({
+    cliPath: 'paseo',
+    provider: 'codex/gpt-5.3-codex-spark',
+    mode: 'default',
+    detached: true,
+    useWorktree: true,
+    titlePrefix: 'Factory',
+    labels: {},
+    env: {},
+});
+const AutonomousConfigSchema = z.object({
+    /** Auto-enable on service start */
+    enabled: z.boolean().default(false),
+    /** Executor/Reviewer pair mode */
+    pairMode: z.boolean().default(true),
+    /** Execution schedule (cron expression) */
+    schedule: z.string().default('*/30 * * * *'),
+    /** Pair mode max attempts */
+    maxAttempts: z.number().min(1).max(10).default(3),
+    /** Allowed project paths */
+    allowedProjects: z.array(z.string()).default(['~/dev']),
+    /** Model configuration (legacy) */
+    models: ModelConfigSchema,
+    /** Executor timeout (ms) - 0 = unlimited (legacy) */
+    executorTimeoutMs: z.number().min(0).default(0),
+    /** Reviewer timeout (ms) - 0 = unlimited (legacy) */
+    reviewerTimeoutMs: z.number().min(0).default(0),
+    /** Max concurrent workItems */
+    maxConcurrentWorkItems: z.number().min(1).max(10).default(1),
+    /** Default stage configuration */
+    defaultStages: DefaultStagesConfigSchema,
+    /** Per-project agent configuration */
+    projectAgents: z.array(ProjectAgentConfigSchema).optional(),
+    /** WorkItem decomposition configuration (Planner Agent) */
+    decomposition: DecompositionConfigSchema,
+    /** Git worktree mode: each workItem runs in isolated worktree */
+    worktreeMode: z.boolean().default(false),
+    /** Dispatch backend for executable workItems. */
+    dispatchBackend: z.enum(['paseo', 'legacy']).default('paseo'),
+    /** Paseo dispatch options. */
+    paseo: PaseoDispatchConfigSchema,
+    /** Dynamic job profiles for model selection */
+    jobProfiles: z.array(JobProfileSchema).optional(),
+    /** Daily workItem completion cap (default: 6) */
+    dailyWorkItemCap: z.number().min(1).max(50).default(6),
+    /** Cooldown between workItem completions in ms (default: 1800000 = 30min) */
+    interWorkItemCooldownMs: z.number().min(0).default(1800000),
+    /** Pipeline guards configuration */
+    guards: z.any().optional(),
+}).optional();
+// Long-Running Monitor schemas
+const CompletionCheckSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('exit-code'), successExitCode: z.number().optional() }),
+    z.object({ type: z.literal('output-regex'), successPattern: z.string(), failurePattern: z.string().optional() }),
+    z.object({ type: z.literal('http-status'), expectedStatus: z.number().optional() }),
+]);
+const LongRunningMonitorConfigSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    checkCommand: z.array(z.string().min(1)).min(1),
+    completionCheck: CompletionCheckSchema,
+    workItemId: z.string().optional(),
+    checkInterval: z.number().min(1).default(1),
+    maxDurationHours: z.number().min(1).default(48),
+    notify: z.boolean().default(true),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+const AzdoSyncConfigSchema = z.object({
+    enabled: z.boolean().default(false),
+    organization: z.string().default('amsterdamdatalabs'),
+    project: z.string().default('Enact'),
+    intervalMs: z.number().positive().default(30000),
+    authStrategy: z.enum(['pat', 'az-cli']).default('az-cli'),
+    patEnvVar: z.string().optional(),
+    areaFilter: z.string().optional(),
+    fieldNames: z.record(z.string(), z.string()).optional(),
+    azdoStateToStatus: z.record(z.string(), WorkItemRecordStatusSchema).optional(),
+    statusToAzdoState: z.record(z.string(), z.string().min(1)).optional(),
+    terminalStates: z.array(z.string().min(1)).optional(),
+}).optional();
+const WorkItemSourceSchema = z.enum(['auto', 'azdo', 'local', 'disabled']).default('auto');
+const LifecycleBooleanSchema = z.object({
+    id: z.string(),
+    label: z.string().optional(),
+    order: z.number().optional(),
+    flippedBy: z.array(z.string()).default([]),
+    source: z.string().optional(),
+});
+const LifecycleSchema = z.object({
+    booleans: z.array(LifecycleBooleanSchema).default([]),
+}).optional();
+const SchedulerSchema = z.object({
+    enabled: z.boolean().default(false),
+    pickNextOperator: z.object({
+        strategy: z.string().default('capability-match'),
+        fallback: z.string().default('ralph'),
+        respectOperatorLaneHint: z.boolean().default(true),
+    }).default({ strategy: 'capability-match', fallback: 'ralph', respectOperatorLaneHint: true }),
+}).optional();
+const DatabaseConfigSchema = z.object({
+    /** Database type: postgres (default) or sqlite */
+    type: z.enum(['sqlite', 'postgres']).default('postgres'),
+    /** PostgreSQL connection string (overrides individual settings) */
+    url: z.string().optional(),
+    /** PostgreSQL host */
+    host: z.string().default('localhost'),
+    /** PostgreSQL port */
+    port: z.number().default(DEFAULT_POSTGRES_PORT),
+    /** PostgreSQL database name */
+    database: z.string().default(DEFAULT_POSTGRES_DATABASE),
+    /** PostgreSQL username */
+    user: z.string().default('enact'),
+    /** PostgreSQL password */
+    password: z.string().default('enact'),
+    /** Schema name (default: public) */
+    schema: z.string().default('public'),
+}).optional();
+const ClosureContractSchema = z.object({
+    required: z.array(z.string()).default([]),
+    optional: z.array(z.string()).default([]),
+    tagOverrides: z.record(z.string(), z.object({
+        addRequired: z.array(z.string()).optional(),
+        removeRequired: z.array(z.string()).optional(),
+    })).optional(),
+});
+const RawConfigSchema = z.object({
+    language: z.enum(['en', 'ko']).default('en'),
+    workItemSource: WorkItemSourceSchema,
+    database: DatabaseConfigSchema,
+    azdo: AzdoConfigSchema,
+    timeWindow: TimeWindowConfigSchema,
+    pairMode: PairModeConfigSchema,
+    autonomous: AutonomousConfigSchema,
+    monitors: z.array(LongRunningMonitorConfigSchema).optional(),
+    projects: z.array(ProjectConfigSchema).default([]),
+    defaultHeartbeatMs: z.number().positive().default(DEFAULT_HEARTBEAT_INTERVAL),
+    azureDevOps: AzdoSyncConfigSchema,
+    closureContracts: z.record(z.string(), ClosureContractSchema).optional(),
+    lifecycle: LifecycleSchema,
+    scheduler: SchedulerSchema,
+});
+const LIFECYCLE_RUNTIME_STAGE_IDS = [
+    'coder',
+    'critic',
+    'tester',
+    'documenter',
+    'auditor',
+    'stage-documenter',
+];
+// Environment Variable Substitution
+/**
+ * Environment variable pattern: ${VAR_NAME} or ${VAR_NAME:-default}
+ */
+const ENV_VAR_PATTERN = /\$\{([^}:]+)(?::-([^}]*))?\}/g;
+/**
+ * Substitute environment variables in string
+ */
+function substituteEnvVars(value) {
+    return value.replace(ENV_VAR_PATTERN, (match, varName, defaultValue) => {
+        const envValue = process.env[varName];
+        if (envValue !== undefined) {
+            return envValue;
+        }
+        if (defaultValue !== undefined) {
+            return defaultValue;
+        }
+        // Return empty string if no env var and no default value
+        console.warn(`Environment variable ${varName} is not set`);
+        return '';
+    });
+}
+/**
+ * Apply environment variable substitution to all strings in an object
+ */
+function substituteEnvVarsDeep(obj) {
+    if (typeof obj === 'string') {
+        return substituteEnvVars(obj);
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(substituteEnvVarsDeep);
+    }
+    if (obj !== null && typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            result[key] = substituteEnvVarsDeep(value);
+        }
+        return result;
+    }
+    return obj;
+}
+/**
+ * Expand path (~/ handling)
+ */
+export function expandPath(path, resolveRelative = false) {
+    if (path.startsWith('~/')) {
+        return join(homedir(), path.slice(2));
+    }
+    if (resolveRelative) {
+        const { resolve } = require('node:path');
+        return resolve(path);
+    }
+    return path;
+}
+// Config Loading
+/**
+ * Find configuration file.
+ *
+ * Resolution order:
+ *   1. ../../config.toml                  (canonical enact-os root config)
+ *   2. ./config.toml                      (cwd fallback)
+ *   3. ~/.enact/factory/config.toml          (canonical factory home — searched first via getConfigSearchDirs)
+ *   4. ~/.config/enact-factory/config.toml  (legacy XDG path — no longer searched; kept here for migration reference)
+ *   5. ~/.enact-factory/config.toml         (legacy home path — no longer searched; kept here for migration reference)
+ */
+function findConfigFile() {
+    for (const path of getConfigSearchPaths()) {
+        if (existsSync(path)) {
+            return path;
+        }
+    }
+    return null;
+}
+/**
+ * Parse configuration file
+ */
+function parseConfigFile(path) {
+    const content = readFileSync(path, 'utf-8');
+    if (path.endsWith('.toml')) {
+        const parsed = TOML.parse(content);
+        if (parsed.factory && typeof parsed.factory === 'object' && !Array.isArray(parsed.factory)) {
+            return parsed.factory;
+        }
+        return parsed;
+    }
+    if (path.endsWith('.json')) {
+        return JSON.parse(content);
+    }
+    // YAML parsing
+    return YAML.parse(content);
+}
+function validateLifecycleStageConfig(configPath, stageId, stageConfig, fallbackProvider) {
+    if (!stageConfig) {
+        return [];
+    }
+    const result = validateRuntimeStageConfig(stageId, stageConfig, fallbackProvider);
+    if ('errors' in result) {
+        return result.errors.map((error) => `${configPath}.${error.field}: ${error.message}`);
+    }
+    return [];
+}
+function collectLifecycleStageValidationErrors(config) {
+    const errors = [];
+    const fallbackProvider = 'claude';
+    const defaultStages = config.autonomous?.defaultStages;
+    if (defaultStages) {
+        for (const stageId of LIFECYCLE_RUNTIME_STAGE_IDS) {
+            const stageConfig = defaultStages[stageId];
+            errors.push(...validateLifecycleStageConfig(`autonomous.defaultStages.${stageId}`, stageId, stageConfig, fallbackProvider));
+        }
+    }
+    config.autonomous?.projectAgents?.forEach((projectAgent, index) => {
+        for (const stageId of LIFECYCLE_RUNTIME_STAGE_IDS) {
+            const stageConfig = projectAgent.stages?.[stageId];
+            errors.push(...validateLifecycleStageConfig(`autonomous.projectAgents[${index}].stages.${stageId}`, stageId, stageConfig, fallbackProvider));
+        }
+    });
+    return errors;
+}
+/**
+ * Transform raw config to FactoryConfig
+ */
+function transformConfig(raw) {
+    return {
+        language: raw.language,
+        workItemSource: raw.workItemSource,
+        database: raw.database ? {
+            type: raw.database.type,
+            url: raw.database.url,
+            host: raw.database.host,
+            port: raw.database.port,
+            database: raw.database.database,
+            user: raw.database.user,
+            password: raw.database.password,
+            schema: raw.database.schema,
+        } : { type: 'postgres' },
+        azdoApiKey: raw.azdo?.apiKey ?? '',
+        azdoTeamId: raw.azdo?.teamId ?? '',
+        projects: raw.projects.map(project => ({
+            ...project,
+            path: expandPath(project.path),
+            heartbeatMs: project.heartbeatMs ?? raw.defaultHeartbeatMs,
+            azdoLabel: project.azdoLabel ?? project.name,
+        })),
+        defaultHeartbeatMs: raw.defaultHeartbeatMs,
+        timeWindow: raw.timeWindow ? {
+            enabled: raw.timeWindow.enabled,
+            allowedWindows: raw.timeWindow.allowedWindows,
+            blockedWindows: raw.timeWindow.blockedWindows,
+            restrictedDays: raw.timeWindow.restrictedDays,
+            timezone: raw.timeWindow.timezone,
+        } : undefined,
+        pairMode: raw.pairMode ? {
+            enabled: raw.pairMode.enabled,
+            maxAttempts: raw.pairMode.maxAttempts,
+            executorTimeoutMs: raw.pairMode.executorTimeoutMs,
+            reviewerTimeoutMs: raw.pairMode.reviewerTimeoutMs,
+            webhookUrl: raw.pairMode.webhookUrl,
+            autoAzdoUpdate: raw.pairMode.autoAzdoUpdate,
+        } : undefined,
+        autonomous: raw.autonomous ? {
+            enabled: raw.autonomous.enabled,
+            pairMode: raw.autonomous.pairMode,
+            schedule: raw.autonomous.schedule,
+            maxAttempts: raw.autonomous.maxAttempts,
+            allowedProjects: raw.autonomous.allowedProjects.map((path) => expandPath(path)),
+            models: raw.autonomous.models ? {
+                executor: raw.autonomous.models.executor,
+                reviewer: raw.autonomous.models.reviewer,
+            } : undefined,
+            executorTimeoutMs: raw.autonomous.executorTimeoutMs,
+            reviewerTimeoutMs: raw.autonomous.reviewerTimeoutMs,
+            maxConcurrentWorkItems: raw.autonomous.maxConcurrentWorkItems,
+            defaultStages: raw.autonomous.defaultStages,
+            projectAgents: raw.autonomous.projectAgents?.map(pa => ({
+                ...pa,
+                path: expandPath(pa.path),
+            })),
+            decomposition: raw.autonomous.decomposition ? {
+                enabled: raw.autonomous.decomposition.enabled,
+                thresholdMinutes: raw.autonomous.decomposition.thresholdMinutes,
+                maxDepth: raw.autonomous.decomposition.maxDepth ?? 2,
+                maxChildrenPerWorkItem: raw.autonomous.decomposition.maxChildrenPerWorkItem ?? 5,
+                dailyLimit: raw.autonomous.decomposition.dailyLimit ?? 20,
+                autoBacklog: raw.autonomous.decomposition.autoBacklog ?? true,
+                plannerModel: raw.autonomous.decomposition.plannerModel,
+                plannerTimeoutMs: raw.autonomous.decomposition.plannerTimeoutMs,
+            } : undefined,
+            worktreeMode: raw.autonomous.worktreeMode,
+            dispatchBackend: raw.autonomous.dispatchBackend,
+            paseo: raw.autonomous.paseo,
+            dailyWorkItemCap: raw.autonomous.dailyWorkItemCap,
+            interWorkItemCooldownMs: raw.autonomous.interWorkItemCooldownMs,
+            jobProfiles: raw.autonomous.jobProfiles,
+            guards: raw.autonomous.guards,
+        } : undefined,
+        monitors: raw.monitors,
+        azureDevOps: raw.azureDevOps ? {
+            enabled: raw.azureDevOps.enabled,
+            organization: raw.azureDevOps.organization,
+            project: raw.azureDevOps.project,
+            intervalMs: raw.azureDevOps.intervalMs,
+            authStrategy: raw.azureDevOps.authStrategy,
+            patEnvVar: raw.azureDevOps.patEnvVar,
+            areaFilter: raw.azureDevOps.areaFilter,
+            fieldNames: raw.azureDevOps.fieldNames,
+        } : undefined,
+        closureContracts: raw.closureContracts,
+        lifecycle: raw.lifecycle,
+        scheduler: raw.scheduler,
+    };
+}
+/**
+ * Load config (env var substitution + Zod validation)
+ */
+function extractFactorySection(merged) {
+    const factory = merged.factory;
+    if (factory && typeof factory === 'object' && !Array.isArray(factory)) {
+        return factory;
+    }
+    return merged;
+}
+export function loadConfig(customPath) {
+    let rawData;
+    let configLabel;
+    if (customPath) {
+        configLabel = customPath;
+        try {
+            rawData = parseConfigFile(customPath);
+        }
+        catch (err) {
+            throw new Error(`Failed to parse config file: ${err}`);
+        }
+    }
+    else {
+        const merged = readWorkspaceRootConfig();
+        if (!merged) {
+            const searched = getConfigSearchPaths().map((p) => `  - ${p}`).join('\n');
+            throw new Error(`Config file not found. Searched:\n${searched}\n` +
+                `Create the canonical enact-os config.toml.`);
+        }
+        const workspacePath = getWorkspaceConfigPath();
+        configLabel = workspacePath
+            ? `merged (global + ${workspacePath})`
+            : `merged (global ~/.enact/config.toml)`;
+        rawData = extractFactorySection(merged);
+    }
+    console.log(`Loading config from: ${configLabel}`);
+    // 3. Substitute environment variables
+    const substituted = substituteEnvVarsDeep(rawData);
+    // 4. Key migrations (deprecated keys → new keys)
+    let migrated = { ...substituted };
+    // autonomous.defaultRoles → autonomous.defaultStages
+    const auto = migrated.autonomous;
+    if (auto && 'defaultRoles' in auto && !('defaultStages' in auto)) {
+        console.warn('[Config] "autonomous.defaultRoles:" is deprecated — use "autonomous.defaultStages:" instead.');
+        auto.defaultStages = auto.defaultRoles;
+        delete auto.defaultRoles;
+    }
+    // Stage key migrations within defaultStages
+    const stages = auto?.defaultStages;
+    if (stages) {
+        if ('executor' in stages && !('coder' in stages)) {
+            console.warn('[Config] Stage key "executor" is deprecated — use "coder" instead.');
+            stages.coder = stages.executor;
+            delete stages.executor;
+        }
+        if ('reviewer' in stages && !('critic' in stages)) {
+            console.warn('[Config] Stage key "reviewer" is deprecated — use "critic" instead.');
+            stages.critic = stages.reviewer;
+            delete stages.reviewer;
+        }
+        if ('skill-documenter' in stages && !('stage-documenter' in stages)) {
+            console.warn('[Config] Stage key "skill-documenter" is deprecated — use "stage-documenter" instead.');
+            stages['stage-documenter'] = stages['skill-documenter'];
+            delete stages['skill-documenter'];
+        }
+    }
+    // Job profile role key migrations
+    const profiles = auto?.jobProfiles;
+    if (profiles) {
+        for (const profile of profiles) {
+            const roles = profile.roles;
+            if (roles) {
+                if ('executor' in roles && !('coder' in roles)) {
+                    roles.coder = roles.executor;
+                    delete roles.executor;
+                }
+                if ('reviewer' in roles && !('critic' in roles)) {
+                    roles.critic = roles.reviewer;
+                    delete roles.reviewer;
+                }
+                if ('skill-documenter' in roles && !('stage-documenter' in roles)) {
+                    roles['stage-documenter'] = roles['skill-documenter'];
+                    delete roles['skill-documenter'];
+                }
+            }
+        }
+    }
+    // 5. Zod schema validation
+    const parseResult = RawConfigSchema.safeParse(migrated);
+    if (!parseResult.success) {
+        const errors = parseResult.error.issues
+            .map((e) => `  - ${e.path.join('.')}: ${e.message}`)
+            .join('\n');
+        throw new Error(`Config validation failed:\n${errors}`);
+    }
+    // 5. Transform to FactoryConfig
+    const config = transformConfig(parseResult.data);
+    // 6. Apply time window config
+    if (config.timeWindow) {
+        setTimeWindowConfig(config.timeWindow);
+        console.log(`[Config] TimeWindow config loaded (enabled: ${config.timeWindow.enabled})`);
+    }
+    else {
+        setTimeWindowConfig(DEFAULT_TIME_WINDOW);
+        console.log(`[Config] Using default TimeWindow config`);
+    }
+    return config;
+}
+/**
+ * Validate config (supplementary checks beyond Zod validation)
+ */
+export function validateBootstrapConfig(config) {
+    const errors = [];
+    // Verify agent project paths exist
+    for (const project of config.projects) {
+        if (!existsSync(project.path)) {
+            errors.push(`Project "${project.name}" path does not exist: ${project.path}`);
+        }
+    }
+    if (config.autonomous?.allowedProjects) {
+        for (const projectPath of config.autonomous.allowedProjects) {
+            if (!existsSync(projectPath)) {
+                errors.push(`Autonomous allowed project path does not exist: ${projectPath}`);
+            }
+        }
+    }
+    if (config.autonomous?.projectAgents) {
+        for (const projectAgent of config.autonomous.projectAgents) {
+            if (!existsSync(projectAgent.path)) {
+                errors.push(`Autonomous project agent path does not exist: ${projectAgent.path}`);
+            }
+        }
+    }
+    errors.push(...collectLifecycleStageValidationErrors(config));
+    errors.push(...validateAzdoStateMapConfig(config.azureDevOps));
+    if (config.autonomous?.worktreeMode) {
+        if (config.autonomous.defaultStages?.coder?.enabled === false) {
+            console.warn('⚠️ Coder stage is disabled — pipeline will not generate code.');
+        }
+        if (config.autonomous.defaultStages?.critic?.enabled === false) {
+            errors.push('autonomous.worktreeMode requires the reviewer stage to remain enabled');
+        }
+        config.autonomous.projectAgents?.forEach((projectAgent, index) => {
+            if (projectAgent.stages?.coder?.enabled === false) {
+                errors.push(`autonomous.projectAgents[${index}].stages.coder must remain enabled when worktreeMode is on`);
+            }
+            if (projectAgent.stages?.critic?.enabled === false) {
+                errors.push(`autonomous.projectAgents[${index}].stages.critic must remain enabled when worktreeMode is on`);
+            }
+        });
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Validate resolved runtime config, including canonical registered-project paths.
+ */
+export function validateConfig(config) {
+    const base = validateBootstrapConfig(config);
+    const errors = [...base.errors];
+    for (const project of config.projects) {
+        if (!existsSync(project.path)) {
+            errors.push(`Project "${project.name}" path does not exist: ${project.path}`);
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Create a default project config
+ */
+export function createProjectConfig(name, path, options) {
+    return {
+        name,
+        path: expandPath(path),
+        heartbeatMs: options?.heartbeatMs ?? DEFAULT_HEARTBEAT_INTERVAL,
+        azdoLabel: options?.azdoLabel ?? name,
+        enabled: options?.enabled ?? true,
+        paused: options?.paused ?? false,
+    };
+}
+/**
+ * Generate a sample configuration file
+ */
+export function generateSampleConfig() {
+    return `# Root enact-os config.toml excerpt for enact-factory
+# Merge this into the single canonical config.toml at the enact-os root.
+
+[factory]
+# Single canonical UI port for the dashboard (43206 dev / 53206 prod).
+# Both \`enact-factory dash\` and \`start\` serve the SAME dashboard here.
+# \`dash_port\` is retired; new configs write only \`port\`.
+port = 43206
+node_env = "development"
+language = "en"
+workItemSource = "auto"
+defaultHeartbeatMs = 1800000
+storage = ".enact/factory"
+
+[factory.database]
+type = "postgres"
+host = "localhost"
+port = 45432
+database = "enact_factory_dev"
+user = "enact"
+password = "enact"
+schema = "public"
+
+# Registered repositories are stored in Postgres (\`projects\` table).
+# A legacy [[factory.projects]] list is only used one time to seed that table
+# when it is empty.
+
+[factory.autonomous]
+dispatchBackend = "paseo"
+
+[factory.autonomous.paseo]
+cliPath = "paseo"
+provider = "codex/gpt-5.3-codex-spark"
+mode = "default"
+detached = true
+useWorktree = true
+titlePrefix = "Factory"
+`;
+}
+//# sourceMappingURL=config.js.map