@roll-agent/octopus-agent 0.0.2 → 0.0.5

package/README.md

@@ -1,4 +1,4 @@
-# Octopus Sponge NL2SQL Agent
+# 丸子Agent（Octopus Agent）
 
 本仓库实现 Octopus 对接 Sponge MCP Server 的第一版 MVP。
 

package/SKILL.md

@@ -1,15 +1,15 @@
 ---
 name: octopus-agent
-description: Octopus Sponge NL2SQL Agent，把自然语言问题转换为只读 SQL，并通过 Sponge MCP Server 校验和执行。
+description: 丸子Agent（Octopus Agent），把自然语言问题转换为只读 SQL，并通过 Sponge MCP Server 校验和执行。
 metadata:
   roll-env-file: references/env.yaml
 ---
 
-# Octopus Sponge Agent
+# 丸子Agent（Octopus Agent）
 
 ## 职责
 
-本 Agent 只负责 Sponge 数据查询：
+本 Agent 只负责海绵数据查询：
 
 - 读取和刷新 Schema Cache（表结构缓存）。
 - 基于用户问题和 schema context，通过 MCP Sampling（采样）请求 roll-core 代调 LLM 生成只读 SQL。
@@ -22,7 +22,7 @@ metadata:
 |-|-|-|
 | `diagnostic_status` | 诊断状态 | 检查配置、缓存和日志路径 |
 | `refresh_schema` | 刷新表结构 | 人工刷新本地 schema 缓存 |
-| `query_sponge` | 查询 Sponge 数据 | 自然语言查询入口 |
+| `query_sponge` | 查询海绵数据 | 自然语言查询入口 |
 
 `refresh_schema` 必填 `traceId`；Agent 会自动读取本地缓存里的 `schemaVersion` 并传给 Sponge。
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@roll-agent/octopus-agent",
-  "version": "0.0.2",
-  "description": "Octopus Sponge NL2SQL Agent",
+  "version": "0.0.5",
+  "description": "丸子Agent（Octopus Agent）",
   "license": "UNLICENSED",
   "keywords": [
     "roll-agent",

package/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "octopus-skill"
-version = "0.0.2"
-description = "Octopus Sponge NL2SQL Agent"
+version = "0.0.5"
+description = "丸子Agent（Octopus Agent）"
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = []

package/src/octopus_sponge_skill/__init__.py

@@ -1,4 +1,4 @@
-"""Octopus Sponge NL2SQL Agent."""
+"""丸子Agent（Octopus Agent）."""
 
 from ._version import __version__
 

package/src/octopus_sponge_skill/_version.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.0.2"
+__version__ = "0.0.5"

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,14 @@ 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)
         schema_version = str(schema.get("schemaVersion")) if schema.get("schemaVersion") is not None else None
         repaired_sql: str | None = None
         prefer_rule_based = is_recruiting_match_effect_query(sql_question)
@@ -159,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()
@@ -176,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()
@@ -189,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()
@@ -217,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:
@@ -260,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:
@@ -290,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,
@@ -431,7 +513,7 @@ 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,
@@ -439,6 +521,38 @@ def _query_only_result() -> QueryResult:
     )
 
 
+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,
+        validation={},
+    )
+
+
+def _business_metric_clarification_result(answer: str) -> QueryResult:
+    return QueryResult(
+        answer=answer,
+        generated_sql="",
+        normalized_sql="",
+        repaired_sql=None,
+        validation={},
+    )
+
+
+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,
@@ -465,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,
+            ),
         )
 
 
@@ -530,19 +649,183 @@ def _is_mutation_analytics_request(question: str) -> bool:
     )
 
 
