@roll-agent/octopus-agent 0.0.4 → 0.0.6

package/src/octopus_sponge_skill/agent.py

@@ -21,6 +21,7 @@ from .sql_generator import (
     enforce_sql_rules,
     is_low_quality_sql_for_question,
     is_recruiting_match_effect_query,
+    sensitive_terms_in_text,
     sql_satisfies_time_range,
     validate_sql_against_schema,
 )
@@ -94,7 +95,11 @@ class SpongeAgent:
             session_id=session_id or new_session_id(),
         )
         sql_question = _strip_result_format_instruction(user_question)
+        sensitive_terms = sensitive_terms_in_text(sql_question)
         schema = self._ensure_schema()
+        unsupported_field_message = _unsupported_requested_field_message(sql_question, schema)
+        if unsupported_field_message is not None:
+            return _business_metric_clarification_result(unsupported_field_message)
         business_clarification = _business_metric_clarification(sql_question, schema)
         if business_clarification is not None:
             return _business_metric_clarification_result(business_clarification)
@@ -162,7 +167,12 @@ class SpongeAgent:
         else:
             schema_context = None
             generator = None
-        candidate_sql = repaired_sql or _apply_default_limit(generated.sql, sql_question, self.config.sql.default_limit)
+        candidate_sql = repaired_sql or _apply_limit_policy(
+            generated.sql,
+            sql_question,
+            default_limit=self.config.sql.default_limit,
+            max_limit=self.config.sql.max_limit,
+        )
         if not sql_satisfies_time_range(candidate_sql, sql_question, schema):
             if sampler is None or schema_context is None or generator is None:
                 return _query_only_result()
@@ -179,7 +189,12 @@ class SpongeAgent:
             except SqlGenerationError:
                 return _query_only_result()
             generated = GeneratedSql(sql="", tables=[], placeholders=[])
-            repaired_sql = _apply_default_limit(repaired.sql, sql_question, self.config.sql.default_limit)
+            repaired_sql = _apply_limit_policy(
+                repaired.sql,
+                sql_question,
+                default_limit=self.config.sql.default_limit,
+                max_limit=self.config.sql.max_limit,
+            )
             candidate_sql = repaired_sql
             if not sql_satisfies_time_range(candidate_sql, sql_question, schema):
                 return _query_only_result()
@@ -192,14 +207,19 @@ class SpongeAgent:
                     original_sql=candidate_sql,
                     validation_error={
                         "code": "LOW_QUALITY_SQL",
-                        "message": "SQL 与问题意图不匹配，报名/工单/候选人明细不能退化成品牌列表，且必须使用正确工单表、状态和岗位关联。",
+                        "message": "SQL 与问题意图不匹配，业务查询不能退化成品牌、项目、城市、门店、岗位等单表列表；明确名称时必须在完整业务 SQL 中 JOIN 对应表并使用 name LIKE 或 job_name LIKE。",
                     },
                     schema_context=schema_context,
                 )
             except SqlGenerationError:
                 return _query_only_result()
             generated = GeneratedSql(sql="", tables=[], placeholders=[])
-            repaired_sql = _apply_default_limit(repaired.sql, sql_question, self.config.sql.default_limit)
+            repaired_sql = _apply_limit_policy(
+                repaired.sql,
+                sql_question,
+                default_limit=self.config.sql.default_limit,
+                max_limit=self.config.sql.max_limit,
+            )
             candidate_sql = repaired_sql
             if is_low_quality_sql_for_question(sql_question, candidate_sql):
                 return _query_only_result()
@@ -220,29 +240,69 @@ class SpongeAgent:
             except SqlGenerationError:
                 return _query_only_result()
             generated = GeneratedSql(sql="", tables=[], placeholders=[])
-            repaired_sql = _apply_default_limit(repaired.sql, sql_question, self.config.sql.default_limit)
+            repaired_sql = _apply_limit_policy(
+                repaired.sql,
+                sql_question,
+                default_limit=self.config.sql.default_limit,
+                max_limit=self.config.sql.max_limit,
+            )
             candidate_sql = repaired_sql
             if validate_sql_against_schema(candidate_sql, schema):
                 return _query_only_result()
         try:
             enforce_sql_rules(candidate_sql, max_limit=self.config.sql.max_limit)
