dominds 0.1.0

package/dist/team.js

@@ -0,0 +1,1160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Team = void 0;
+/**
+ * Module: team
+ *
+ * Team configuration and member modeling:
+ * - `Team` aggregating members and defaults
+ * - YAML load/conversion helpers
+ * - `Team.Member` with tool resolution and access fields
+ */
+const promises_1 = __importDefault(require("fs/promises"));
+const yaml_1 = __importDefault(require("yaml"));
+const client_1 = require("./llm/client");
+const log_1 = require("./log");
+const problems_1 = require("./problems");
+const time_1 = require("./shared/utils/time");
+const registry_1 = require("./tools/registry");
+class Team {
+    constructor(params) {
+        this.memberDefaults =
+            params.memberDefaults ||
+                new Team.Member({
+                    id: 'defaulter',
+                    name: 'Defaulter',
+                });
+        this.defaultResponder = params.defaultResponder;
+        this.shellSpecialists = params.shellSpecialists ?? [];
+        this.members = params.members || {};
+    }
+    getDefaultResponder() {
+        const explicit = this.getMember(this.defaultResponder);
+        if (explicit)
+            return explicit;
+        // Fallback: pick the first visible member, else Fuxi, else any member.
+        const all = Object.values(this.members);
+        const visible = all.find((m) => m.hidden !== true);
+        if (visible)
+            return visible;
+        const fuxi = this.getMember('fuxi');
+        if (fuxi)
+            return fuxi;
+        return all.length > 0 ? all[0] : undefined;
+    }
+    getMember(id) {
+        if (!id)
+            return undefined;
+        return this.members[id];
+    }
+}
+exports.Team = Team;
+(function (Team) {
+    const TEAM_YAML_PATH = '.minds/team.yaml';
+    const TEAM_YAML_PROBLEM_PREFIX = 'team/team_yaml_error/';
+    /**
+     * Team.Member
+     *
+     * Represents an agent/member with model/provider and tool configuration.
+     * Also supports resolving toolsets into concrete tool lists.
+     */
+    class Member {
+        constructor(params) {
+            this.id = params.id;
+            this.name = params.name;
+            // Only assign provided fields; omit undefined so prototype fallback can apply
+            if (params.provider !== undefined)
+                this.provider = params.provider;
+            if (params.model !== undefined)
+                this.model = params.model;
+            // Only assign provided fields; omit undefined so prototype fallback can apply
+            if (params.gofor !== undefined)
+                this.gofor = params.gofor;
+            if (params.toolsets !== undefined)
+                this.toolsets = params.toolsets;
+            if (params.tools !== undefined)
+                this.tools = params.tools;
+            if (params.model_params !== undefined)
+                this.model_params = params.model_params;
+            if (params.diligence_push_max !== undefined)
+                this.diligence_push_max = params.diligence_push_max;
+            if (params.read_dirs !== undefined)
+                this.read_dirs = params.read_dirs;
+            if (params.write_dirs !== undefined)
+                this.write_dirs = params.write_dirs;
+            if (params.no_read_dirs !== undefined)
+                this.no_read_dirs = params.no_read_dirs;
+            if (params.no_write_dirs !== undefined)
+                this.no_write_dirs = params.no_write_dirs;
+            if (params.icon !== undefined)
+                this.icon = params.icon;
+            if (params.streaming !== undefined)
+                this.streaming = params.streaming;
+            if (params.hidden !== undefined)
+                this.hidden = params.hidden;
+            // TypeScript class-field initialization may define optional fields as own-properties with
+            // `undefined`, which breaks prototype-chain defaults. Clean them up.
+            const self = this;
+            const unsettableKeys = [
+                'provider',
+                'model',
+                'gofor',
+                'toolsets',
+                'tools',
+                'model_params',
+                'diligence_push_max',
+                'read_dirs',
+                'write_dirs',
+                'no_read_dirs',
+                'no_write_dirs',
+                'icon',
+                'streaming',
+                'hidden',
+            ];
+            for (const key of unsettableKeys) {
+                if (Object.prototype.hasOwnProperty.call(self, key) && self[key] === undefined) {
+                    delete self[key];
+                }
+            }
+        }
+        setName(name) {
+            this.name = name;
+        }
+        setProvider(provider) {
+            if (provider === undefined) {
+                delete this.provider;
+                return;
+            }
+            this.provider = provider;
+        }
+        setModel(model) {
+            if (model === undefined) {
+                delete this.model;
+                return;
+            }
+            this.model = model;
+        }
+        setGofor(gofor) {
+            if (gofor === undefined) {
+                delete this.gofor;
+                return;
+            }
+            this.gofor = gofor;
+        }
+        setToolsets(toolsets) {
+            if (toolsets === undefined) {
+                delete this.toolsets;
+                return;
+            }
+            this.toolsets = toolsets;
+        }
+        setTools(tools) {
+            if (tools === undefined) {
+                delete this.tools;
+                return;
+            }
+            this.tools = tools;
+        }
+        setModelParams(modelParams) {
+            if (modelParams === undefined) {
+                delete this.model_params;
+                return;
+            }
+            this.model_params = modelParams;
+        }
+        setDiligencePushMax(max) {
+            if (max === undefined) {
+                delete this.diligence_push_max;
+                return;
+            }
+            this.diligence_push_max = max;
+        }
+        setReadDirs(readDirs) {
+            if (readDirs === undefined) {
+                delete this.read_dirs;
+                return;
+            }
+            this.read_dirs = readDirs;
+        }
+        setWriteDirs(writeDirs) {
+            if (writeDirs === undefined) {
+                delete this.write_dirs;
+                return;
+            }
+            this.write_dirs = writeDirs;
+        }
+        setNoReadDirs(noReadDirs) {
+            if (noReadDirs === undefined) {
+                delete this.no_read_dirs;
+                return;
+            }
+            this.no_read_dirs = noReadDirs;
+        }
+        setNoWriteDirs(noWriteDirs) {
+            if (noWriteDirs === undefined) {
+                delete this.no_write_dirs;
+                return;
+            }
+            this.no_write_dirs = noWriteDirs;
+        }
+        setIcon(icon) {
+            if (icon === undefined) {
+                delete this.icon;
+                return;
+            }
+            this.icon = icon;
+        }
+        setStreaming(streaming) {
+            if (streaming === undefined) {
+                delete this.streaming;
+                return;
+            }
+            this.streaming = streaming;
+        }
+        setHidden(hidden) {
+            if (hidden === undefined) {
+                delete this.hidden;
+                return;
+            }
+            this.hidden = hidden;
+        }
+        /**
+         * Returns a flat list of Tool objects by resolving toolsets and merging with individual tools.
+         * Honors declaration order of toolsets and tools. Logs warnings for duplicate tool names
+         * that resolve to different Tool objects. Returns no duplicate tools per name.
+         */
+        listResolvedToolsetNames() {
+            if (!this.toolsets)
+                return [];
+            const excludedToolsets = new Set();
+            for (const entry of this.toolsets) {
+                if (entry.startsWith('!') && entry.length > 1) {
+                    excludedToolsets.add(entry.slice(1));
+                }
+            }
+            const resolved = [];
+            const seen = new Set();
+            for (const toolsetName of this.toolsets) {
+                if (toolsetName.startsWith('!'))
+                    continue;
+                const toolsetNames = toolsetName === '*'
+                    ? Object.keys((0, registry_1.listToolsets)()).filter((n) => !excludedToolsets.has(n))
+                    : excludedToolsets.has(toolsetName)
+                        ? []
+                        : [toolsetName];
+                for (const resolvedToolsetName of toolsetNames) {
+                    if (seen.has(resolvedToolsetName))
+                        continue;
+                    const tools = (0, registry_1.getToolset)(resolvedToolsetName);
+                    if (!tools) {
+                        log_1.log.warn(`Toolset '${resolvedToolsetName}' not found in registry for member '${this.id}'`);
+                        continue;
+                    }
+                    resolved.push(resolvedToolsetName);
+                    seen.add(resolvedToolsetName);
+                }
+            }
+            return resolved;
+        }
+        listTools() {
+            const toolMap = new Map();
+            const seenNames = new Set();
+            // Process toolsets (in declaration order)
+            for (const toolsetName of this.listResolvedToolsetNames()) {
+                const tools = (0, registry_1.getToolset)(toolsetName);
+                if (!tools)
+                    continue;
+                for (const tool of tools) {
+                    if (seenNames.has(tool.name)) {
+                        const existingTool = toolMap.get(tool.name);
+                        if (existingTool && existingTool !== tool) {
+                            log_1.log.warn(`Tool name '${tool.name}' resolves to different Tool objects for member '${this.id}'. Using first occurrence.`);
+                        }
+                        continue; // Skip duplicate
+                    }
+                    toolMap.set(tool.name, tool);
+                    seenNames.add(tool.name);
+                }
+            }
+            // Process individual tools (in declaration order)
+            if (this.tools) {
+                for (const toolName of this.tools) {
+                    const tool = (0, registry_1.getTool)(toolName);
+                    if (!tool) {
+                        log_1.log.warn(`Tool '${toolName}' not found in registry for member '${this.id}'`);
+                        continue;
+                    }
+                    if (seenNames.has(toolName)) {
+                        const existingTool = toolMap.get(toolName);
+                        if (existingTool && existingTool !== tool) {
+                            log_1.log.warn(`Tool name '${toolName}' resolves to different Tool objects for member '${this.id}'. Using first occurrence.`);
+                        }
+                        continue; // Skip duplicate
+                    }
+                    toolMap.set(toolName, tool);
+                    seenNames.add(toolName);
+                }
+            }
+            return Array.from(toolMap.values());
+        }
+    }
+    Team.Member = Member;
+    // Team config support: load .minds/team.yaml
+    async function load() {
+        const md = new Team.Member({
+            id: 'defaulter',
+            name: 'Defaulter',
+        });
+        const fuxi = new Team.Member({
+            id: 'fuxi',
+            name: '伏羲(Fuxi)',
+            icon: '☯️',
+            hidden: true,
+            toolsets: ['team-mgmt'],
+            diligence_push_max: 0,
+        });
+        Object.setPrototypeOf(fuxi, md);
+        // Use `*` to include toolsets registered later (e.g., hot-reloaded MCP toolsets),
+        // and exclude the team-management toolset.
+        const pangu = new Team.Member({
+            id: 'pangu',
+            name: '盘古(Pangu)',
+            icon: '⛰️',
+            hidden: true,
+            toolsets: ['*', '!team-mgmt'],
+            no_read_dirs: ['.minds/**'],
+            no_write_dirs: ['.minds/**'],
+            diligence_push_max: 0,
+        });
+        Object.setPrototypeOf(pangu, md);
+        const issuesById = new Map();
+        const addIssue = (id, message, errorText) => {
+            issuesById.set(id, { message, errorText });
+        };
+        const finalizeProblems = () => {
+            const now = (0, time_1.formatUnifiedTimestamp)(new Date());
+            const desired = [];
+            for (const [id, issue] of issuesById.entries()) {
+                desired.push({
+                    kind: 'team_workspace_config_error',
+                    source: 'team',
+                    id: TEAM_YAML_PROBLEM_PREFIX + id,
+                    severity: 'error',
+                    timestamp: now,
+                    message: issue.message,
+                    detail: { filePath: TEAM_YAML_PATH, errorText: issue.errorText },
+                });
+            }
+            (0, problems_1.reconcileProblemsByPrefix)(TEAM_YAML_PROBLEM_PREFIX, desired);
+        };
+        const SHELL_TOOL_NAMES = ['shell_cmd', 'stop_daemon', 'get_daemon_output'];
+        function isShellToolName(name) {
+            return SHELL_TOOL_NAMES.includes(name);
+        }
+        function listShellTools(member) {
+            const out = [];
+            for (const t of member.listTools()) {
+                if (t.type !== 'func')
+                    continue;
+                if (!isShellToolName(t.name))
+                    continue;
+                if (out.includes(t.name))
+                    continue;
+                out.push(t.name);
+            }
+            return out;
+        }
+        function enforceShellSpecialistsPolicy(team) {
+            // Hidden members are system-managed (or otherwise not user-facing). Their tool access is
+            // governed by runtime policy rather than `.minds/team.yaml` validation, so we skip them.
+            const isExemptHiddenMember = (member) => member.hidden === true;
+            const specialists = team.shellSpecialists;
+            if (specialists.length === 0) {
+                for (const member of Object.values(team.members)) {
+                    if (isExemptHiddenMember(member))
+                        continue;
+                    const shellTools = listShellTools(member);
+                    if (shellTools.length === 0)
+                        continue;
+                    addIssue(`shell_specialists/forbidden_member/${sanitizeProblemIdSegment(member.id)}`, 'Invalid .minds/team.yaml: shell tools are present but shell_specialists is empty/null.', `member '${member.id}' has shell tools (${shellTools.join(', ')}) but shell_specialists is empty; set shell_specialists to include '${member.id}' or remove shell tools from that member.`);
+                }
+                return;
+            }
+            const specialistSet = new Set(specialists);
+            for (const id of specialists) {
+                const member = team.getMember(id);
+                if (!member) {
+                    addIssue(`shell_specialists/unknown_member/${sanitizeProblemIdSegment(id)}`, 'Invalid .minds/team.yaml: shell_specialists contains an unknown member id.', `shell_specialists includes '${id}', but no such member exists in team.members.`);
+                    continue;
+                }
+                if (isExemptHiddenMember(member))
+                    continue;
+                const shellTools = listShellTools(member);
+                if (shellTools.length === 0) {
+                    addIssue(`shell_specialists/missing_shell_tools/${sanitizeProblemIdSegment(id)}`, 'Invalid .minds/team.yaml: shell specialist has no shell tools.', `shell_specialists includes '${id}', but member '${id}' has no shell tools. Grant toolset 'os' (or tools ${SHELL_TOOL_NAMES.join(', ')}) to '${id}'.`);
+                }
+            }
+            for (const member of Object.values(team.members)) {
+                if (isExemptHiddenMember(member))
+                    continue;
+                if (specialistSet.has(member.id))
+                    continue;
+                const shellTools = listShellTools(member);
+                if (shellTools.length === 0)
+                    continue;
+                addIssue(`shell_specialists/non_specialist_has_shell_tools/${sanitizeProblemIdSegment(member.id)}`, 'Invalid .minds/team.yaml: non-shell-specialist member has shell tools.', `member '${member.id}' has shell tools (${shellTools.join(', ')}) but is not listed in shell_specialists.`);
+            }
+        }
+        const buildBootstrapTeam = async () => {
+            try {
+                await applyBootstrapMemberDefaults(md);
+            }
+            catch (err) {
+                log_1.log.warn(`Failed to apply bootstrap member defaults: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            return new Team({
+                memberDefaults: md,
+                defaultResponder: 'fuxi',
+                shellSpecialists: [],
+                members: { fuxi, pangu },
+            });
+        };
+        try {
+            await promises_1.default.access(TEAM_YAML_PATH);
+        }
+        catch {
+            // When rtws doesn't have a team definition, construct a minimal team with
+            // shadow/hidden members for bootstrap.
+            const team = await buildBootstrapTeam();
+            finalizeProblems();
+            return team;
+        }
+        let team;
+        try {
+            const raw = await promises_1.default.readFile(TEAM_YAML_PATH, 'utf-8');
+            let parsed;
+            try {
+                parsed = yaml_1.default.parse(raw);
+            }
+            catch (err) {
+                addIssue('parse', 'Failed to parse .minds/team.yaml.', err instanceof Error ? err.message : String(err));
+                team = await buildBootstrapTeam();
+                finalizeProblems();
+                return team;
+            }
+            const parsedTeam = parseTeamYamlObject(parsed, md, { fuxi, pangu });
+            for (const issue of parsedTeam.issues) {
+                addIssue(issue.id, issue.message, issue.errorText);
+            }
+            team = parsedTeam.team;
+        }
+        catch (err) {
+            addIssue('read', 'Failed to load .minds/team.yaml.', err instanceof Error ? err.message : String(err));
+            team = await buildBootstrapTeam();
+            finalizeProblems();
+            return team;
+        }
+        // Always include fuxi + pangu as shadow members, even if team.yaml exists.
+        enforceShadowMemberDefaults(fuxi, pangu);
+        team.members['fuxi'] = fuxi;
+        team.members['pangu'] = pangu;
+        const configuredDefaultResponder = team.defaultResponder;
+        // Normalize default responder (even if team.yaml omitted it).
+        const def = team.getDefaultResponder();
+        team.defaultResponder = def ? def.id : 'fuxi';
+        // Shell specialists policy is fail-open at runtime but must surface errors to Problems panel.
+        enforceShellSpecialistsPolicy(team);
+        // If member_defaults provider/model are missing after parsing, try to recover from llm.yaml.
+        try {
+            await applyBootstrapMemberDefaults(md);
+        }
+        catch (err) {
+            // Fail open: Team must remain usable even if llm.yaml cannot be loaded.
+            log_1.log.warn(`Failed to recover missing member_defaults provider/model from llm config: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        if (!md.provider) {
+            addIssue('member_defaults/provider', 'Invalid .minds/team.yaml: missing member_defaults.provider.', 'member_defaults.provider is required (or must be recoverable from .minds/llm.yaml).');
+        }
+        if (!md.model) {
+            addIssue('member_defaults/model', 'Invalid .minds/team.yaml: missing member_defaults.model.', 'member_defaults.model is required (or must be recoverable from .minds/llm.yaml).');
+        }
+        if (configuredDefaultResponder && !team.getMember(configuredDefaultResponder)) {
+            addIssue('default_responder/unknown', 'Invalid .minds/team.yaml: default_responder does not match any member.', `default_responder '${configuredDefaultResponder}' does not exist in team members.`);
+        }
+        finalizeProblems();
+        return team;
+    }
+    Team.load = load;
+    async function applyBootstrapMemberDefaults(md) {
+        if (md.provider && md.model)
+            return;
+        const llmCfg = await client_1.LlmConfig.load();
+        const providerEntries = Object.entries(llmCfg.providers);
+        const tryPickProvider = (key) => {
+            if (!md.provider)
+                md.setProvider(key);
+            const providerKey = md.provider;
+            if (!providerKey)
+                return;
+            const modelKeys = Object.keys(llmCfg.providers[providerKey]?.models ?? {});
+            if (!md.model && modelKeys.length > 0)
+                md.setModel(modelKeys[0]);
+        };
+        // Prefer a provider with an available API key env var.
+        for (const [key, providerConfig] of providerEntries) {
+            if (process.env[providerConfig.apiKeyEnvVar]) {
+                tryPickProvider(key);
+                break;
+            }
+        }
+        // Fall back to the first configured provider.
+        if (!md.provider && providerEntries.length > 0) {
+            tryPickProvider(providerEntries[0][0]);
+        }
+        // If provider is set but model is missing, try to pick a model for that provider.
+        if (md.provider && !md.model) {
+            tryPickProvider(md.provider);
+        }
+    }
+    function enforceShadowMemberDefaults(fuxi, pangu) {
+        // fuxi: always hidden + always has team-mgmt available
+        fuxi.setHidden(true);
+        const fuxiToolsets = fuxi.toolsets ? [...fuxi.toolsets] : [];
+        const withoutExclude = fuxiToolsets.filter((t) => t !== '!team-mgmt');
+        if (!withoutExclude.includes('team-mgmt'))
+            withoutExclude.unshift('team-mgmt');
+        fuxi.setToolsets(withoutExclude);
+        // pangu: always hidden + never has team-mgmt + never reads/writes .minds/**
+        pangu.setHidden(true);
+        const panguToolsets = pangu.toolsets ? [...pangu.toolsets] : [];
+        const withoutMgmt = panguToolsets.filter((t) => t !== 'team-mgmt');
+        if (!withoutMgmt.includes('!team-mgmt'))
+            withoutMgmt.push('!team-mgmt');
+        if (!withoutMgmt.includes('*'))
+            withoutMgmt.unshift('*');
+        pangu.setToolsets(withoutMgmt);
+        const mindsScope = '.minds/**';
+        const panguNoRead = pangu.no_read_dirs ? [...pangu.no_read_dirs] : [];
+        if (!panguNoRead.includes(mindsScope))
+            panguNoRead.push(mindsScope);
+        pangu.setNoReadDirs(panguNoRead);
+        const panguNoWrite = pangu.no_write_dirs ? [...pangu.no_write_dirs] : [];
+        if (!panguNoWrite.includes(mindsScope))
+            panguNoWrite.push(mindsScope);
+        pangu.setNoWriteDirs(panguNoWrite);
+    }
+    function hasOwnKey(obj, key) {
+        return Object.prototype.hasOwnProperty.call(obj, key);
+    }
+    function requireDefined(value, at) {
+        if (value === undefined) {
+            throw new Error(`Invalid ${at}: value required (got ${describeValueType(value)})`);
+        }
+        return value;
+    }
+    function isRecordValue(value) {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+    }
+    Team.TEAM_YAML_ROOT_KEYS = [
+        'member_defaults',
+        'default_responder',
+        'shell_specialists',
+        'members',
+    ];
+    Team.TEAM_YAML_MEMBER_KEYS = [
+        'name',
+        'provider',
+        'model',
+        'gofor',
+        'toolsets',
+        'tools',
+        'model_params',
+        'diligence-push-max',
+        'diligence_push_max',
+        'read_dirs',
+        'write_dirs',
+        'no_read_dirs',
+        'no_write_dirs',
+        'icon',
+        'streaming',
+        'hidden',
+    ];
+    Team.TEAM_YAML_MODEL_PARAMS_ROOT_KEYS = [
+        'max_tokens',
+        'codex',
+        'openai',
+        'anthropic',
+    ];
+    Team.TEAM_YAML_MODEL_PARAMS_OPENAI_KEYS = [
+        'temperature',
+        'max_tokens',
+        'top_p',
+        'frequency_penalty',
+        'presence_penalty',
+        'seed',
+        'logprobs',
+        'top_logprobs',
+        'stop',
+        'logit_bias',
+        'user',
+        'reasoning_effort',
+        'verbosity',
+        'parallel_tool_calls',
+    ];
+    Team.TEAM_YAML_MODEL_PARAMS_CODEX_KEYS = Team.TEAM_YAML_MODEL_PARAMS_OPENAI_KEYS;
+    Team.TEAM_YAML_MODEL_PARAMS_ANTHROPIC_KEYS = [
+        'temperature',
+        'max_tokens',
+        'top_p',
+        'top_k',
+        'stop_sequences',
+        'reasoning_split',
+    ];
+    function listUnknownKeys(obj, allowedKeys) {
+        const allowed = new Set(allowedKeys);
+        const unknown = [];
+        for (const k of Object.keys(obj)) {
+            if (!allowed.has(k))
+                unknown.push(k);
+        }
+        unknown.sort((a, b) => a.localeCompare(b));
+        return unknown;
+    }
+    function buildUnknownFieldErrorText(at, unknownKeys, hints) {
+        const lines = [];
+        for (const k of unknownKeys) {
+            const hint = hints[k];
+            lines.push(hint ? `- ${at}.${k}: unknown field. ${hint}` : `- ${at}.${k}: unknown field.`);
+        }
+        return lines.join('\n');
+    }
+    function validateCommonModelParamMisplacements(pushIssue, idPrefix, atPrefix, memberObj) {
+        const hintsAtMember = {
+            reasoning_effort: `Did you mean \`${atPrefix}.model_params.codex.reasoning_effort\` (preferred for provider: codex) or \`${atPrefix}.model_params.openai.reasoning_effort\`? (not supported at ${atPrefix} root)`,
+            verbosity: `Did you mean \`${atPrefix}.model_params.codex.verbosity\` (preferred for provider: codex) or \`${atPrefix}.model_params.openai.verbosity\`? (not supported at ${atPrefix} root)`,
+            parallel_tool_calls: `Did you mean \`${atPrefix}.model_params.codex.parallel_tool_calls\` (preferred for provider: codex) or \`${atPrefix}.model_params.openai.parallel_tool_calls\`? (not supported at ${atPrefix} root)`,
+        };
+        const unknownAtMember = listUnknownKeys(memberObj, Team.TEAM_YAML_MEMBER_KEYS);
+        if (unknownAtMember.length > 0) {
+            pushIssue(`${idPrefix}/unknown_fields`, `Invalid .minds/team.yaml: ${atPrefix} contains unknown fields.`, buildUnknownFieldErrorText(atPrefix, unknownAtMember, hintsAtMember));
+        }
+        if (!Object.prototype.hasOwnProperty.call(memberObj, 'model_params'))
+            return;
+        const rawModelParams = memberObj.model_params;
+        if (rawModelParams === undefined)
+            return;
+        if (!isRecordValue(rawModelParams)) {
+            // Type errors are handled by parseMemberOverrides; keep this check focused on schema/placement.
+            return;
+        }
+        const modelParamsAt = `${atPrefix}.model_params`;
+        const hintsAtModelParams = {
+            reasoning_effort: `Did you mean \`${modelParamsAt}.codex.reasoning_effort\` (preferred for provider: codex) or \`${modelParamsAt}.openai.reasoning_effort\`?`,
+            verbosity: `Did you mean \`${modelParamsAt}.codex.verbosity\` (preferred for provider: codex) or \`${modelParamsAt}.openai.verbosity\`?`,
+            parallel_tool_calls: `Did you mean \`${modelParamsAt}.codex.parallel_tool_calls\` (preferred for provider: codex) or \`${modelParamsAt}.openai.parallel_tool_calls\`?`,
+            temperature: `Did you mean \`${modelParamsAt}.codex.temperature\` / \`${modelParamsAt}.openai.temperature\` (or \`${modelParamsAt}.anthropic.temperature\`)?`,
+            top_p: `Did you mean \`${modelParamsAt}.codex.top_p\` / \`${modelParamsAt}.openai.top_p\` (or \`${modelParamsAt}.anthropic.top_p\`)?`,
+            max_tokens: `Did you mean \`${modelParamsAt}.max_tokens\` (top-level), or \`${modelParamsAt}.codex.max_tokens\` / \`${modelParamsAt}.openai.max_tokens\` / \`${modelParamsAt}.anthropic.max_tokens\`?`,
+        };
+        const unknownAtModelParams = listUnknownKeys(rawModelParams, Team.TEAM_YAML_MODEL_PARAMS_ROOT_KEYS);
+        if (unknownAtModelParams.length > 0) {
+            pushIssue(`${idPrefix}/model_params/unknown_fields`, `Invalid .minds/team.yaml: ${modelParamsAt} contains unknown fields.`, buildUnknownFieldErrorText(modelParamsAt, unknownAtModelParams, hintsAtModelParams));
+        }
+        const rawCodex = rawModelParams.codex;
+        if (rawCodex !== undefined && isRecordValue(rawCodex)) {
+            const unknownAtCodex = listUnknownKeys(rawCodex, Team.TEAM_YAML_MODEL_PARAMS_CODEX_KEYS);
+            if (unknownAtCodex.length > 0) {
+                pushIssue(`${idPrefix}/model_params/codex/unknown_fields`, `Invalid .minds/team.yaml: ${modelParamsAt}.codex contains unknown fields.`, buildUnknownFieldErrorText(`${modelParamsAt}.codex`, unknownAtCodex, {}));
+            }
+        }
+        const rawOpenai = rawModelParams.openai;
+        if (rawOpenai !== undefined && isRecordValue(rawOpenai)) {
+            const unknownAtOpenai = listUnknownKeys(rawOpenai, Team.TEAM_YAML_MODEL_PARAMS_OPENAI_KEYS);
+            if (unknownAtOpenai.length > 0) {
+                pushIssue(`${idPrefix}/model_params/openai/unknown_fields`, `Invalid .minds/team.yaml: ${modelParamsAt}.openai contains unknown fields.`, buildUnknownFieldErrorText(`${modelParamsAt}.openai`, unknownAtOpenai, {}));
+            }
+        }
+        const rawAnthropic = rawModelParams.anthropic;
+        if (rawAnthropic !== undefined && isRecordValue(rawAnthropic)) {
+            const unknownAtAnthropic = listUnknownKeys(rawAnthropic, Team.TEAM_YAML_MODEL_PARAMS_ANTHROPIC_KEYS);
+            if (unknownAtAnthropic.length > 0) {
+                pushIssue(`${idPrefix}/model_params/anthropic/unknown_fields`, `Invalid .minds/team.yaml: ${modelParamsAt}.anthropic contains unknown fields.`, buildUnknownFieldErrorText(`${modelParamsAt}.anthropic`, unknownAtAnthropic, {}));
+            }
+        }
+    }
+    function sanitizeProblemIdSegment(segment) {
+        return segment.replace(/[^a-zA-Z0-9_-]/g, '_');
+    }
+    function asErrorText(err) {
+        return err instanceof Error ? err.message : String(err);
+    }
+    function parseMemberOverrides(rv, at) {
+        const overrides = {};
+        const errors = [];
+        if (hasOwnKey(rv, 'name')) {
+            try {
+                overrides.name = requireDefined(asOptionalString(rv['name'], `${at}.name`), `${at}.name`);
+            }
+            catch (err) {
+                errors.push(asErrorText(err));
+            }
+        }
+        if (hasOwnKey(rv, 'provider')) {
+            try {
+                overrides.provider = requireDefined(asOptionalString(rv['provider'], `${at}.provider`), `${at}.provider`);
+            }
+            catch (err) {
+                errors.push(asErrorText(err));
+            }
+        }
+        if (hasOwnKey(rv, 'model')) {
+            try {
+                overrides.model = requireDefined(asOptionalString(rv['model'], `${at}.model`), `${at}.model`);
+            }
+            catch (err) {
+                errors.push(asErrorText(err));
+            }
+        }
+        if (hasOwnKey(rv, 'gofor')) {
+            try {
+                overrides.gofor = requireDefined(asOptionalGofor(rv['gofor'], `${at}.gofor`), `${at}.gofor`);
+            }
+            catch (err) {
+                errors.push(asErrorText(err));
+            }
+        }
+        if (hasOwnKey(rv, 'toolsets')) {
+            try {
+                overrides.toolsets = requireDefined(asOptionalStringArray(rv['toolsets'], `${at}.toolsets`), `${at}.toolsets`);
+            }
+            catch (err) {
+                errors.push(asErrorText(err));
+            }
+        }
+        if (hasOwnKey(rv, 'tools')) {
+            try {
+                overrides.tools = requireDefined(asOptionalStringArray(rv['tools'], `${at}.tools`), `${at}.tools`);
+            }
+            catch (err) {
+                errors.push(asErrorText(err));
+            }
+        }
+        if (hasOwnKey(rv, 'model_params')) {
+            try {
+                overrides.model_params = requireDefined(asOptionalModelParams(rv['model_params'], `${at}.model_params`), `${at}.model_params`);
+            }
+            catch (err) {
+                errors.push(asErrorText(err));
+            }
+        }
+        const hasDiligencePushMaxDash = hasOwnKey(rv, 'diligence-push-max');
+        const hasDiligencePushMaxUnderscore = hasOwnKey(rv, 'diligence_push_max');
+        if (hasDiligencePushMaxDash && hasDiligencePushMaxUnderscore) {
+            errors.push(`Invalid ${at}: both diligence-push-max and diligence_push_max are set; please use only diligence-push-max.`);
+        }
+        else if (hasDiligencePushMaxDash) {
+            try {
+                overrides.diligence_push_max = requireDefined(asOptionalNumber(rv['diligence-push-max'], `${at}.diligence-push-max`), `${at}.diligence-push-max`);
+            }
+            catch (err) {
+                errors.push(asErrorText(err));
+            }
+        }
+        else if (hasDiligencePushMaxUnderscore) {
+            try {
+                overrides.diligence_push_max = requireDefined(asOptionalNumber(rv['diligence_push_max'], `${at}.diligence_push_max`), `${at}.diligence_push_max`);
+            }
+            catch (err) {
+                errors.push(asErrorText(err));
+            }
+        }
+        if (hasOwnKey(rv, 'read_dirs')) {
+            try {
+                overrides.read_dirs = requireDefined(asOptionalStringArray(rv['read_dirs'], `${at}.read_dirs`), `${at}.read_dirs`);
+            }
+            catch (err) {
+                errors.push(asErrorText(err));
+            }
+        }
+        if (hasOwnKey(rv, 'write_dirs')) {
+            try {
+                overrides.write_dirs = requireDefined(asOptionalStringArray(rv['write_dirs'], `${at}.write_dirs`), `${at}.write_dirs`);
+            }
+            catch (err) {
+                errors.push(asErrorText(err));
+            }
+        }
+        if (hasOwnKey(rv, 'no_read_dirs')) {
+            try {
+                overrides.no_read_dirs = requireDefined(asOptionalStringArray(rv['no_read_dirs'], `${at}.no_read_dirs`), `${at}.no_read_dirs`);
+            }
+            catch (err) {
+                errors.push(asErrorText(err));
+            }
+        }
+        if (hasOwnKey(rv, 'no_write_dirs')) {
+            try {
+                overrides.no_write_dirs = requireDefined(asOptionalStringArray(rv['no_write_dirs'], `${at}.no_write_dirs`), `${at}.no_write_dirs`);
+            }
+            catch (err) {
+                errors.push(asErrorText(err));
+            }
+        }
+        if (hasOwnKey(rv, 'icon')) {
+            try {
+                overrides.icon = requireDefined(asOptionalString(rv['icon'], `${at}.icon`), `${at}.icon`);
+            }
+            catch (err) {
+                errors.push(asErrorText(err));
+            }
+        }
+        if (hasOwnKey(rv, 'streaming')) {
+            try {
+                overrides.streaming = requireDefined(asOptionalBoolean(rv['streaming'], `${at}.streaming`), `${at}.streaming`);
+            }
+            catch (err) {
+                errors.push(asErrorText(err));
+            }
+        }
+        if (hasOwnKey(rv, 'hidden')) {
+            try {
+                overrides.hidden = requireDefined(asOptionalBoolean(rv['hidden'], `${at}.hidden`), `${at}.hidden`);
+            }
+            catch (err) {
+                errors.push(asErrorText(err));
+            }
+        }
+        if (errors.length > 0)
+            return { kind: 'error', errorTexts: errors };
+        return { kind: 'ok', overrides };
+    }
+    function applyOverrides(member, overrides) {
+        if (overrides.name !== undefined)
+            member.setName(overrides.name);
+        if (overrides.provider !== undefined)
+            member.setProvider(overrides.provider);
+        if (overrides.model !== undefined)
+            member.setModel(overrides.model);
+        if (overrides.gofor !== undefined)
+            member.setGofor(overrides.gofor);
+        if (overrides.toolsets !== undefined)
+            member.setToolsets(overrides.toolsets);
+        if (overrides.tools !== undefined)
+            member.setTools(overrides.tools);
+        if (overrides.model_params !== undefined)
+            member.setModelParams(overrides.model_params);
+        if (overrides.diligence_push_max !== undefined)
+            member.setDiligencePushMax(overrides.diligence_push_max);
+        if (overrides.read_dirs !== undefined)
+            member.setReadDirs(overrides.read_dirs);
+        if (overrides.write_dirs !== undefined)
+            member.setWriteDirs(overrides.write_dirs);
+        if (overrides.no_read_dirs !== undefined)
+            member.setNoReadDirs(overrides.no_read_dirs);
+        if (overrides.no_write_dirs !== undefined)
+            member.setNoWriteDirs(overrides.no_write_dirs);
+        if (overrides.icon !== undefined)
+            member.setIcon(overrides.icon);
+        if (overrides.streaming !== undefined)
+            member.setStreaming(overrides.streaming);
+        if (overrides.hidden !== undefined)
+            member.setHidden(overrides.hidden);
+    }
+    function parseTeamYamlObject(obj, md, shadow) {
+        const issues = [];
+        const pushIssue = (id, message, errorText) => {
+            issues.push({ id, message, errorText });
+        };
+        const teamObj = (() => {
+            if (isRecordValue(obj))
+                return obj;
+            pushIssue('root', 'Invalid .minds/team.yaml: expected an object at root.', `Invalid team config: expected an object (got ${describeValueType(obj)})`);
+            return {};
+        })();
+        const unknownRootKeys = listUnknownKeys(teamObj, Team.TEAM_YAML_ROOT_KEYS);
+        if (unknownRootKeys.length > 0) {
+            pushIssue('root/unknown_fields', 'Invalid .minds/team.yaml: unknown top-level fields.', buildUnknownFieldErrorText('root', unknownRootKeys, {}));
+        }
+        // member_defaults
+        const rawMemberDefaults = teamObj.member_defaults;
+        if (rawMemberDefaults !== undefined) {
+            if (!isRecordValue(rawMemberDefaults)) {
+                pushIssue('member_defaults', 'Invalid .minds/team.yaml: member_defaults must be an object.', `Invalid member_defaults: expected an object (got ${describeValueType(rawMemberDefaults)})`);
+            }
+            else {
+                validateCommonModelParamMisplacements(pushIssue, 'member_defaults', 'member_defaults', rawMemberDefaults);
+                const parsedMd = parseMemberOverrides(rawMemberDefaults, 'member_defaults');
+                if (parsedMd.kind === 'ok') {
+                    applyOverrides(md, parsedMd.overrides);
+                }
+                else {
+                    pushIssue('member_defaults', 'Invalid .minds/team.yaml: member_defaults has invalid fields.', parsedMd.errorTexts.join('\n'));
+                }
+            }
+        }
+        // default_responder
+        let defResp;
+        if (teamObj.default_responder !== undefined) {
+            try {
+                defResp = asOptionalString(teamObj.default_responder, 'default_responder');
+            }
+            catch (err) {
+                pushIssue('default_responder/type', 'Invalid .minds/team.yaml: default_responder must be a string.', asErrorText(err));
+            }
+        }
+        // shell_specialists
+        let shellSpecialists = [];
+        if (teamObj.shell_specialists !== undefined) {
+            const v = teamObj.shell_specialists;
+            if (v === null) {
+                shellSpecialists = [];
+            }
+            else {
+                try {
+                    const parsed = requireDefined(asOptionalStringOrStringArray(v, 'shell_specialists'), 'shell_specialists');
+                    // Normalize: drop empties and de-dupe while preserving order.
+                    const seen = new Set();
+                    shellSpecialists = [];
+                    for (const id of parsed) {
+                        const trimmed = id.trim();
+                        if (trimmed === '')
+                            continue;
+                        if (seen.has(trimmed))
+                            continue;
+                        seen.add(trimmed);
+                        shellSpecialists.push(trimmed);
+                    }
+                }
+                catch (err) {
+                    pushIssue('shell_specialists/type', 'Invalid .minds/team.yaml: shell_specialists must be string|string[] or null.', asErrorText(err));
+                }
+            }
+        }
+        const membersRec = {};
+        const rawMembers = teamObj.members;
+        const membersObj = (() => {
+            if (rawMembers === undefined)
+                return {};
+            if (isRecordValue(rawMembers))
+                return rawMembers;
+            pushIssue('members', 'Invalid .minds/team.yaml: members must be an object.', `Invalid members: expected an object (got ${describeValueType(rawMembers)})`);
+            return {};
+        })();
+        for (const [id, raw] of Object.entries(membersObj)) {
+            const memberAt = `members.${id}`;
+            const idSeg = sanitizeProblemIdSegment(id);
+            if (!isRecordValue(raw)) {
+                pushIssue(`members/${idSeg}`, `Invalid .minds/team.yaml: ${memberAt} must be an object.`, `Invalid ${memberAt}: expected an object (got ${describeValueType(raw)})`);
+                continue;
+            }
+            validateCommonModelParamMisplacements(pushIssue, `members/${idSeg}`, memberAt, raw);
+            const parsedMember = parseMemberOverrides(raw, memberAt);
+            if (parsedMember.kind === 'error') {
+                pushIssue(`members/${idSeg}`, `Invalid .minds/team.yaml: ${memberAt} has invalid fields.`, parsedMember.errorTexts.join('\n'));
+                if (id === 'fuxi' || id === 'pangu') {
+                    // Shadow members are always present; ignore overrides on invalid config.
+                    const shadowMember = id === 'fuxi' ? shadow.fuxi : shadow.pangu;
+                    Object.setPrototypeOf(shadowMember, md);
+                    membersRec[id] = shadowMember;
+                }
+                continue;
+            }
+            if (id === 'fuxi' || id === 'pangu') {
+                const shadowMember = id === 'fuxi' ? shadow.fuxi : shadow.pangu;
+                applyOverrides(shadowMember, parsedMember.overrides);
+                Object.setPrototypeOf(shadowMember, md);
+                membersRec[id] = shadowMember;
+                continue;
+            }
+            const m = new Team.Member({ id, name: id });
+            applyOverrides(m, parsedMember.overrides);
+            Object.setPrototypeOf(m, md);
+            membersRec[id] = m;
+        }
+        return {
+            team: new Team({
+                memberDefaults: md,
+                defaultResponder: defResp,
+                shellSpecialists,
+                members: membersRec,
+            }),
+            issues,
+        };
+    }
+    function asRecord(value, at) {
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            throw new Error(`Invalid ${at}: expected an object (got ${describeValueType(value)})`);
+        }
+        return value;
+    }
+    function asString(value, at) {
+        if (typeof value !== 'string') {
+            throw new Error(`Invalid ${at}: expected a string (got ${describeValueType(value)})`);
+        }
+        return value;
+    }
+    function asOptionalString(value, at) {
+        if (value === undefined)
+            return undefined;
+        if (typeof value !== 'string') {
+            throw new Error(`Invalid ${at}: expected a string (got ${describeValueType(value)})`);
+        }
+        return value;
+    }
+    function asOptionalBoolean(value, at) {
+        if (value === undefined)
+            return undefined;
+        if (typeof value !== 'boolean') {
+            throw new Error(`Invalid ${at}: expected a boolean (got ${describeValueType(value)})`);
+        }
+        return value;
+    }
+    function asOptionalNumber(value, at) {
+        if (value === undefined)
+            return undefined;
+        if (typeof value !== 'number' || !Number.isFinite(value)) {
+            throw new Error(`Invalid ${at}: expected a number (got ${describeValueType(value)})`);
+        }
+        return value;
+    }
+    function asOptionalStringArray(value, at) {
+        if (value === undefined)
+            return undefined;
+        if (!Array.isArray(value) || !value.every((v) => typeof v === 'string')) {
+            throw new Error(`Invalid ${at}: expected string[] (got ${describeValueType(value)})`);
+        }
+        return value;
+    }
+    function describeValueType(value) {
+        if (value === undefined)
+            return 'undefined';
+        if (value === null)
+            return 'null';
+        if (Array.isArray(value)) {
+            if (value.length === 0)
+                return 'unknown[]';
+            const elementTypes = new Set();
+            for (const v of value) {
+                if (v === undefined)
+                    elementTypes.add('undefined');
+                else if (v === null)
+                    elementTypes.add('null');
+                else if (Array.isArray(v))
+                    elementTypes.add('unknown[]');
+                else
+                    elementTypes.add(typeof v);
+            }
+            const t = Array.from(elementTypes).sort();
+            if (t.length === 1)
+                return `${t[0]}[]`;
+            return `(${t.join('|')})[]`;
+        }
+        return typeof value;
+    }
+    function asOptionalStringOrStringArray(value, at) {
+        if (value === undefined)
+            return undefined;
+        if (typeof value === 'string')
+            return [value];
+        if (Array.isArray(value) && value.every((v) => typeof v === 'string')) {
+            return value;
+        }
+        throw new Error(`Invalid ${at}: expected string|string[] (got ${describeValueType(value)})`);
+    }
+    function asOptionalGofor(value, at) {
+        if (value === undefined)
+            return undefined;
+        if (typeof value === 'string')
+            return [value];
+        if (Array.isArray(value) && value.every((v) => typeof v === 'string'))
+            return value;
+        if (isRecordValue(value)) {
+            const obj = value;
+            for (const [k, v] of Object.entries(obj)) {
+                if (typeof v !== 'string') {
+                    throw new Error(`Invalid ${at}.${k}: expected string (got ${describeValueType(v)})`);
+                }
+            }
+            return obj;
+        }
+        throw new Error(`Invalid ${at}: expected string|string[]|Record<string,string> (got ${describeValueType(value)})`);
+    }
+    function asOptionalStop(value, at) {
+        if (value === undefined)
+            return undefined;
+        if (typeof value === 'string')
+            return value;
+        if (Array.isArray(value) && value.every((v) => typeof v === 'string'))
+            return value;
+        throw new Error(`Invalid ${at}: expected string|string[] (got ${describeValueType(value)})`);
+    }
+    function asOptionalLogitBias(value, at) {
+        if (value === undefined)
+            return undefined;
+        const obj = asRecord(value, at);
+        for (const [k, v] of Object.entries(obj)) {
+            if (typeof v !== 'number') {
+                throw new Error(`Invalid ${at}.${k}: expected a number (got ${describeValueType(v)})`);
+            }
+        }
+        return obj;
+    }
+    function asOptionalModelParams(value, at) {
+        if (value === undefined)
+            return undefined;
+        const obj = asRecord(value, at);
+        const validateOpenAiStyleParams = (params, at2) => {
+            asOptionalNumber(params.temperature, `${at2}.temperature`);
+            asOptionalNumber(params.max_tokens, `${at2}.max_tokens`);
+            asOptionalNumber(params.top_p, `${at2}.top_p`);
+            asOptionalNumber(params.frequency_penalty, `${at2}.frequency_penalty`);
+            asOptionalNumber(params.presence_penalty, `${at2}.presence_penalty`);
+            asOptionalNumber(params.seed, `${at2}.seed`);
+            asOptionalBoolean(params.logprobs, `${at2}.logprobs`);
+            asOptionalNumber(params.top_logprobs, `${at2}.top_logprobs`);
+            asOptionalStop(params.stop, `${at2}.stop`);
+            asOptionalLogitBias(params.logit_bias, `${at2}.logit_bias`);
+            asOptionalString(params.user, `${at2}.user`);
+            asOptionalBoolean(params.parallel_tool_calls, `${at2}.parallel_tool_calls`);
+            const reasoningEffort = params.reasoning_effort;
+            if (reasoningEffort !== undefined &&
+                reasoningEffort !== 'none' &&
+                reasoningEffort !== 'minimal' &&
+                reasoningEffort !== 'low' &&
+                reasoningEffort !== 'medium' &&
+                reasoningEffort !== 'high' &&
+                reasoningEffort !== 'xhigh') {
+                throw new Error(`Invalid ${at2}.reasoning_effort: expected none|minimal|low|medium|high|xhigh (got ${describeValueType(reasoningEffort)})`);
+            }
+            const verbosity = params.verbosity;
+            if (verbosity !== undefined &&
+                verbosity !== 'low' &&
+                verbosity !== 'medium' &&
+                verbosity !== 'high') {
+                throw new Error(`Invalid ${at2}.verbosity: expected low|medium|high (got ${describeValueType(verbosity)})`);
+            }
+        };
+        const codex = obj.codex === undefined ? undefined : asRecord(obj.codex, `${at}.codex`);
+        const openai = obj.openai === undefined ? undefined : asRecord(obj.openai, `${at}.openai`);
+        const anthropic = obj.anthropic === undefined ? undefined : asRecord(obj.anthropic, `${at}.anthropic`);
+        if (codex) {
+            validateOpenAiStyleParams(codex, `${at}.codex`);
+        }
+        if (openai) {
+            validateOpenAiStyleParams(openai, `${at}.openai`);
+        }
+        if (anthropic) {
+            asOptionalNumber(anthropic.temperature, `${at}.anthropic.temperature`);
+            asOptionalNumber(anthropic.max_tokens, `${at}.anthropic.max_tokens`);
+            asOptionalNumber(anthropic.top_p, `${at}.anthropic.top_p`);
+            asOptionalNumber(anthropic.top_k, `${at}.anthropic.top_k`);
+            asOptionalStringArray(anthropic.stop_sequences, `${at}.anthropic.stop_sequences`);
+            asOptionalBoolean(anthropic.reasoning_split, `${at}.anthropic.reasoning_split`);
+        }
+        asOptionalNumber(obj.max_tokens, `${at}.max_tokens`);
+        return obj;
+    }
+})(Team || (exports.Team = Team = {}));