+def _business_metric_clarification(question: str, schema: dict[str, Any]) -> str | None:
+    if is_recruiting_match_effect_query(question):
+        return None
+    metric_terms = _ambiguous_business_metric_terms(question)
+    if not metric_terms:
+        return None
+    if _schema_has_metric_definition(question, schema, metric_terms):
+        return None
+
+    lines = [
+        "这个查询涉及业务口径，我暂时不直接生成 SQL，避免结果口径不准。",
+        "",
+        "请先确认：",
+        f"1. 指标定义：“{'、'.join(metric_terms)}”具体包含哪些数据？",
+        "2. 时间口径：按哪个时间字段统计？",
+        "3. 状态口径：哪些状态算有效/成功/完成/异常？",
+        "4. 聚合维度：需要按什么维度展示？",
+    ]
+    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 = (
+        "漏斗",
+        "转化率",
+        "转化",
+        "有效",
+        "活跃",
+        "成功率",
+        "留存",
+        "履约",
+        "异常",
+        "质量",
+        "效率",
+        "趋势",
+        "健康度",
+        "达成率",
+        "完成率",
+    )
+    return [term for term in terms if term in question]
+
+
+def _schema_has_metric_definition(question: str, schema: dict[str, Any], metric_terms: list[str]) -> bool:
+    metric_texts: list[str] = []
+    for metric in schema.get("metrics") or []:
+        if not isinstance(metric, dict):
+            continue
+        parts: list[str] = []
+        for key in ("name", "term", "displayName", "definition", "description", "aggregation"):
+            value = metric.get(key)
+            if isinstance(value, str):
+                parts.append(value)
+        filters = metric.get("filters")
+        if isinstance(filters, list):
+            parts.extend(str(item) for item in filters)
+        metric_text = " ".join(parts)
+        if metric_text:
+            metric_texts.append(metric_text)
+            name = metric.get("name")
+            if isinstance(name, str) and name and name in question:
+                return True
+
+    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):
-        return True
-    if re.search(r"(?:返回|展示|查询|列出|给我|取)\s*\d+\s*(?:条|行|个|项|家|名)", question):
+    if _question_requests_all_rows(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)

package/src/octopus_sponge_skill/sql_generator.py

@@ -65,15 +65,12 @@ class RuleBasedSqlGenerator:
         if _is_multi_metric_query(question):
             raise SqlGenerationError("Multi-metric query requires schema-driven metric generation")
 
-        if ("品牌" in question or "brand" in lowered) and "brand" in table_names:
+        if ("品牌" in question or "brand" in lowered) and "brand" in table_names and _is_entity_lookup_query(question, "品牌"):
             brand_filter = _extract_brand_filter(question)
             brand_where = "b.is_delete = 0"
             if brand_filter is not None:
-                operator, brand_name = brand_filter
-                if operator == "contains":
-                    brand_where = f"b.is_delete = 0 AND b.name LIKE '%{_escape_sql_string(brand_name)}%'"
-                else:
-                    brand_where = f"b.is_delete = 0 AND b.name = '{_escape_sql_string(brand_name)}'"
+                _operator, brand_name = brand_filter
+                brand_where = f"b.is_delete = 0 AND b.name LIKE '%{_escape_sql_string(brand_name)}%'"
             sql = (
                 "SELECT b.id AS 品牌ID, b.name AS 品牌名称 "
                 "FROM brand b "
@@ -82,11 +79,15 @@ class RuleBasedSqlGenerator:
             )
             return GeneratedSql(sql, ["brand"], [])
 
-        if ("项目" in question or "project" in lowered) and "sponge_project" in table_names:
+        if ("项目" in question or "project" in lowered) and "sponge_project" in table_names and _is_entity_lookup_query(question, "项目"):
+            project_name = _extract_project_name(question)
+            project_where = "p.is_delete = 0"
+            if project_name is not None:
+                project_where = f"p.is_delete = 0 AND p.name LIKE '%{_escape_sql_string(project_name)}%'"
             sql = (
                 "SELECT p.id AS 项目ID, p.name AS 项目名称 "
                 "FROM sponge_project p "
-                "WHERE p.is_delete = 0 "
+                f"WHERE {project_where} "
                 f"LIMIT {self.default_limit}"
             )
             return GeneratedSql(sql, ["sponge_project"], [])
@@ -101,7 +102,7 @@ class RuleBasedSqlGenerator:
         if location and _has_recruiting_location_tables(table_names):
             escaped_location = _escape_sql_string(location)
             from_and_where = _append_job_time_range_condition(
-                _recruiting_location_from_and_where(escaped_location),
+                _append_job_name_condition(_recruiting_location_from_and_where(escaped_location), question),
                 question,
                 schema,
             )
@@ -123,7 +124,11 @@ class RuleBasedSqlGenerator:
             )
 
         if _is_recruiting_job_question(question) and _has_recruiting_tables(table_names):
