@diff-review-system/drs 3.3.1 → 4.0.1

package/dist/lib/config.js

@@ -1,8 +1,51 @@
-import { readFileSync, existsSync } from 'fs';
-import { resolve } from 'path';
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { basename, extname, join, resolve } from 'path';
 import * as yaml from 'yaml';
+import { requireAgentId } from './agent-id.js';
+import { getBuiltInWorkflowPaths } from '../runtime/built-in-paths.js';
+// Canonical list of supported workflow actions. WorkflowNodeConfig['action']
+// derives its union from this tuple so the schema and the load-time validator
+// can never drift. Keep both this tuple and the validator in lockstep.
+export const SUPPORTED_WORKFLOW_ACTIONS = [
+    'write',
+    'git-diff',
+    'git-add',
+    'git-branch',
+    'git-commit',
+    'git-push',
+    'has-diff',
+    'stack-guard',
+    'review-threshold',
+    'save-artifact',
+    'load-artifact',
+    'artifact-exists',
+    'create-review-artifact',
+    'review-artifact-status',
+    'review-artifact-add-finding',
+    'review-artifact-update-findings',
+    'verify-fix',
+    'review-artifact-promote-finding',
+    'review-artifact-resolve-finding',
+    'create-change-request',
+    'create-pr',
+    'create-mr',
+    'change-source',
+    'review',
+    'review-context',
+    'describe',
+    'code-quality-report',
+    'post-comment',
+    'post-review-comments',
+    'post-fix-status',
+];
 const DEFAULT_CONFIG = {
     pi: {},
+    agents: {
+        default: {
+            model: getDefaultModelEnv() ?? 'anthropic/claude-sonnet-4-5-20250929',
+            skills: [],
+        },
+    },
     gitlab: {
         url: process.env.GITLAB_URL ?? 'https://gitlab.com',
         token: process.env.GITLAB_TOKEN ?? '',
@@ -11,11 +54,7 @@ const DEFAULT_CONFIG = {
         token: process.env.GITHUB_TOKEN ?? '',
     },
     review: {
-        agents: ['security', 'quality', 'style', 'performance', 'documentation'],
-        default: {
-            model: process.env.REVIEW_DEFAULT_MODEL ?? 'anthropic/claude-sonnet-4-5-20250929',
-            skills: [],
-        },
+        agents: ['review/unified-reviewer'],
         ignorePatterns: [
             '*.test.ts',
             '*.spec.ts',
@@ -27,12 +66,10 @@ const DEFAULT_CONFIG = {
         ],
         describe: {
             enabled: false,
-            postDescription: false,
         },
         cursorFixLinks: {
             enabled: false,
         },
-        postErrorComment: false,
     },
     contextCompression: {
         enabled: true,
@@ -41,32 +78,254 @@ const DEFAULT_CONFIG = {
         softBufferTokens: 1500,
         hardBufferTokens: 1000,
         tokenEstimateDivisor: 4,
+        summaryThresholdMultiplier: 3,
     },
     describe: {
         includeProjectContext: true,
     },
 };
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isWorkflowFileName(fileName) {
+    return fileName.endsWith('.yaml') || fileName.endsWith('.yml');
+}
+const SUPPORTED_ACTION_SET = new Set(SUPPORTED_WORKFLOW_ACTIONS);
+function levenshteinDistance(a, b) {
+    if (a === b)
+        return 0;
+    if (a.length === 0)
+        return b.length;
+    if (b.length === 0)
+        return a.length;
+    let previous = new Array(b.length + 1);
+    let current = new Array(b.length + 1);
+    for (let j = 0; j <= b.length; j++)
+        previous[j] = j;
+    for (let i = 1; i <= a.length; i++) {
+        current[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a.charCodeAt(i - 1) === b.charCodeAt(j - 1) ? 0 : 1;
+            current[j] = Math.min(current[j - 1] + 1, previous[j] + 1, previous[j - 1] + cost);
+        }
+        const tmp = previous;
+        previous = current;
+        current = tmp;
+    }
+    return previous[b.length];
+}
+function findClosestSupportedAction(input) {
+    let best;
+    let bestDistance = Infinity;
+    // Cap at two edits so we never suggest a long action for a shorter typo.
+    const threshold = 2;
+    for (const supported of SUPPORTED_WORKFLOW_ACTIONS) {
+        const distance = levenshteinDistance(input, supported);
+        if (distance < bestDistance && distance <= threshold) {
+            best = supported;
+            bestDistance = distance;
+        }
+    }
+    return best;
+}
+/**
+ * Validate every node's `action` value in a workflow against
+ * SUPPORTED_WORKFLOW_ACTIONS. Throws with a did-you-mean hint on failure:
+ *   - Near-miss typos get the closest supported action via Levenshtein.
+ *   - Wholly unknown actions get a list of every supported action.
+ *
+ * Called from validateWorkflowDefinition so misconfigured YAML fails fast at
+ * config-load time instead of partway through wave execution.
+ */
+export function validateWorkflowActions(workflowName, nodes) {
+    for (const [nodeId, node] of Object.entries(nodes)) {
+        const action = node.action;
+        if (typeof action !== 'string')
+            continue;
+        if (SUPPORTED_ACTION_SET.has(action))
+            continue;
+        let hint;
+        const closest = findClosestSupportedAction(action);
+        if (closest) {
+            hint = "Did you mean '" + closest + "'?";
+        }
+        else {
+            hint = 'Supported actions: ' + SUPPORTED_WORKFLOW_ACTIONS.join(', ') + '.';
+        }
+        throw new Error('Workflow "' +
+            workflowName +
+            '" node "' +
+            nodeId +
+            '" has unsupported action "' +
+            action +
+            '". ' +
+            hint);
+    }
+}
+function validateWorkflowInputs(workflowName, inputs) {
+    if (inputs === undefined)
+        return;
+    if (!isRecord(inputs)) {
+        throw new Error(`Workflow "${workflowName}" inputs must be an object.`);
+    }
+    for (const [inputName, input] of Object.entries(inputs)) {
+        if (typeof input === 'string')
+            continue;
+        if (!isRecord(input)) {
+            throw new Error(`Workflow "${workflowName}" input "${inputName}" must be a string or object.`);
+        }
+        const allowed = new Set([
+            'type',
+            'value',
+            'file',
+            'default',
+            'required',
+            'values',
+            'description',
+        ]);
+        const unknown = Object.keys(input).filter((key) => !allowed.has(key));
+        if (unknown.length > 0) {
+            throw new Error(`Workflow "${workflowName}" input "${inputName}" has unsupported field(s): ${unknown.join(', ')}.`);
+        }
+        const rawType = input.type;
+        if (rawType !== undefined && typeof rawType !== 'string') {
+            throw new Error(`Workflow "${workflowName}" input "${inputName}" type must be a string.`);
+        }
+        const type = rawType ?? 'string';
+        if (!['string', 'boolean', 'number', 'enum'].includes(type)) {
+            throw new Error(`Workflow "${workflowName}" input "${inputName}" has unsupported type "${type}".`);
+        }
+        if (input.file !== undefined && (input.value !== undefined || input.default !== undefined)) {
+            throw new Error(`Workflow "${workflowName}" input "${inputName}" cannot define file with value/default.`);
+        }
+        if (input.required !== undefined && typeof input.required !== 'boolean') {
+            throw new Error(`Workflow "${workflowName}" input "${inputName}" required must be boolean.`);
+        }
+        if (input.description !== undefined && typeof input.description !== 'string') {
+            throw new Error(`Workflow "${workflowName}" input "${inputName}" description must be string.`);
+        }
+        if (type === 'enum' && (!Array.isArray(input.values) || input.values.length === 0)) {
+            throw new Error(`Workflow "${workflowName}" input "${inputName}" type enum must define values.`);
+        }
+    }
+}
+function validateWorkflowDefinition(workflowName, workflow, sourcePath) {
+    if (!isRecord(workflow) || !isRecord(workflow.nodes)) {
+        throw new Error(`Workflow "${workflowName}" in ${sourcePath} must define a nodes object.`);
+    }
+    const typed = workflow;
+    validateWorkflowInputs(workflowName, typed.inputs);
+    validateWorkflowActions(workflowName, typed.nodes);
+    return typed;
+}
+function loadWorkflowFile(filePath) {
+    const parsed = yaml.parse(readFileSync(filePath, 'utf-8')) ?? {};
+    if (!isRecord(parsed)) {
+        throw new Error(`Workflow file ${filePath} must contain a YAML object.`);
+    }
+    if (parsed.workflows !== undefined) {
+        throw new Error(`Workflow file ${filePath} must define one workflow directly.`);
+    }
+    const workflowName = parsed.name === undefined ? basename(filePath, extname(filePath)) : parsed.name;
+    if (typeof workflowName !== 'string' || !workflowName.trim()) {
+        throw new Error(`Workflow file ${filePath} must use a non-empty string name.`);
+    }
+    const workflow = { ...parsed };
+    delete workflow.name;
+    return {
+        [workflowName.trim()]: validateWorkflowDefinition(workflowName.trim(), workflow, filePath),
+    };
+}
+function loadWorkflowFilesFromDirectory(directoryPath, source) {
+    if (!existsSync(directoryPath)) {
+        return { workflows: {}, sources: {} };
+    }
+    if (!statSync(directoryPath).isDirectory()) {
+        throw new Error(`Workflow path ${directoryPath} exists but is not a directory.`);
+    }
+    const workflows = {};
+    const sources = {};
+    for (const fileName of readdirSync(directoryPath).filter(isWorkflowFileName).sort()) {
+        const fileWorkflows = loadWorkflowFile(join(directoryPath, fileName));
+        for (const workflowName of Object.keys(fileWorkflows)) {
+            sources[workflowName] = source;
+        }
+        Object.assign(workflows, fileWorkflows);
+    }
+    return { workflows, sources };
+}
+function loadBuiltInWorkflowFiles() {
+    const result = {
+        workflows: {},
+        sources: {},
+    };
+    for (const directory of getBuiltInWorkflowPaths()) {
+        const loaded = loadWorkflowFilesFromDirectory(directory, 'packaged');
+        Object.assign(result.workflows, loaded.workflows);
+        Object.assign(result.sources, loaded.sources);
+    }
+    return result;
+}
+/**
+ * Load map of workflow names to their source origin (packaged or project).
+ */
+export function loadWorkflowSources(projectPath) {
+    const basePath = projectPath ?? process.cwd();
+    const builtIn = loadBuiltInWorkflowFiles();
+    const project = loadWorkflowFilesFromDirectory(resolve(basePath, '.drs/workflows'), 'project');
+    // Project workflows take precedence, so they override packaged sources.
+    return { ...builtIn.sources, ...project.sources };
+}
+/**
+ * Load map of workflow names to their source origin, including whether
+ * a project workflow is overriding an existing packaged workflow.
+ */
+export function loadWorkflowSourceInfo(projectPath) {
+    const basePath = projectPath ?? process.cwd();
+    const builtIn = loadBuiltInWorkflowFiles();
+    const project = loadWorkflowFilesFromDirectory(resolve(basePath, '.drs/workflows'), 'project');
+    const info = {};
+    for (const name of Object.keys(builtIn.sources)) {
+        info[name] = { source: 'packaged', overridesPackaged: false };
+    }
+    for (const name of Object.keys(project.sources)) {
+        info[name] = { source: 'project', overridesPackaged: name in builtIn.sources };
+    }
+    return info;
+}
 /**
  * Load configuration from various sources with precedence:
- * 1. CLI arguments (passed as overrides)
- * 2. Environment variables
- * 3. .drs/drs.config.yaml or .drs/drs.config.json
- * 4. .gitlab-review.yml
- * 5. Default values
+ * 1. Default values
+ * 2. Built-in workflow files
+ * 3. .drs/workflows/*.yaml
+ * 4. .drs/drs.config.yaml
+ * 5. .gitlab-review.yml
+ * 6. Environment variables
+ * 7. CLI arguments (passed as overrides)
  */
 export function loadConfig(projectPath, overrides) {
     const basePath = projectPath ?? process.cwd();
-    let config = { ...DEFAULT_CONFIG };
+    const builtIn = loadBuiltInWorkflowFiles();
+    let config = mergeConfig({ ...DEFAULT_CONFIG }, { workflows: builtIn.workflows });
+    const projectWorkflowPath = resolve(basePath, '.drs/workflows');
+    const project = loadWorkflowFilesFromDirectory(projectWorkflowPath, 'project');
+    config = mergeConfig(config, { workflows: project.workflows });
     // Try loading from .drs/drs.config.yaml
     const drsConfigPath = resolve(basePath, '.drs/drs.config.yaml');
     if (existsSync(drsConfigPath)) {
-        const fileConfig = yaml.parse(readFileSync(drsConfigPath, 'utf-8'));
+        const fileConfig = yaml.parse(readFileSync(drsConfigPath, 'utf-8')) ?? {};
+        rejectLegacyAgentConfigKeys(fileConfig, drsConfigPath);
+        rejectRemovedReviewPostingConfigKeys(fileConfig, drsConfigPath);
+        rejectInlineWorkflowConfig(fileConfig, drsConfigPath);
         config = mergeConfig(config, fileConfig);
     }
     // Try loading from .gitlab-review.yml
     const gitlabReviewPath = resolve(basePath, '.gitlab-review.yml');
     if (existsSync(gitlabReviewPath)) {
-        const fileConfig = yaml.parse(readFileSync(gitlabReviewPath, 'utf-8'));
+        const fileConfig = yaml.parse(readFileSync(gitlabReviewPath, 'utf-8')) ?? {};
+        rejectLegacyAgentConfigKeys(fileConfig, gitlabReviewPath);
+        rejectRemovedReviewPostingConfigKeys(fileConfig, gitlabReviewPath);
+        rejectInlineWorkflowConfig(fileConfig, gitlabReviewPath);
         config = mergeConfig(config, fileConfig);
     }
     // Apply environment variable overrides
@@ -83,31 +342,20 @@ export function loadConfig(projectPath, overrides) {
         // Environment variable is always simple string format (comma-separated)
         config.review.agents = process.env.REVIEW_AGENTS.split(',').map((a) => a.trim());
     }
-    if (process.env.REVIEW_DEFAULT_MODEL) {
-        config.review.defaultModel = process.env.REVIEW_DEFAULT_MODEL;
-        config.review.default = mergeSection(config.review.default, {
-            model: process.env.REVIEW_DEFAULT_MODEL,
+    const defaultModelEnv = getDefaultModelEnv();
+    if (defaultModelEnv) {
+        config.agents.default = mergeSection(config.agents.default, {
+            model: defaultModelEnv,
         });
     }
-    if (process.env.REVIEW_MODE) {
-        console.warn('⚠ REVIEW_MODE is deprecated. Configure review.agents explicitly (include unified-reviewer when needed).');
-        config.review.mode = process.env.REVIEW_MODE;
-    }
     if (process.env.REVIEW_UNIFIED_MODEL) {
         config.review.unified = {
             ...config.review.unified,
             model: process.env.REVIEW_UNIFIED_MODEL,
         };
     }
-    if (process.env.REVIEW_UNIFIED_THRESHOLD) {
-        console.warn('⚠ REVIEW_UNIFIED_THRESHOLD is deprecated and ignored by the agents-first pipeline.');
-        config.review.unified = {
-            ...config.review.unified,
-            severityThreshold: process.env.REVIEW_UNIFIED_THRESHOLD,
-        };
-    }
     if (process.env.REVIEW_THINKING_LEVEL) {
-        config.review.default = mergeSection(config.review.default, {
+        config.agents.default = mergeSection(config.agents.default, {
             thinkingLevel: process.env.REVIEW_THINKING_LEVEL,
         });
     }
@@ -117,29 +365,56 @@ export function loadConfig(projectPath, overrides) {
     if (process.env.REVIEW_SKIP_BRANCH_CHECK === 'true') {
         config.review.skipBranchCheck = true;
     }
-    if (process.env.REVIEW_POST_ERROR_COMMENT === 'true') {
-        config.review.postErrorComment = true;
-    }
     // Validate required fields
     if (!getDefaultModel(config)) {
-        throw new Error('Default model is required. Set review.default.model or defaultModel in .drs/drs.config.yaml or REVIEW_DEFAULT_MODEL environment variable.\n' +
+        throw new Error('Default model is required. Set agents.default.model in .drs/drs.config.yaml or DRS_DEFAULT_MODEL environment variable.\n' +
             'Run "drs init" to configure your project.');
     }
     // Apply CLI overrides
     if (overrides) {
         config = mergeConfig(config, overrides);
     }
-    if (config.review.mode) {
-        console.warn('⚠ review.mode is deprecated. Configure review.agents explicitly (include unified-reviewer when needed).');
-        const validModes = ['multi-agent', 'unified', 'hybrid'];
-        if (!validModes.includes(config.review.mode)) {
-            throw new Error(`Invalid review mode "${config.review.mode}". Valid options: ${validModes.join(', ')}`);
-        }
+    return normalizeRuntimeConfig(config);
+}
+function rejectLegacyAgentConfigKeys(fileConfig, sourcePath) {
+    const reviewConfig = fileConfig.review;
+    if (!reviewConfig || typeof reviewConfig !== 'object') {
+        return;
+    }
+    const migrations = [];
+    if ('default' in reviewConfig)
+        migrations.push('review.default -> agents.default');
+    if ('defaultModel' in reviewConfig)
+        migrations.push('review.defaultModel -> agents.default.model');
+    if ('paths' in reviewConfig)
+        migrations.push('review.paths -> agents.paths');
+    if (migrations.length > 0) {
+        throw new Error(`Config file ${sourcePath} uses legacy DRS 3.x agent config keys: ${migrations.join(', ')}. ` +
+            'DRS 4.0 requires top-level agent configuration. Move model/skill defaults to agents.default and custom paths to agents.paths.');
     }
-    if (config.review.unified?.severityThreshold) {
-        console.warn('⚠ review.unified.severityThreshold is deprecated and ignored by the agents-first pipeline.');
+}
+function rejectInlineWorkflowConfig(fileConfig, sourcePath) {
+    if (!isRecord(fileConfig) || fileConfig.workflows === undefined) {
+        return;
+    }
+    throw new Error(`Config file ${sourcePath} cannot define top-level workflows.`);
+}
+function rejectRemovedReviewPostingConfigKeys(fileConfig, sourcePath) {
+    if (!isRecord(fileConfig) || !isRecord(fileConfig.review)) {
+        return;
+    }
+    const removedKeys = [];
+    if (Object.prototype.hasOwnProperty.call(fileConfig.review, 'postErrorComment')) {
+        removedKeys.push('review.postErrorComment');
+    }
+    if (isRecord(fileConfig.review.describe) &&
+        Object.prototype.hasOwnProperty.call(fileConfig.review.describe, 'postDescription')) {
+        removedKeys.push('review.describe.postDescription');
+    }
+    if (removedKeys.length > 0) {
+        throw new Error(`Config file ${sourcePath} uses removed DRS 4.0 review posting keys: ${removedKeys.join(', ')}. ` +
+            'Run posting explicitly with workflows, or use github-pr-describe/gitlab-mr-describe with post=true when updating PR/MR descriptions.');
     }
-    return normalizeRuntimeConfig(config);
 }
 /**
  * Deep merge two config objects, skipping undefined values
@@ -148,12 +423,16 @@ function mergeConfig(base, override) {
     return {
         pi: mergeSection(base.pi, override.pi),
         opencode: mergeSection(base.opencode, override.opencode),
+        agents: mergeSection(base.agents, override.agents),
+        workflows: mergeSection(base.workflows, override.workflows),
+        workflow: mergeSection(base.workflow, override.workflow),
         gitlab: mergeSection(base.gitlab, override.gitlab),
         github: mergeSection(base.github, override.github),
         review: mergeSection(base.review, override.review),
         describe: mergeSection(base.describe, override.describe),
         contextCompression: mergeSection(base.contextCompression, override.contextCompression),
         pricing: mergeSection(base.pricing, override.pricing),
+        fix: mergeSection(base.fix, override.fix),
     };
 }
 function normalizeRuntimeConfig(config) {
@@ -168,8 +447,24 @@ function normalizeRuntimeConfig(config) {
         ...(legacyRuntime.provider ?? {}),
         ...(piRuntime.provider ?? {}),
     };
+    const mergedRuntimeTimeouts = {
+        ...(legacyRuntime.runtime ?? {}),
+        ...(piRuntime.runtime ?? {}),
+    };
+    const legacyProviderRetry = legacyRuntime.retry?.provider;
+    const piProviderRetry = piRuntime.retry?.provider;
+    const mergedProviderRetry = {
+        ...(legacyProviderRetry ?? {}),
+        ...(piProviderRetry ?? {}),
+    };
     const normalizedRuntime = {
         provider: Object.keys(mergedProvider).length > 0 ? mergedProvider : undefined,
+        runtime: Object.keys(mergedRuntimeTimeouts).length > 0 ? mergedRuntimeTimeouts : undefined,
+        retry: Object.keys(mergedProviderRetry).length > 0
+            ? {
+                provider: mergedProviderRetry,
+            }
+            : undefined,
     };
     return {
         ...config,
@@ -191,7 +486,6 @@ function mergeSection(base, override) {
     for (const key in override) {
         const value = override[key];
         if (value !== undefined) {
-            // TypeScript knows that value is T[Extract<keyof T, string>] which is assignable to T[keyof T]
             result[key] = value;
         }
     }
@@ -208,11 +502,11 @@ export function validateConfig(config, platform) {
     if (platform === 'github' && !config.github.token) {
         throw new Error('GitHub token is required. Set GITHUB_TOKEN environment variable or configure in config file');
     }
-    if (getAgentNames(config).length === 0) {
+    if (getReviewAgentIds(config).length === 0) {
         throw new Error('At least one review agent must be configured');
     }
     if (!getDefaultModel(config)) {
-        throw new Error('Default model is required. Run "drs init" to configure or set REVIEW_DEFAULT_MODEL environment variable.');
+        throw new Error('Default model is required. Run "drs init" to configure agents.default.model or set DRS_DEFAULT_MODEL environment variable.');
     }
 }
 /**
@@ -255,69 +549,144 @@ export function normalizeAgentConfig(agents) {
         return agent;
     });
 }
+function dedupeStrings(values) {
+    return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
+}
+function getNamespaceDefaults(config, namespace) {
+    return config.agents.namespaces?.[namespace] ?? {};
+}
+function getAgentOverride(config, agentId) {
+    return config.agents.overrides?.[agentId] ?? {};
+}
+function getDefaultModelEnv() {
+    return process.env.DRS_DEFAULT_MODEL ?? process.env.REVIEW_DEFAULT_MODEL ?? undefined;
+}
+function getAgentModelEnv(agentId) {
+    const suffix = agentId.toUpperCase().replace(/[^A-Z0-9]/g, '_');
+    return process.env[`DRS_AGENT_${suffix}_MODEL`] ?? process.env[`REVIEW_AGENT_${suffix}_MODEL`];
+}
+function mergeToolSettings(...settings) {
+    const merged = {};
+    for (const setting of settings) {
+        if (!setting) {
+            continue;
+        }
+        for (const [toolName, enabled] of Object.entries(setting)) {
+            if (typeof enabled === 'boolean') {
+                merged[toolName] = enabled;
+            }
+        }
+    }
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+function mergeRunSettings(...settings) {
+    const merged = {};
+    for (const setting of settings) {
+        if (!setting) {
+            continue;
+        }
+        if (setting.prompt !== undefined)
+            merged.prompt = setting.prompt;
+        if (setting.promptFile !== undefined)
+            merged.promptFile = setting.promptFile;
+        if (setting.output !== undefined)
+            merged.output = setting.output;
+        if (setting.json !== undefined)
+            merged.json = setting.json;
+    }
+    return merged;
+}
 export function getDefaultModel(config) {
-    return (config.review.default?.model ??
-        config.review.defaultModel ??
-        process.env.REVIEW_DEFAULT_MODEL ??
-        undefined);
+    return config.agents.default?.model ?? getDefaultModelEnv();
 }
 export function getDefaultThinkingLevel(config) {
-    return config.review.default?.thinkingLevel;
+    return config.agents.default?.thinkingLevel;
+}
+export function resolveAgentThinkingLevel(config, agentId) {
+    const { namespace } = requireAgentId(agentId);
+    return (getAgentOverride(config, agentId).thinkingLevel ??
+        getNamespaceDefaults(config, namespace).thinkingLevel ??
+        getDefaultThinkingLevel(config));
 }
 export function getDefaultSkills(config) {
-    if (!Array.isArray(config.review.default?.skills)) {
-        return [];
-    }
-    return config.review.default.skills.map(String).filter((skill) => skill.length > 0);
+    return dedupeStrings((config.agents.default?.skills ?? []).map(String));
 }
-function applyLegacyModeAgentFallback(config, agentNames) {
-    const deduped = Array.from(new Set(agentNames));
-    const mode = config.review.mode;
-    if (mode === 'unified' && !deduped.includes('unified-reviewer')) {
-        return ['unified-reviewer'];
-    }
-    if (mode === 'hybrid' && !deduped.includes('unified-reviewer')) {
-        return ['unified-reviewer', ...deduped];
-    }
-    return deduped;
+export function resolveAgentSkills(config, agentId, definitionSkills = [], additionalSkills = [], precomputedReviewAgentConfig) {
+    const { namespace } = requireAgentId(agentId);
+    const namespaceDefaults = getNamespaceDefaults(config, namespace);
+    const agentOverride = getAgentOverride(config, agentId);
+    const reviewAgentConfig = precomputedReviewAgentConfig === undefined
+        ? normalizeAgentConfig(config.review.agents).find((agent) => agent.name === agentId)
+        : precomputedReviewAgentConfig;
+    return dedupeStrings([
+        ...(config.agents.default?.skills ?? []),
+        ...(namespaceDefaults.skills ?? []),
+        ...definitionSkills,
+        ...(agentOverride.skills ?? []),
+        ...(reviewAgentConfig?.skills ?? []),
+        ...additionalSkills,
+    ]);
+}
+export function resolveAgentModel(config, agentId, explicitModel) {
+    const { namespace } = requireAgentId(agentId);
+    const envModel = getAgentModelEnv(agentId);
+    return (explicitModel ??
+        envModel ??
+        getAgentOverride(config, agentId).model ??
+        getNamespaceDefaults(config, namespace).model ??
+        getDefaultModel(config));
+}
+export function resolveRuntimeAgentModel(config, agentId, definitionModel) {
+    const { namespace } = requireAgentId(agentId);
+    return (getAgentModelEnv(agentId) ??
+        getAgentOverride(config, agentId).model ??
+        definitionModel ??
+        getNamespaceDefaults(config, namespace).model ??
+        getDefaultModel(config));
+}
+export function resolveAgentTools(config, agentId, definitionTools) {
+    const { namespace } = requireAgentId(agentId);
+    return mergeToolSettings(config.agents.default?.tools, getNamespaceDefaults(config, namespace).tools, definitionTools, getAgentOverride(config, agentId).tools);
+}
+export function resolveAgentRunConfig(config, agentId) {
+    const { namespace } = requireAgentId(agentId);
+    return mergeRunSettings(config.agents.default?.run, getNamespaceDefaults(config, namespace).run, getAgentOverride(config, agentId).run);
 }
 /**
- * Extract effective agent names from configuration.
- *
- * Primary model: review.agents controls execution order and composition.
- * Legacy compatibility:
- * - mode=unified forces unified-reviewer when not explicitly configured.
- * - mode=hybrid prepends unified-reviewer when not explicitly configured.
+ * Extract effective review agent ids from configuration.
  */
-export function getAgentNames(config) {
-    const configuredAgentNames = normalizeAgentConfig(config.review.agents).map((agent) => agent.name);
-    return applyLegacyModeAgentFallback(config, configuredAgentNames);
+export function getReviewAgentIds(config) {
+    return getReviewAgentIdsFromNormalized(normalizeAgentConfig(config.review.agents));
+}
+function getReviewAgentIdsFromNormalized(normalizedAgents) {
+    const configuredAgentIds = normalizedAgents.map((agent) => agent.name);
+    const deduped = dedupeStrings(configuredAgentIds);
+    for (const agentId of deduped) {
+        const { namespace } = requireAgentId(agentId);
+        if (namespace !== 'review') {
+            throw new Error(`Invalid review agent "${agentId}". Review agents must be in the "review" namespace.`);
+        }
+    }
+    return deduped;
 }
 /**
  * Build model overrides from config and environment variables
  * Precedence:
  * 1. Per-agent model in config
- * 2. Environment variable REVIEW_AGENT_<NAME>_MODEL (e.g., REVIEW_AGENT_SECURITY_MODEL)
- * 3. defaultModel in config
- * 4. Environment variable REVIEW_DEFAULT_MODEL
- *
+ * 2. Environment variable DRS_AGENT_<NAMESPACE>_<NAME>_MODEL
+ * 3. agents.overrides.<agent>.model
+ * 4. agents.namespaces.<namespace>.model
+ * 5. agents.default.model (falls back to DRS_DEFAULT_MODEL)
  */
 export function getModelOverrides(config) {
     const overrides = {};
     const normalizedAgents = normalizeAgentConfig(config.review.agents);
     const agentConfigByName = new Map(normalizedAgents.map((agent) => [agent.name, agent]));
-    // Get default model from config or environment
-    const defaultModel = getDefaultModel(config);
-    for (const agentName of getAgentNames(config)) {
-        const configuredAgent = agentConfigByName.get(agentName);
-        // Check per-agent environment variable (e.g., REVIEW_AGENT_SECURITY_MODEL)
-        const envVarName = `REVIEW_AGENT_${agentName.toUpperCase().replace(/[^A-Z0-9]/g, '_')}_MODEL`;
-        const envModel = process.env[envVarName];
-        // Precedence: agent.model > env var > defaultModel
-        const model = configuredAgent?.model ?? envModel ?? defaultModel;
+    for (const agentId of getReviewAgentIdsFromNormalized(normalizedAgents)) {
+        const configuredAgent = agentConfigByName.get(agentId);
+        const model = resolveAgentModel(config, agentId, configuredAgent?.model);
         if (model) {
-            // Use review/<agent> format which matches how agents are invoked
-            overrides[`review/${agentName}`] = model;
+            overrides[agentId] = model;
         }
     }
     return overrides;
@@ -327,14 +696,13 @@ export function getModelOverrides(config) {
  * Precedence:
  * 1. review.unified.model in config
  * 2. Environment variable REVIEW_UNIFIED_MODEL
- * 3. review.defaultModel in config (fallback)
- * 4. Environment variable REVIEW_DEFAULT_MODEL (fallback)
  */
 export function getUnifiedModelOverride(config) {
     const overrides = {};
-    const unifiedModel = config.review.unified?.model ?? process.env.REVIEW_UNIFIED_MODEL ?? getDefaultModel(config);
+    const agentId = 'review/unified-reviewer';
+    const unifiedModel = config.review.unified?.model ?? process.env.REVIEW_UNIFIED_MODEL;
     if (unifiedModel) {
-        overrides['review/unified-reviewer'] = unifiedModel;
+        overrides[agentId] = unifiedModel;
     }
     return overrides;
 }
@@ -343,15 +711,21 @@ export function getUnifiedModelOverride(config) {
  * Precedence:
  * 1. describe.model in config
  * 2. Environment variable DESCRIBE_MODEL
- * 3. review.defaultModel in config (fallback)
- * 4. Environment variable REVIEW_DEFAULT_MODEL (fallback)
+ * 3. agents.overrides["describe/pr-describer"].model
+ * 4. agents.namespaces.describe.model
+ * 5. agents.default.model (falls back to DRS_DEFAULT_MODEL)
  */
 export function getDescriberModelOverride(config) {
     const overrides = {};
-    // Check for describer-specific model
-    const describerModel = config.describe?.model ?? process.env.DESCRIBE_MODEL ?? getDefaultModel(config);
+    const agentId = 'describe/pr-describer';
+    const describerModel = config.describe?.model ?? process.env.DESCRIBE_MODEL;
     if (describerModel) {
-        overrides['describe/pr-describer'] = describerModel;
+        overrides[agentId] = describerModel;
+        return overrides;
+    }
+    const genericModel = resolveAgentModel(config, agentId);
+    if (genericModel) {
+        overrides[agentId] = genericModel;
     }
     return overrides;
 }