Improve data skill routing and tool organization

src/agent_runtime.py

@@ -2012,78 +2012,96 @@ class LocalCodingAgent:
         return fallback
 
     def _format_generation_goal_review(self, goal: dict[str, object]) -> str:
+        target_summary = self._format_review_targets(goal)
         lines = [
-            '已生成待 review 的数据生成目标，本轮已暂停。',
-            '',
-            f"- goal_id: `{goal.get('goal_id', '')}`",
-            f"- revision: `{goal.get('revision', '')}`",
-            f"- dataset_label: {goal.get('dataset_label', '')}",
-            f"- 目标摘要: {goal.get('goal_summary', '')}",
+            '我先把生成目标整理好了，先确认边界，暂时不生成数据。',
+            f"- 数据集：{goal.get('dataset_label', '')}",
         ]
-        targets = goal.get('target_definitions')
-        if isinstance(targets, list) and targets:
-            lines.append('- target_definitions:')
-            for item in targets:
-                if isinstance(item, dict):
-                    lines.append(
-                        f"  - {item.get('name', '')}: `{item.get('target', '')}`；规则：{item.get('rule', '')}"
-                    )
-        elif goal.get('target'):
-            lines.append(f"- target: `{goal.get('target')}`")
-        if goal.get('plan_hint'):
-            lines.append(f"- 计划提示: {goal.get('plan_hint')}")
+        if target_summary:
+            lines.append(f'- 标签：{target_summary}')
+        if goal.get('goal_summary'):
+            lines.append(f"- 边界：{self._short_review_text(goal.get('goal_summary'))}")
+        scope_parts = []
+        if goal.get('coverage'):
+            scope_parts.append(f"覆盖：{self._short_review_text(goal.get('coverage'), limit=70)}")
+        if goal.get('exclusions'):
+            scope_parts.append(f"排除：{self._short_review_text(goal.get('exclusions'), limit=50)}")
+        if scope_parts:
+            lines.append('- 范围：' + '；'.join(scope_parts))
         open_questions = goal.get('open_questions')
         if isinstance(open_questions, list) and open_questions:
-            lines.append('- 待确认问题:')
-            for item in open_questions:
-                if isinstance(item, str) and item:
-                    lines.append(f'  - {item}')
-        source_refs = goal.get('source_refs')
-        if isinstance(source_refs, list) and source_refs:
-            lines.append('- 来源:')
-            for item in source_refs:
-                if isinstance(item, str) and item:
-                    lines.append(f'  - {item}')
+            questions = '；'.join(str(item).strip() for item in open_questions if isinstance(item, str) and item.strip())
+            if questions:
+                lines.append(f'- 待确认：{self._short_review_text(questions)}')
+        elif goal.get('plan_hint'):
+            lines.append(f"- 下一步：{self._short_review_text(goal.get('plan_hint'))}")
+        lines.append(f"- 内部：goal_id `{goal.get('goal_id', '')}`，revision `{goal.get('revision', '')}`")
+        lines.append('')
+        lines.append('你看这个目标是否准确？没问题就回“确认目标”；想改的话直接说哪里不对。')
+        return '\n'.join(lines)
+
+    def _format_generation_plan_review(self, plan: dict[str, object]) -> str:
+        if not plan.get('confirmed_goal_id'):
+            return self._format_direct_generation_plan_review(plan)
+        lines = [
+            '目标已确认。现在只补充生成参数，标签边界沿用上一步。',
+            f"- 数量：{plan.get('total_count', '')} 条",
+            f"- 轮次：{plan.get('turn_mix', '')}",
+            f"- 覆盖补充：{self._short_review_text(plan.get('coverage'))}",
+            f"- 排除：{self._short_review_text(plan.get('exclusions'))}",
+            f"- 输出：{plan.get('output_path', '')}",
+            f"- 内部：plan_id `{plan.get('plan_id', '')}`，revision `{plan.get('revision', '')}`",
+        ]
+        lines.append('')
+        lines.append('如果这个数量和路径可以，就回“确认，开始生成”；想调整就直接说，比如“改成 20 条，全单轮”。')
+        return '\n'.join(lines)
+
+    def _format_direct_generation_plan_review(self, plan: dict[str, object]) -> str:
+        target_summary = self._format_review_targets(plan)
+        lines = [
+            '我把目标和生成参数合成一次确认，确认后就开始生成。',
+            f"- 数据集：{plan.get('dataset_label', '')}",
+        ]
+        if target_summary:
+            lines.append(f'- 标签：{target_summary}')
         lines.extend(
             [
-                f"- 覆盖范围: {goal.get('coverage', '')}",
-                f"- 排除项: {goal.get('exclusions', '')}",
+                f"- 数量：{plan.get('total_count', '')} 条；轮次：{plan.get('turn_mix', '')}",
+                (
+                    '- 范围：'
+                    f"覆盖：{self._short_review_text(plan.get('coverage'), limit=70)}；"
+                    f"排除：{self._short_review_text(plan.get('exclusions'), limit=50)}"
+                ),
+                f"- 输出：{plan.get('output_path', '')}",
+                f"- 内部：plan_id `{plan.get('plan_id', '')}`，revision `{plan.get('revision', '')}`",
                 '',
-                '请 review 这个生成目标：需要修改就直接回复修改意见；认可的话回复“确认目标”。',
+                '如果目标、数量和路径都可以，就回“确认，开始生成”；想调整就直接说哪里改。',
             ]
         )
         return '\n'.join(lines)
 