-            from_and_where = _append_job_time_range_condition(_recruiting_from_and_where(), question, schema)
+            from_and_where = _append_job_time_range_condition(
+                _append_job_name_condition(_recruiting_from_and_where(), question),
+                question,
+                schema,
+            )
             if _question_requests_count(question):
                 sql = f"SELECT COUNT(DISTINCT jbi.id) AS 在招岗位数量 {from_and_where} LIMIT {self.default_limit}"
             else:
@@ -150,8 +155,11 @@ def enforce_sql_rules(sql: str, *, max_limit: int) -> None:
         raise SqlGenerationError("SQL contains a forbidden keyword")
     if re.search(r"\b(password|token|secret|credential|private_key)\b", normalized):
         raise SqlGenerationError("SQL contains a sensitive field")
+    if _sql_selects_sensitive_field(sql):
+        raise SqlGenerationError("SQL contains a sensitive field")
     if ":scope." in normalized:
         raise SqlGenerationError("SQL must not contain scope placeholders")
+    _enforce_text_filters_use_like(sql)
     _enforce_chinese_select_aliases(sql)
     _enforce_no_null_placeholder_select_items(sql)
     limit = re.search(r"\blimit\s+(\d+)\b", normalized)
@@ -161,11 +169,157 @@ def enforce_sql_rules(sql: str, *, max_limit: int) -> None:
         raise SqlGenerationError(f"SQL LIMIT must not exceed {max_limit}")
 
 
+SENSITIVE_FIELD_NAMES = {
+    "phone",
+    "mobile",
+    "tel",
+    "telephone",
+    "phone_number",
+    "mobile_number",
+    "mobile_phone",
+    "contact_phone",
+    "contact_mobile",
+    "contact_tel",
+    "id_card",
+    "idcard",
+    "identity_card",
+    "cert_no",
+    "certificate_no",
+    "password",
+    "token",
+    "secret",
+    "credential",
+    "private_key",
+}
+SENSITIVE_FIELD_SUFFIXES = ("_phone", "_mobile", "_tel")
+SENSITIVE_FIELD_LABELS = (
+    "手机号",
+    "手机号码",
+    "电话",
+    "电话号码",
+    "联系方式",
+    "身份证",
+    "身份证号",
+    "身份证号码",
+    "密码",
+    "令牌",
+    "密钥",
+    "凭证",
+)
+
+
+def sensitive_terms_in_text(text: str) -> list[str]:
+    lowered = text.lower()
+    terms: list[str] = []
+    for label in SENSITIVE_FIELD_LABELS:
+        if label in text:
+            terms.append(label)
+    english_terms = {
+        "phone": "手机号",
+        "mobile": "手机号",
+        "tel": "电话",
+        "telephone": "电话",
+        "id_card": "身份证",
+        "idcard": "身份证",
+        "password": "密码",
+        "token": "令牌",
+        "secret": "密钥",
+    }
+    for term, label in english_terms.items():
+        if re.search(rf"\b{re.escape(term)}\b", lowered) and label not in terms:
+            terms.append(label)
+    return list(dict.fromkeys(terms))
+
+
+def _sql_selects_sensitive_field(sql: str) -> bool:
+    select_clause = _top_level_select_clause(sql)
+    if select_clause is None:
+        return False
+    return any(_select_item_contains_sensitive_field(item) for item in _split_select_items(select_clause))
+
+
+def _top_level_select_clause(sql: str) -> str | None:
+    match = re.search(r"\bselect\b(?P<select>.*?)\bfrom\b", sql, flags=re.IGNORECASE | re.DOTALL)
+    if match is None:
+        return None
+    return match.group("select")
+
+
+def _split_select_items(select_clause: str) -> list[str]:
+    items: list[str] = []
+    start = 0
+    depth = 0
+    quote: str | None = None
+    for index, char in enumerate(select_clause):
+        if quote is not None:
+            if char == quote:
+                quote = None
+            continue
+        if char in {"'", '"', "`"}:
+            quote = char
+        elif char == "(":
+            depth += 1
+        elif char == ")" and depth > 0:
+            depth -= 1
+        elif char == "," and depth == 0:
+            items.append(select_clause[start:index].strip())
+            start = index + 1
+    tail = select_clause[start:].strip()
+    if tail:
+        items.append(tail)
+    return items
+
+
+def _select_item_contains_sensitive_field(item: str) -> bool:
+    if any(label in item for label in SENSITIVE_FIELD_LABELS):
+        return True
+    identifiers = re.findall(r"\b[a-zA-Z_][a-zA-Z0-9_]*\b", item.lower())
+    for identifier in identifiers:
+        if identifier in {"select", "case", "when", "then", "else", "end", "as", "if", "null", "coalesce"}:
+            continue
+        if identifier in SENSITIVE_FIELD_NAMES or identifier.endswith(SENSITIVE_FIELD_SUFFIXES):
+            return True
+    return False
+
+
+def _enforce_text_filters_use_like(sql: str) -> None:
+    for match in re.finditer(
+        r"\b(?:where|and|or|having)\s*\(?\s*(?:[a-zA-Z_][a-zA-Z0-9_]*\.)?"
+        r"(?P<column>[a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*'(?P<value>[^']*)'",
+        sql,
+        flags=re.IGNORECASE,
+    ):
+        column = match.group("column").lower()
+        value = match.group("value").strip()
+        if _is_name_filter_column(column) or (_is_status_text_filter_column(column) and not _is_numeric_literal(value)):
+            raise SqlGenerationError("SQL text filters must use LIKE")
+
+
+def _is_name_filter_column(column: str) -> bool:
+    return column == "name" or column == "job_name" or column.endswith("_name")
+
+
+def _is_status_text_filter_column(column: str) -> bool:
+    return column in {"status", "state"} or column.endswith("_status") or column.endswith("_state")
+
+
+def _is_numeric_literal(value: str) -> bool:
+    return bool(re.fullmatch(r"-?\d+(?:\.\d+)?", value))
+
+
 def is_low_quality_sql_for_question(question: str, sql: str) -> bool:
     normalized = re.sub(r"\s+", " ", sql.strip().lower())