-        except SqlGenerationError:
-            if sampler is None:
-                return _query_only_result()
-            if not fast_mode:
-                return _query_only_result()
-            try:
-                generated = _generate_rule_based_sql(
-                    question=sql_question,
-                    schema=schema,
+        except SqlGenerationError as exc:
+            if _is_sensitive_sql_error(exc) and sensitive_terms:
+                if sampler is None or schema_context is None or generator is None:
+                    return _sensitive_query_only_result(sensitive_terms)
+                try:
+                    repaired = generator.repair(
+                        question=sql_question,
+                        original_sql=candidate_sql,
+                        validation_error={
+                            "code": "SENSITIVE_FIELD",
+                            "message": "用户要求的敏感字段必须从 SELECT 中排除；如还有其他非敏感字段，请继续生成去敏后的 SQL。",
+                        },
+                        schema_context=schema_context,
+                    )
+                except SqlGenerationError:
+                    return _sensitive_query_only_result(sensitive_terms)
+                repaired_sql = _apply_limit_policy(
+                    repaired.sql,
+                    sql_question,
                     default_limit=self.config.sql.default_limit,
                     max_limit=self.config.sql.max_limit,
                 )
-                repaired_sql = None
-                candidate_sql = _apply_default_limit(generated.sql, sql_question, self.config.sql.default_limit)
-                enforce_sql_rules(candidate_sql, max_limit=self.config.sql.max_limit)
-            except SqlGenerationError:
-                return _query_only_result()
+                try:
+                    enforce_sql_rules(repaired_sql, max_limit=self.config.sql.max_limit)
+                except SqlGenerationError as repaired_exc:
+                    if _is_sensitive_sql_error(repaired_exc):
+                        return _sensitive_query_only_result(sensitive_terms)
+                    return _query_only_result()
+                generated = GeneratedSql(sql="", tables=[], placeholders=[])
+                candidate_sql = repaired_sql
+            else:
+                if sampler is None:
+                    return _query_only_result()
+                if not fast_mode:
+                    return _query_only_result()
+                try:
+                    generated = _generate_rule_based_sql(
+                        question=sql_question,
+                        schema=schema,
+                        default_limit=self.config.sql.default_limit,
+                        max_limit=self.config.sql.max_limit,
+                    )
+                    repaired_sql = None
+                    candidate_sql = _apply_limit_policy(
+                        generated.sql,
+                        sql_question,
+                        default_limit=self.config.sql.default_limit,
+                        max_limit=self.config.sql.max_limit,
+                    )
+                    enforce_sql_rules(candidate_sql, max_limit=self.config.sql.max_limit)
+                except SqlGenerationError:
+                    return _query_only_result()
         normalized_sql = self._validate_sql(context, user_question, candidate_sql)
         if sampler is not None and normalized_sql is None and schema_context is not None and generator is not None:
             try:
@@ -263,17 +323,29 @@ class SpongeAgent:
                         max_limit=self.config.sql.max_limit,
                     )
                     repaired_sql = None
-                    candidate_sql = _apply_default_limit(generated.sql, sql_question, self.config.sql.default_limit)
+                    candidate_sql = _apply_limit_policy(
+                        generated.sql,
+                        sql_question,
+                        default_limit=self.config.sql.default_limit,
+                        max_limit=self.config.sql.max_limit,
+                    )
                     enforce_sql_rules(candidate_sql, max_limit=self.config.sql.max_limit)
                     normalized_sql = self._validate_sql(context, user_question, candidate_sql, raise_on_error=True)
                 except SqlGenerationError:
                     return _query_only_result()
             else:
                 generated = GeneratedSql(sql="", tables=[], placeholders=[])
-                repaired_sql = _apply_default_limit(repaired.sql, sql_question, self.config.sql.default_limit)
+                repaired_sql = _apply_limit_policy(
+                    repaired.sql,
+                    sql_question,
+                    default_limit=self.config.sql.default_limit,
+                    max_limit=self.config.sql.max_limit,
+                )
                 try:
                     enforce_sql_rules(repaired_sql, max_limit=self.config.sql.max_limit)