-    def _format_generation_plan_review(self, plan: dict[str, object]) -> str:
-        lines = [
-            '已生成待 review 的数据生成计划，本轮已暂停。',
-            '',
-            f"- plan_id: `{plan.get('plan_id', '')}`",
-            f"- revision: `{plan.get('revision', '')}`",
-            f"- dataset_label: {plan.get('dataset_label', '')}",
-        ]
-        targets = plan.get('target_definitions')
+    def _format_review_targets(self, payload: dict[str, object]) -> str:
+        targets = payload.get('target_definitions')
         if isinstance(targets, list) and targets:
-            lines.append('- target_definitions:')
+            parts: list[str] = []
             for item in targets:
-                if isinstance(item, dict):
-                    lines.append(
-                        f"  - {item.get('name', '')}: `{item.get('target', '')}`；规则：{item.get('rule', '')}"
-                    )
-        elif plan.get('target'):
-            lines.append(f"- target: `{plan.get('target')}`")
-        lines.extend(
-            [
-                f"- 生成数量: {plan.get('total_count', '')}",
-                f"- 单轮/多轮: {plan.get('turn_mix', '')}",
-                f"- 覆盖范围: {plan.get('coverage', '')}",
-                f"- 排除项: {plan.get('exclusions', '')}",
-                f"- 落盘路径: {plan.get('output_path', '')}",
-                '',
-                '请 review 这份计划：需要修改就直接回复修改意见；认可的话回复“确认，开始生成”。',
-            ]
-        )
-        return '\n'.join(lines)
+                if not isinstance(item, dict):
+                    continue
+                name = str(item.get('name') or '').strip()
+                target = str(item.get('target') or '').strip()
+                if name and target:
+                    parts.append(f'{name} -> `{target}`')
+                elif target:
+                    parts.append(f'`{target}`')
+            return '；'.join(parts)
+        target = payload.get('target')
+        return f'`{target}`' if isinstance(target, str) and target.strip() else ''
+
+    def _short_review_text(self, value: object, *, limit: int = 120) -> str:
+        text = ' '.join(str(value or '').split())
+        if len(text) <= limit:
+            return text
+        return text[: limit - 1].rstrip() + '…'
 
     def _compact_prefix_count(self, session: AgentSessionState) -> int:
         prefix_count = 0
@@ -2388,14 +2406,29 @@ class LocalCodingAgent:
 
         # Explicit model param in arguments takes priority
         if isinstance(model_override, str) and model_override.strip():
-            return replace(self.model_config, model=model_override.strip())
+            resolved_model = self._resolve_child_model_name(model_override.strip())
+            return replace(self.model_config, model=resolved_model)
 
         # Agent definition model
         if agent_model and agent_model != 'inherit':
-            return replace(self.model_config, model=agent_model)
+            resolved_model = self._resolve_child_model_name(agent_model)
+            return replace(self.model_config, model=resolved_model)
 
         return self.model_config
 
+    def _resolve_child_model_name(self, requested_model: str) -> str:
+        """Map Claude-style child model aliases only when the parent model is Claude-like."""
+
+        normalized = requested_model.strip()
+        if normalized in {'haiku', 'sonnet', 'opus'} and not self._is_claude_model(self.model_config.model):
+            return self.model_config.model
+        return normalized
+
+    @staticmethod
+    def _is_claude_model(model: str) -> bool:
+        lowered = model.lower()
+        return lowered.startswith('claude') or '/claude' in lowered or 'anthropic' in lowered
+
     def _filter_tools_for_agent(
         self,
         agent_def: AgentDefinition,