+    if _is_business_query(question) and _is_single_entity_lookup_sql(sql):
+        return True
     brand_filter = _extract_brand_filter(question)
     if brand_filter is not None and _sql_references_brand_table(sql) and not _sql_contains_brand_name_filter(sql, brand_filter[1]):
         return True
+    project_name = _extract_project_name(question)
+    if project_name is not None and _sql_references_table(sql, "sponge_project") and not _sql_contains_name_filter(sql, project_name):
+        return True
+    job_name = _extract_job_name_filter(question)
+    if job_name is not None and _sql_references_table(sql, "job_basic_info") and not _sql_contains_job_name_filter(sql, job_name):
+        return True
     if _is_work_order_detail_query(question):
         if "mvp_applied_jobs_by_helped_account" not in normalized:
             return True
@@ -352,12 +506,27 @@ def _generate_recruiting_detail_sql(question: str, schema: dict[str, Any], defau
         raise SqlGenerationError("job_basic_info is required for recruiting detail query")
 
     select_items = _recruiting_detail_select_items(question, schema)
-    from_and_where = _append_job_time_range_condition(_recruiting_detail_from_and_where(table_names), question, schema)
+    city_brand_filter = _extract_city_brand_filter(question)
+    location = _extract_location_for_recruiting_job_question(question)
+    brand_name = _extract_brand_name(question)
+    city_only_location = False
+    if city_brand_filter is not None:
+        location = city_brand_filter[0]
+        city_only_location = True
+        if brand_name is None:
+            brand_name = city_brand_filter[1]
+    location = location if location and _has_recruiting_location_tables(table_names) else None
+    brand_name = brand_name if brand_name and "brand" in table_names else None
+    from_and_where = _append_job_time_range_condition(
+        _recruiting_detail_from_and_where(table_names, location, brand_name, city_only_location),
+        question,
+        schema,
+    )
     order_by = _job_order_by(question, schema)
     sql = f"SELECT DISTINCT {', '.join(select_items)} {from_and_where} {order_by} LIMIT {default_limit}"
     tables = [
         table
-        for table in ("job_basic_info", "job_store", "store", "job_salary", "job_hiring_requirement")
+        for table in ("job_basic_info", "job_address", "job_store", "store", "province", "city", "region", "brand", "job_salary", "job_hiring_requirement")
         if table in table_names
     ]
     return GeneratedSql(sql, tables, [])
@@ -374,8 +543,8 @@ def _generate_work_order_detail_sql(question: str, schema: dict[str, Any], defau
     if not sql:
         raise SqlGenerationError("Work order detail schema example has no SQL")
     sql = re.sub(
-        r"b\.name\s*=\s*'[^']*'",
-        f"b.name = '{_escape_sql_string(brand_name)}'",
+        r"b\.name\s*(?:=|LIKE)\s*'%?[^']*%?'",
+        f"b.name LIKE '%{_escape_sql_string(brand_name)}%'",
         sql,
         count=1,
         flags=re.IGNORECASE,
@@ -682,17 +851,37 @@ def _match_effect_match_metric_sql(
     )
 
 
-def _recruiting_detail_from_and_where(table_names: set[str]) -> str:
+def _recruiting_detail_from_and_where(
+    table_names: set[str],
+    location: str | None = None,
+    brand_name: str | None = None,
+    city_only_location: bool = False,
+) -> str:
     parts = ["FROM job_basic_info jbi"]
+    if location is not None and "job_address" in table_names:
+        parts.append("LEFT JOIN job_address ja ON ja.job_id = jbi.job_id AND ja.delete_at IS NULL")
     if "job_store" in table_names:
         parts.append("LEFT JOIN job_store js ON js.job_basic_info_id = jbi.id AND js.is_deleted = 0")
     if {"job_store", "store"} <= table_names:
         parts.append("LEFT JOIN store s ON s.id = js.store_id AND s.delete_at IS NULL")
+    if brand_name is not None and "brand" in table_names:
+        parts.append("LEFT JOIN brand b ON b.id = jbi.brand_id AND b.is_delete = 0")
     if "job_salary" in table_names:
         parts.append("LEFT JOIN job_salary jsa ON jsa.job_basic_info_id = jbi.id AND jsa.is_deleted = 0")
     if "job_hiring_requirement" in table_names:
         parts.append("LEFT JOIN job_hiring_requirement jhr ON jhr.job_basic_info_id = jbi.id AND jhr.is_deleted = 0")
-    parts.append("WHERE jbi.is_deleted = 0 AND jbi.status = 1")
+    where = "WHERE jbi.is_deleted = 0 AND jbi.status = 1"
+    if location is not None:
+        escaped_location = _escape_sql_string(location)
+        location_condition = (
+            _recruiting_city_condition(escaped_location)
+            if city_only_location
+            else _recruiting_location_condition(escaped_location)
+        )
+        where = f"{where} AND {location_condition}"
+    if brand_name is not None:
+        where = f"{where} AND b.name LIKE '%{_escape_sql_string(brand_name)}%'"
+    parts.append(where)
     return " ".join(parts)
 
 
@@ -836,6 +1025,17 @@ def _recruiting_location_condition(location: str) -> str:
     )
 
 
+def _recruiting_city_condition(location: str) -> str:
+    return (
+        "("
+        "EXISTS ("
+        "SELECT 1 FROM city c "
+        f"WHERE ({_city_name_matches(location)}) "
+        "AND (ja.city_id = c.id OR s.city_id = c.id OR FIND_IN_SET(c.id, jbi.city_ids) > 0)"
+        "))"
+    )
+
+
 def _append_job_time_range_condition(from_and_where: str, question: str, schema: dict[str, Any]) -> str:
     time_range = _extract_time_range(question, schema)
     if time_range is None:
@@ -846,6 +1046,13 @@ def _append_job_time_range_condition(from_and_where: str, question: str, schema:
     )
 
 
+def _append_job_name_condition(from_and_where: str, question: str) -> str:
+    job_name = _extract_job_name_filter(question)
+    if job_name is None:
+        return from_and_where
+    return f"{from_and_where} AND jbi.job_name LIKE '%{_escape_sql_string(job_name)}%'"
+
+
 def _extract_time_range(question: str, schema: dict[str, Any] | None = None) -> TimeRange | None:
     field = _resolve_job_time_field(question, schema or {})
     if field is None:
@@ -1073,6 +1280,7 @@ def _extract_location_for_recruiting_job_question(question: str) -> str | None:
         r"(?P<location>[\u4e00-\u9fff]{2,12}?)(?:有)?(?:多少|几|数量|总数).*?(?:在招|招聘)(?:岗位|职位)",
         r"(?P<location>[\u4e00-\u9fff]{2,12}?)(?:的)?(?:在招|招聘)(?:岗位|职位)",
         r"(?P<location>[\u4e00-\u9fff]{2,12}?)(?:有|有哪些|有什么).*?(?:在招|招聘)(?:岗位|职位)",
+        r"(?P<location>[\u4e00-\u9fff]{2,12}?)(?:的)?(?:岗位|职位)",
         r"(?:在|位于)(?P<location>[\u4e00-\u9fff]{2,12}?)(?:的)?(?:岗位|职位)",
     ]
     for pattern in patterns:
@@ -1099,6 +1307,63 @@ def _is_work_order_detail_query(question: str) -> bool:
     )
 
 