-                except SqlGenerationError:
+                except SqlGenerationError as exc:
+                    if _is_sensitive_sql_error(exc) and sensitive_terms:
+                        return _sensitive_query_only_result(sensitive_terms)
                     return _query_only_result()
                 normalized_sql = self._validate_sql(context, user_question, repaired_sql, raise_on_error=True)
         if normalized_sql is None:
@@ -293,6 +365,13 @@ class SpongeAgent:
                 result_format,
                 _default_limit_notice(self.config.sql.default_limit),
             )
+        if sensitive_terms:
+            answer = _append_default_limit_notice(
+                answer,
+                user_question,
+                result_format,
+                _sensitive_field_notice(sensitive_terms),
+            )
         return QueryResult(
             answer=answer,
             generated_sql=generated.sql,
@@ -434,7 +513,17 @@ def _strip_result_format_instruction(question: str) -> str:
 
 def _query_only_result() -> QueryResult:
     return QueryResult(
-        answer="目前只能查询",
+        answer="已按当前 schema 判断，目前不支持该查询",
+        generated_sql="",
+        normalized_sql="",
+        repaired_sql=None,
+        validation={},
+    )
+
+
+def _sensitive_query_only_result(terms: list[str]) -> QueryResult:
+    return QueryResult(
+        answer=f"该查询包含敏感字段，{_sensitive_field_notice(terms)}已按当前 schema 判断，目前不支持该查询。",
         generated_sql="",
         normalized_sql="",
         repaired_sql=None,
@@ -452,6 +541,18 @@ def _business_metric_clarification_result(answer: str) -> QueryResult:
     )
 
 
+def _sensitive_field_notice(terms: list[str]) -> str:
+    if not terms:
+        return "已排除敏感字段。"
+    shown_terms = "、".join(terms[:3])
+    suffix = "等敏感字段" if len(terms) > 1 or shown_terms not in {"敏感字段"} else "等敏感字段"
+    return f"已排除{shown_terms}{suffix}。"
+
+
+def _is_sensitive_sql_error(exc: SqlGenerationError) -> bool:
+    return "sensitive field" in str(exc).lower()
+
+
 def _generate_with_sampler(
     *,
     generator: SamplingSqlGenerator,
@@ -478,7 +579,12 @@ def _generate_with_sampler(
             return GeneratedSql(sql="", tables=[], placeholders=[]), None
         return (
             GeneratedSql(sql="", tables=[], placeholders=[]),
-            _apply_default_limit(repaired.sql, question, generator.default_limit),
+            _apply_limit_policy(
+                repaired.sql,
+                question,
+                default_limit=generator.default_limit,
+                max_limit=generator.max_limit,
+            ),
         )
 
 
@@ -564,6 +670,71 @@ def _business_metric_clarification(question: str, schema: dict[str, Any]) -> str
     return "\n".join(lines)
 
 
+def _unsupported_requested_field_message(question: str, schema: dict[str, Any]) -> str | None:
+    if "供应商" not in question:
+        return None
+    if not re.search(r"(报名|工单|候选人|人员|清单|明细)", question):
+        return None
+    if not _schema_has_table(schema, "supplier") or not _schema_has_column(schema, "supplier", "nick_name"):
+        return "当前 schema 不支持“供应商”字段的查询，可联系管理员补充。"
+    if not _schema_supports_work_order_supplier_relation(schema):
+        return "当前 schema 缺少“供应商”的关联关系，可联系管理员补充。"
+    return None
+
+
+def _schema_supports_work_order_supplier_relation(schema: dict[str, Any]) -> bool:
+    return (
+        _schema_has_join(schema, "mvp_applied_jobs_by_helped_account", "c_helped_account")
+        and _schema_has_join(schema, "c_helped_account", "resume")
+        and (
+            _schema_has_join(schema, "resume", "supplier")
+            or (_schema_has_column(schema, "resume", "supplier_id") and _schema_has_column(schema, "supplier", "id"))
+        )
+    )
+
+
+def _schema_has_table(schema: dict[str, Any], table_name: str) -> bool:
+    tables = schema.get("tables", [])
+    return isinstance(tables, list) and any(
+        isinstance(table, dict) and str(table.get("tableName") or table.get("name") or "") == table_name
+        for table in tables
+    )
+
+
+def _schema_has_column(schema: dict[str, Any], table_name: str, column_name: str) -> bool:
+    tables = schema.get("tables", [])
+    if not isinstance(tables, list):
+        return False
+    for table in tables:
+        if not isinstance(table, dict) or str(table.get("tableName") or table.get("name") or "") != table_name:
+            continue
+        columns = table.get("columns", [])
+        if not isinstance(columns, list):
+            return False
+        return any(
+            isinstance(column, dict)
+            and str(column.get("columnName") or column.get("name") or "") == column_name
+            for column in columns
+        )
+    return False
+
+
+def _schema_has_join(schema: dict[str, Any], left_table: str, right_table: str) -> bool:
+    joins = schema.get("joins", [])
+    if not isinstance(joins, list):
+        return False
+    for join in joins:
+        if not isinstance(join, dict):
+            continue
+        join_tables = {
+            str(join.get("leftTable") or join.get("from") or ""),
+            str(join.get("rightTable") or join.get("to") or ""),
+        }
+        if {left_table, right_table} <= join_tables:
+            return True
+    return False
+
+
 def _ambiguous_business_metric_terms(question: str) -> list[str]:
     terms = (
         "漏斗",
@@ -608,19 +779,53 @@ def _schema_has_metric_definition(question: str, schema: dict[str, Any], metric_
     return any(term in metric_text for term in metric_terms for metric_text in metric_texts)
 
 
+def _apply_limit_policy(sql: str, question: str, *, default_limit: int, max_limit: int) -> str:
+    if _question_requests_all_rows(question):
+        return _replace_limit(sql, max_limit)
+    requested_limit = _requested_limit(question)
+    if requested_limit is not None:
+        return _replace_limit(sql, min(requested_limit, max_limit))
+    return _replace_limit(sql, default_limit)
+
+
 def _apply_default_limit(sql: str, question: str, default_limit: int) -> str:
     if _question_requests_limit(question):
-        return sql
-    return re.sub(r"\blimit\s+\d+\b", f"LIMIT {default_limit}", sql, count=1, flags=re.IGNORECASE)
+        return _replace_limit(sql, _requested_limit(question) or default_limit)
+    return _replace_limit(sql, default_limit)
+
+
+def _replace_limit(sql: str, limit: int) -> str:
+    return re.sub(r"\blimit\s+\d+\b", f"LIMIT {limit}", sql, count=1, flags=re.IGNORECASE)
 
 
 def _question_requests_limit(question: str) -> bool:
-    lowered = question.lower()
-    if re.search(r"\b(?:limit|top)\s+\d+\b", lowered):
+    if _question_requests_all_rows(question):
         return True
-    if re.search(r"(?:返回|展示|查询|列出|给我|取)\s*\d+\s*(?:条|行|个|项|家|名)", question):
-        return True
-    return bool(re.search(r"前\s*\d+\s*(?:条|行|个|项|家|名)?", question))
+    return _requested_limit(question) is not None
+
+
+def _requested_limit(question: str) -> int | None:
+    lowered = question.lower()
+    match = re.search(r"\b(?:limit|top)\s+(?P<limit>\d+)\b", lowered)
+    if match is None:
+        match = re.search(r"(?:返回|展示|查询|列出|给我|取)\s*(?P<limit>\d+)\s*(?:条|行|个|项|家|名)", question)
+    if match is None:
+        match = re.search(r"前\s*(?P<limit>\d+)\s*(?:条|行|个|项|家|名)?", question)
+    if match is None:
+        return None
+    try:
+        return int(match.group("limit"))
+    except (TypeError, ValueError):
+        return None
+
+
+def _question_requests_all_rows(question: str) -> bool:
+    lowered = question.lower()
+    return bool(
+        re.search(r"(所有|全部|全量|完整)", question)
+        or re.search(r"(导出|生成|下载).{0,12}(excel|xlsx|表格|文件)", lowered)
+        or re.search(r"(excel|xlsx).{0,12}(导出|生成|下载)", lowered)
+    )
 
 
 def _default_limit_notice(default_limit: int) -> str:

package/src/octopus_sponge_skill/config.py

@@ -63,7 +63,7 @@ def load_config() -> AppConfig:
             max_repair_attempts=2,
             default_limit=50,
             max_limit=500,
-            query_cache_path=PACKAGE_ROOT / "data/query-sql-cache.json",
+            query_cache_path=_optional_path("OCTOPUS_QUERY_SQL_CACHE_PATH"),
             query_cache_ttl_minutes=30,
         ),
         audit=AuditConfig(
@@ -75,3 +75,10 @@ def load_config() -> AppConfig:
 
 def load_config_from_env() -> AppConfig:
     return load_config()
+
+
+def _optional_path(env_name: str) -> Path | None:
+    value = os.getenv(env_name)
+    if value is None or not value.strip():
+        return None
+    return Path(value).expanduser()

package/src/octopus_sponge_skill/prompt_builder.py

@@ -6,19 +6,28 @@ from typing import Any
 from .schema_context_retriever import SchemaContext
 
 
-NL2SQL_SYSTEM_PROMPT = """你是 Octopus 的 Sponge 数据查询 SQL 生成器。
+NL2SQL_SYSTEM_PROMPT = """你是丸子Agent（Octopus Agent）的海绵数据 SQL 生成器。
 你只能基于提供的 schema context 生成 MySQL SELECT 查询。
 返回 JSON 中的 sql 字段必须直接以 SELECT 开头，不能返回非 SQL 文本。
 只生成业务 SQL，不要生成权限占位符或权限条件。
 不得使用 :scope.project_ids、:scope.brand_ids 或任何 :scope.* placeholder（占位符）。
 如果用户没有明确要求返回条数，LIMIT 必须使用 defaultLimit。
+如果用户要求所有数据、全部数据、全量数据、完整数据，或要求导出/生成 Excel/xlsx/表格文件，LIMIT 必须使用 maxLimit，不要使用 defaultLimit。
 不得查询 auth 库、密码、令牌、密钥、凭证字段。
+不得输出敏感字段，包括手机号、电话、联系方式、身份证、密码、token、secret、credential、private_key 等。
+如果用户要求敏感字段，必须从 SELECT 中排除这些字段；还有其他非敏感字段时继续生成去敏后的 SQL。
 不得生成 INSERT、UPDATE、DELETE、DDL、非 SELECT SQL 或多语句 SQL。
 SELECT 中每个输出字段都必须使用 AS 中文含义，例如 b.name AS 品牌名称。
 禁止使用英文别名，例如 brand_name、project_name。
 用户点名要求输出的字段，必须优先使用 schema context 中含义匹配的真实字段或真实关联表生成。
 不得为了凑齐字段写 NULL AS 字段名、CAST(NULL AS ...) AS 字段名 等空占位表达式。
 只有 schema context 中完全没有相关真实字段或关联表时，才允许不返回该字段；不要用空占位字段替代。
+用户明确给出品牌、项目、岗位、职位、门店等实体名称时，必须在对应名称字段上使用 LIKE 过滤，不要先查询全量或默认 LIMIT 列表再比对。
+名称类字段和状态文本类字段的筛选条件必须使用 LIKE '%值%'，例如 name、job_name、status_text、status_name。
+数字 ID、数字状态枚举、删除标记、时间范围和 JOIN ON 表关联条件不要改成 LIKE；例如 status = 1、is_delete = 0、a.id = b.id、create_at >= '2026-05-01' 保持原比较符。
+只有“名称包含/名称为/是/等于/招聘xx岗位/在招xx职位”等明确关系才能判定为岗位或职位名称；不要仅因逗号、空格、冒号相邻就推断岗位名称。
+业务查询必须一次生成完整 SQL；不要先查 brand、sponge_project、city、store、job_basic_info 等单表列表来找 ID，也不要要求外部先提供 ID。
+业务查询中需要按品牌、项目、城市、门店、岗位名称过滤时，必须 JOIN 对应表并直接使用 name 或 job_name LIKE。
 涉及业务指标或业务口径时，必须优先使用 schemaContext.metrics 中的 definition、aggregation 和 filters。
 如果 schemaContext.metrics 没有给出对应业务口径，不得自行推断状态枚举、有效性过滤或跨轮次分割规则。
 所有业务字段、状态枚举、状态映射、表关联方式必须来自 schemaContext.tables、schemaContext.joins、schemaContext.glossary、schemaContext.metrics 或 schemaContext.examples。

package/src/octopus_sponge_skill/roll_server.py

@@ -73,7 +73,7 @@ def tool_definitions() -> list[Json]:
     return [
         {
             "name": "diagnostic_status",
-            "description": "调试专用：检查 Octopus Sponge Agent 配置、缓存和本地持久化状态。普通业务查询不要先调用本工具，直接调用 query_sponge。",
+            "description": "调试专用：检查丸子Agent（Octopus Agent）配置、缓存和本地持久化状态。普通业务查询不要先调用本工具，直接调用 query_sponge。",
             "inputSchema": {
                 "type": "object",
                 "properties": {},
@@ -82,7 +82,7 @@ def tool_definitions() -> list[Json]:
         },
         {
             "name": "refresh_schema",
-            "description": "调试/运维专用：手动刷新本地 Schema Cache（表结构缓存）。只有用户明确要求刷新 schema 时才调用；普通业务查询不要先调用本工具。",
+            "description": "调试/运维专用：手动刷新本地 Schema Cache（表结构缓存）。只有用户明确要求刷新 schema 时才调用；普通业务查询不要先调用本工具；query_sponge 内部会先检查 schemaVersion 并按需刷新 schema cache，query_sponge 失败后也不要自动调用本工具。",
             "inputSchema": {
                 "type": "object",
                 "required": ["traceId"],
@@ -97,7 +97,7 @@ def tool_definitions() -> list[Json]:
         },
         {
             "name": "query_sponge",
-            "description": "业务查询唯一入口：把自然语言问题转换为只读 SQL，并通过 Sponge MCP Server 校验和执行。上层模型必须直接调用本工具；不要先调用 diagnostic_status 或 refresh_schema；不要自行生成 SQL；不要解释 schema；不要要求用户提供 SQL；不要改写用户问题。originalQuestion 必须传用户原始话术；如果 question 被上层改写，Agent 会忽略改写版并优先用 originalQuestion 生成 SQL、审计和缓存。对“匹配效果/分析报告/报名多但入职少/在招多但报名少/候选人多但岗位少”等报告类问题，必须只调用一次 query_sponge 处理完整原始问题，不要拆成多个品牌/项目/城市子查询。工具返回后应把 answer 原文复制到最终答复正文完整展示，不要只放在折叠步骤、思考过程或工具调用详情中；如果 answer 已包含分析报告，必须先展示完整报告，再展示总结关键发现；不要自行汇总替代 answer，不要追加“是否继续查询/是否需要更多字段/我可以继续帮你”等引导。默认 fastMode=true、finalAnswerOnly=true，会优先使用缓存和规则模板。",
+            "description": "业务查询唯一入口：把自然语言问题转换为只读 SQL，并通过 Sponge MCP Server 校验和执行。本工具内部第一步会检查本地 schemaVersion，并调用 Sponge get_schema 按需刷新 schema cache；普通业务查询不得额外调用 refresh_schema。上层模型必须直接调用本工具；不要先调用 diagnostic_status 或 refresh_schema；query_sponge 返回“目前不支持该查询”后也不要自行 retry fastMode=false 或再调用 refresh_schema，除非用户明确要求调试；不要自行生成 SQL；不要解释 schema；不要要求用户提供 SQL；不要改写用户问题。originalQuestion 必须传用户原始话术；如果 question 被上层改写，Agent 会忽略改写版并优先用 originalQuestion 生成 SQL、审计和缓存。对“匹配效果/分析报告/报名多但入职少/在招多但报名少/候选人多但岗位少”等报告类问题，必须只调用一次 query_sponge 处理完整原始问题，不要拆成多个品牌/项目/城市子查询。工具返回后应把 answer 原文复制到最终答复正文完整展示，不要只放在折叠步骤、思考过程或工具调用详情中；如果 answer 已包含分析报告，必须先展示完整报告，再展示总结关键发现；不要自行汇总替代 answer，不要追加“是否继续查询/是否需要更多字段/我可以继续帮你”等引导。默认 fastMode=true、finalAnswerOnly=true，会优先使用规则模板，复杂查询会使用 schema context 和 LLM 生成。",
             "inputSchema": {
                 "type": "object",
                 "required": ["question", "originalQuestion"],

package/src/octopus_sponge_skill/schema_context_retriever.py

@@ -26,13 +26,17 @@ LOCATION_RECRUITING_TABLES = (
 
 WORK_ORDER_DETAIL_TABLES = (
     "mvp_applied_jobs_by_helped_account",
-    "brand",
+    "c_helped_account",
+    "resume",
+    "job",
     "job_basic_info",
+    "brand",
+    "supplier",
     "sponge_project",
 )
 
 
-def retrieve_schema_context(schema: dict[str, Any], question: str, *, max_tables: int = 8) -> SchemaContext:
+def retrieve_schema_context(schema: dict[str, Any], question: str, *, max_tables: int = 12) -> SchemaContext:
     glossary = _matching_items(schema.get("glossary", []), question, keys=("term", "description"))
     metrics = _matching_items(schema.get("metrics", []), question, keys=("name", "metric", "description", "definition"))
     examples = _matching_items(schema.get("examples", []), question, keys=("question", "description"))
@@ -40,6 +44,7 @@ def retrieve_schema_context(schema: dict[str, Any], question: str, *, max_tables
     tables = _select_tables(schema.get("tables", []), question, table_names_from_context, max_tables)
     selected_table_names = {_table_name(table) for table in tables}
     joins = _filter_joins(schema.get("joins", []), selected_table_names)
+    joins = _append_derived_joins(schema, joins, selected_table_names)
     return SchemaContext(tables=tables, joins=joins, glossary=glossary, metrics=metrics, examples=examples)
 
 
@@ -167,6 +172,40 @@ def _filter_joins(joins: Any, selected_table_names: set[str]) -> list[dict[str,
     return result[:12]
 
 
+def _append_derived_joins(
+    schema: dict[str, Any],
+    joins: list[dict[str, Any]],
+    selected_table_names: set[str],
+) -> list[dict[str, Any]]:
+    result = list(joins)
+    existing = {
+        (
+            str(join.get("leftTable") or ""),
+            str(join.get("leftColumn") or ""),
+            str(join.get("rightTable") or ""),
+            str(join.get("rightColumn") or ""),
+        )
+        for join in result
+    }
+    if (
+        {"resume", "supplier"} <= selected_table_names
+        and _table_has_column(schema, "resume", "supplier_id")
+        and _table_has_column(schema, "supplier", "id")
+        and ("supplier", "id", "resume", "supplier_id") not in existing
+        and ("resume", "supplier_id", "supplier", "id") not in existing
+    ):
+        result.append(
+            {
+                "description": "简历和供应商关系；供应商名称可使用 supplier.nick_name",
+                "leftTable": "supplier",
+                "leftColumn": "id",
+                "rightTable": "resume",
+                "rightColumn": "supplier_id",
+            }
+        )
+    return result[:16]
+
+
 def _table_name(table: dict[str, Any]) -> str:
     return str(table.get("tableName") or table.get("name") or "")
 
@@ -177,6 +216,24 @@ def _column_text(column: dict[str, Any]) -> str:
     )
 
 
+def _table_has_column(schema: dict[str, Any], table_name: str, column_name: str) -> bool:
+    tables = schema.get("tables", [])
+    if not isinstance(tables, list):
+        return False
+    for table in tables:
+        if not isinstance(table, dict) or _table_name(table) != table_name:
+            continue
+        columns = table.get("columns", [])
+        if not isinstance(columns, list):
+            return False
+        return any(
+            isinstance(column, dict)
+            and str(column.get("columnName") or column.get("name") or "") == column_name
+            for column in columns
+        )
+    return False
+
+
 def _question_tokens(question: str) -> list[str]:
     lowered = question.lower()
     tokens = [lowered]
@@ -199,6 +256,9 @@ def _question_tokens(question: str) -> list[str]:
         "面试成功",
         "进行中",
         "姓名",
+        "人员",
+        "清单",
+        "供应商",
     ):
         if word in question:
             tokens.append(word)