+def _is_entity_lookup_query(question: str, entity: str) -> bool:
+    if _is_business_query(question):
+        return False
+    if entity == "品牌" and _extract_brand_filter(question) is not None:
+        return True
+    if entity == "项目" and _extract_project_name(question) is not None:
+        return True
+    if re.search(r"(列表|清单|信息|有哪些|哪些|我能看到|可见|能看到|查询.*(?:品牌|项目)|查看.*(?:品牌|项目))", question):
+        return True
+    return bool(re.fullmatch(rf"\s*(?:查询|查看|列出)?\s*{entity}\s*", question))
+
+
+def _is_business_query(question: str) -> bool:
+    return bool(
+        re.search(
+            r"(报名|工单|候选人|入职|上岗|在招|招聘|岗位|职位|门店|剩余|转化|漏斗|匹配|统计|多少|几|数量|总数|人数|数)",
+            question,
+        )
+    )
+
+
+def _is_single_entity_lookup_sql(sql: str) -> bool:
+    normalized = re.sub(r"\s+", " ", sql.strip().lower())
+    table_aliases = _sql_table_aliases(normalized)
+    referenced_tables = set(table_aliases.values())
+    entity_tables = {"brand", "sponge_project", "city", "province", "region", "store"}
+    if len(referenced_tables) != 1 or not referenced_tables <= entity_tables:
+        return False
+    if " limit " not in f" {normalized} ":
+        return False
+    return bool(re.search(r"\b(?:id|name|job_name)\b", normalized))
+
+
+_ENTITY_NAME_CHARS = r"[\u4e00-\u9fffA-Za-z0-9（）()·_\-]{1,40}"
+_ENTITY_SEPARATOR = r"[\s:：,，、;；]+"
+_DIRECT_MUNICIPALITIES = ("上海", "北京", "天津", "重庆")
+
+
+def _extract_city_brand_filter(question: str) -> tuple[str, str] | None:
+    if not _is_recruiting_job_question(question):
+        return None
+    text = re.sub(r"(根据|我要|海绵数据|帮我查询|帮我查|帮我|查询|查看|看看|当前|目前|现在|，|,|。|\s)", "", question)
+    patterns = [
+        r"(?P<city>[\u4e00-\u9fff]{2,8}?(?:省|市|区|县))(?P<brand>[\u4e00-\u9fffA-Za-z0-9（）()·_\-]{1,40}?)(?:当前|目前|现在)?(?:在招|招聘)(?:岗位|职位)",
+        rf"(?P<city>{'|'.join(_DIRECT_MUNICIPALITIES)})(?P<brand>[\u4e00-\u9fffA-Za-z0-9（）()·_\-]{{1,40}}?)(?:当前|目前|现在)?(?:在招|招聘)(?:岗位|职位)",
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, text)
+        if match is None:
+            continue
+        location = _clean_location_candidate(match.group("city"), require_location_signal=True)
+        brand = _clean_brand_candidate(match.group("brand"))
+        if location is not None and brand is not None:
+            return location, brand
+    return None
+
+
 def _extract_brand_filter(question: str) -> tuple[str, str] | None:
     contains_patterns = [
         r"品牌(?:名称)?(?:包含|含有|模糊匹配|like)(?P<brand>.+?)(?:，|,|。|；|;|的品牌|品牌信息|包括|返回|$)",
@@ -1113,8 +1378,9 @@ def _extract_brand_filter(question: str) -> tuple[str, str] | None:
             return "contains", brand
 
     exact_patterns = [
-        r"品牌(?:名称)?(?:为|是|=|等于)(?P<brand>.+?)(?:，|,|。|；|;|候选人|工单|报名|提供|输出|通过|包括|返回|$)",
-        r"(?P<brand>[\u4e00-\u9fffA-Za-z0-9（）()·_\-]{2,40})品牌(?:下|的)?",
+        rf"品牌(?:名称)?(?:为|是|=|等于|:|：)(?:{_ENTITY_SEPARATOR})?(?P<brand>{_ENTITY_NAME_CHARS})",
+        rf"品牌{_ENTITY_SEPARATOR}(?P<brand>{_ENTITY_NAME_CHARS})",
+        rf"(?P<brand>{_ENTITY_NAME_CHARS})(?:{_ENTITY_SEPARATOR})?品牌(?:下|的)?",
     ]
     for pattern in exact_patterns:
         match = re.search(pattern, question)
@@ -1131,30 +1397,94 @@ def _extract_brand_name(question: str) -> str | None:
     return brand_filter[1] if brand_filter is not None else None
 
 
+def _extract_project_name(question: str) -> str | None:
+    patterns = [
+        r"项目(?:名称)?(?:包含|含有|模糊匹配|like)(?P<name>.+?)(?:，|,|。|；|;|项目信息|包括|返回|$)",
+        rf"项目(?:名称)?(?:为|是|=|等于|:|：)(?:{_ENTITY_SEPARATOR})?(?P<name>{_ENTITY_NAME_CHARS})",
+        rf"项目{_ENTITY_SEPARATOR}(?P<name>{_ENTITY_NAME_CHARS})",
+        rf"(?P<name>{_ENTITY_NAME_CHARS})(?:{_ENTITY_SEPARATOR})?项目(?:下|的)?",
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, question, flags=re.IGNORECASE)
+        if match is None:
+            continue
+        project = _clean_entity_candidate(match.group("name"), extra_forbidden=("品牌", "岗位", "职位", "报名"))
+        if project is not None:
+            return project
+    return None
+
+
+def _extract_job_name_filter(question: str) -> str | None:
+    patterns = [
+        r"(?:岗位|职位)(?:名称)?(?:包含|含有|模糊匹配|like)(?P<name>.+?)(?:，|,|。|；|;|岗位信息|职位信息|包括|返回|$)",
+        rf"(?:岗位|职位)(?:名称)?(?:为|是|=|等于|:|：)(?:{_ENTITY_SEPARATOR})?(?P<name>{_ENTITY_NAME_CHARS})",
+        rf"(?:招聘|在招|招|急招)(?:{_ENTITY_SEPARATOR})?(?P<name>{_ENTITY_NAME_CHARS})(?:岗位|职位)",
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, question, flags=re.IGNORECASE)
+        if match is None:
+            continue
+        job_name = _clean_entity_candidate(match.group("name"), extra_forbidden=("品牌", "项目", "门店", "报名"))
+        if job_name is not None:
+            return job_name
+    return None
+
+
 def _clean_brand_candidate(value: str) -> str | None:
+    return _clean_entity_candidate(
+        value,
+        extra_forbidden=("岗位", "候选人", "报名", "入职", "在招", "招聘", "数量", "多少"),
+        suffix_pattern=r"(的品牌信息|品牌信息|的品牌|品牌|的|下)$",
+    )
+
+
+def _clean_entity_candidate(
+    value: str,
+    *,
+    extra_forbidden: tuple[str, ...] = (),
+    suffix_pattern: str = r"(的|下)$",
+) -> str | None:
     brand = re.sub(r"\s+", "", value)
-    brand = brand.strip("\"'“”‘’%")
+    brand = brand.strip("\"'“”‘’%:：,，、;；")
     brand = re.sub(r"^(名称为|名称是|为|是|=|等于)", "", brand)
-    brand = re.sub(r"(的品牌信息|品牌信息|的品牌|品牌|的|下)$", "", brand)
-    brand = brand.strip("\"'“”‘’%")
-    if 2 <= len(brand) <= 40 and re.search(r"(查询|查看|给我|帮我|根据|roll-core|岗位|候选人|报名|入职|在招|招聘|数量|多少)", brand) is None:
+    brand = re.sub(suffix_pattern, "", brand)
+    brand = brand.strip("\"'“”‘’%:：,，、;；")
+    forbidden = ("查询", "查看", "给我", "帮我", "根据", "roll-core", "信息", "数据") + extra_forbidden
+    if 2 <= len(brand) <= 40 and not any(term in brand for term in forbidden):
         return brand
     return None
 
 
 def _sql_references_brand_table(sql: str) -> bool:
-    return "brand" in _sql_table_aliases(sql.lower()).values()
+    return _sql_references_table(sql, "brand")
 
 
 def _sql_contains_brand_name_filter(sql: str, brand_name: str) -> bool:
+    return _sql_contains_name_filter(sql, brand_name)
+
+
+def _sql_references_table(sql: str, table_name: str) -> bool:
+    return table_name in _sql_table_aliases(sql.lower()).values()
+
+
+def _sql_contains_name_filter(sql: str, name: str) -> bool:
     normalized = sql.lower()
-    escaped = re.escape(_escape_sql_string(brand_name).lower())
+    escaped = re.escape(_escape_sql_string(name).lower())
     return bool(
         re.search(rf"\b[a-zA-Z_][a-zA-Z0-9_]*\.name\s*(?:=|like)\s*['\"]%?{escaped}%?['\"]", normalized)
         or re.search(rf"\bname\s*(?:=|like)\s*['\"]%?{escaped}%?['\"]", normalized)
     )
 
 
+def _sql_contains_job_name_filter(sql: str, job_name: str) -> bool:
+    normalized = sql.lower()
+    escaped = re.escape(_escape_sql_string(job_name).lower())
+    return bool(
+        re.search(rf"\bjbi\.job_name\s*(?:=|like)\s*['\"]%?{escaped}%?['\"]", normalized)
+        or re.search(rf"\bjob_name\s*(?:=|like)\s*['\"]%?{escaped}%?['\"]", normalized)
+    )
+
+
 def _is_monthly_recruiting_conversion_query(question: str) -> bool:
     return bool(
         re.search(r"(全年|年内|每月|月度)", question)
@@ -1203,11 +1533,11 @@ def _is_multi_metric_query(question: str) -> bool:
 
 
 def _requires_recruiting_detail_joins(question: str) -> bool:
-    if re.search(r"(明细|详情|包含|需要|显示|带上|返回)", question) is None:
+    if re.search(r"(明细|详情|信息|包含|需要|显示|带上|返回|字段)", question) is None:
         return False
     return bool(
         re.search(
-            r"(门店|薪资|学历|经验|年龄|技能|用人要求|招聘人数|岗位类型|职能类别|工作年限|薪资范围|薪资类型|岗位描述)",
+            r"(门店|门店地址|详细地址|精确地址|地址|薪资|学历|经验|年龄|技能|用人要求|招聘人数|岗位类型|职能类别|工作年限|薪资范围|薪资类型|岗位描述)",
             question,
         )
     )
@@ -1285,7 +1615,7 @@ def _escape_sql_string(value: str) -> str:
 def _province_name_matches(location: str) -> str:
     literal = f"'{location}'"
     return (
-        f"p.name = {literal} OR "
+        f"p.name LIKE '%{location}%' OR "
         "REPLACE(REPLACE(REPLACE(REPLACE(p.name, '特别行政区', ''), '自治区', ''), '省', ''), '市', '') = "
         f"REPLACE(REPLACE(REPLACE(REPLACE({literal}, '特别行政区', ''), '自治区', ''), '省', ''), '市', '')"
     )
@@ -1294,7 +1624,7 @@ def _province_name_matches(location: str) -> str:
 def _city_name_matches(location: str) -> str:
     literal = f"'{location}'"
     return (
-        f"c.name = {literal} OR "
+        f"c.name LIKE '%{location}%' OR "
         "REPLACE(REPLACE(REPLACE(c.name, '自治州', ''), '地区', ''), '市', '') = "
         f"REPLACE(REPLACE(REPLACE({literal}, '自治州', ''), '地区', ''), '市', '')"
     )
@@ -1303,7 +1633,7 @@ def _city_name_matches(location: str) -> str:
 def _region_name_matches(location: str) -> str:
     literal = f"'{location}'"
     return (
-        f"r.name = {literal} OR "
+        f"r.name LIKE '%{location}%' OR "
         "REPLACE(REPLACE(REPLACE(r.name, '自治县', ''), '区', ''), '县', '') = "
         f"REPLACE(REPLACE(REPLACE({literal}, '自治县', ''), '区', ''), '县', '')"
     )