R3.2.8.6-R1.3B Context-Aware AI-Writing Trace Guard

config.py

@@ -161,8 +161,7 @@ def load_config():
                 "pivotal", "foster", "seamlessly", "multifaceted",
                 "beacon", "landscape", "underscore", "robust",
                 "firstly", "secondly", "moreover", "furthermore",
-                "in conclusion", "to summarize", "as an ai",
-                "ai-generated", "this response",
+                "in conclusion", "to summarize",
             ],
         },
         "openalex_api_url": os.environ.get("OPENALEX_API_URL", "https://api.openalex.org/works"),

core/pipeline_agent.py

@@ -26,6 +26,7 @@ except ImportError:
     LANGDETECT_AVAILABLE = False
 
 from config import APP_CONFIG
+from core.production_guard import find_authorial_ai_meta_spans
 
 
 class DeepSeekAPIError(RuntimeError):
@@ -3182,16 +3183,75 @@ Return exactly:
 
     @staticmethod
     def _remove_ai_meta_traces(text):
-        patterns = [
-            r'(?im)^.*\bas an ai(?: language model)?\b.*(?:\n|$)',
-            r'(?im)^.*\bai[- ]generated\b.*(?:\n|$)',
-            r'(?im)^.*\bthis response\b.*(?:\n|$)',
-            r'(?im)^.*\bi cannot (?:browse|access|verify)\b.*(?:\n|$)',
-        ]
+        """Bounded deterministic repair for high-confidence authorial meta only.
+
+        R1.3B deliberately does not treat AI-related words as traces.  Protected
+        quotations/references are excluded by the shared classifier, and a
+        finding removes only its affected sentence/clause rather than a whole
+        Markdown line/paragraph.  Headings are never rewritten here; unresolved
+        heading-level traces are left for the final validating guard.
+        """
         value = str(text or '')
-        for pattern in patterns:
-            value = re.sub(pattern, '', value)
-        return re.sub(r'\n{3,}', '\n\n', value).strip()
+        findings = find_authorial_ai_meta_spans(value)
+        if not findings:
+            return value.strip()
+
+        spans = []
+        sentence_breaks = '.!?。！？;；\n'
+        for finding in findings:
+            start = int(finding.get('start', 0))
+            end = int(finding.get('end', start))
+
+            left_positions = [value.rfind(mark, 0, start) for mark in sentence_breaks]
+            left_boundary = max(left_positions)
+            left = left_boundary + 1 if left_boundary >= 0 else 0
+
+            right_candidates = [value.find(mark, end) for mark in sentence_breaks]
+            right_candidates = [pos for pos in right_candidates if pos >= 0]
+            if right_candidates:
+                right_mark = min(right_candidates)
+                right = right_mark + 1
+            else:
+                right = len(value)
+
+            # Never damage a Markdown heading or a mixed sentence carrying
+            # protected academic objects.  Unsafe-to-repair traces remain in
+            # place so the final validating guard can fail closed rather than
+            # silently deleting hypotheses, numbers, citations, or quotations.
+            line_start = value.rfind('\n', 0, start) + 1
+            candidate = value[left:right]
+            if value[line_start:start].lstrip().startswith('#'):
+                continue
+            if (
+                re.search(r'\bH\d+[A-Za-z]?\b', candidate)
+                or re.search(r'(?<![A-Za-z])[-+]?\d+(?:\.\d+)?%?', candidate)
+                or re.search(r'\[\[SP-(?:P|C|T)', candidate, flags=re.I)
+                or re.search(r'\[?CITE-\d+', candidate, flags=re.I)
+                or re.search(r'["“”«»「」『』]', candidate)
+            ):
+                continue
+            spans.append((left, right))
+
+        if not spans:
+            return value.strip()
+
+        merged = []
+        for start, end in sorted(spans):
+            if merged and start <= merged[-1][1]:
+                merged[-1][1] = max(merged[-1][1], end)
+            else:
+                merged.append([start, end])
+
+        pieces = []
+        cursor = 0
+        for start, end in merged:
+            pieces.append(value[cursor:start])
+            cursor = end
+        pieces.append(value[cursor:])
+        repaired = ''.join(pieces)
+        repaired = re.sub(r'[ \t]{2,}', ' ', repaired)
+        repaired = re.sub(r'\n{3,}', '\n\n', repaired)
+        return repaired.strip()
 
     def polish_academic_section(self, text, section_name='', abstract=False, mode='amj'):
         value = self._remove_ai_meta_traces(text)

core/production_guard.py

@@ -54,13 +54,311 @@ def validate_docx_bytes(data: bytes, *, minimum_paragraphs: int = 8) -> None:
         )
 
 
+
+_REFERENCE_HEADING_RE = re.compile(
+    r"(?im)^#\s+(?:References|参考文献|Литература|Пайдаланылған әдебиеттер)\s*$"
+)
+_HARD_SP_MARKER_RE = re.compile(
+    r"\[\[SP-(?:P|C|T)(?:\d{6}|x{6})\]\]",
+    flags=re.IGNORECASE,
+)
+_UNRESOLVED_CITE_RE = re.compile(
+    r"(?<![A-Za-z0-9_])\[?CITE-\d+\]?(?![A-Za-z0-9_])",
+    flags=re.IGNORECASE,
+)
+
+# R1.3B uses one semantic taxonomy with bounded language profiles.  These
+# patterns intentionally require relations (role + first person, capability
+# disclaimer, current artifact + AI actor + writing action, or current-response
+# frame + first-person answer action).  AI-domain vocabulary alone is never a
+# finding.
+_AUTHORIAL_META_PATTERNS = (
+    # English
+    ("en", "assistant_self_identity", re.compile(
+        r"\bas an\s+(?:ai|artificial intelligence)(?:\s+language)?"
+        r"(?:\s+(?:model|assistant))?\s*,?\s*"
+        r"(?:i|we)\s+(?:am|are|can(?:not|'t)?|will|would|shall|"
+        r"do|don't|have|lack|provide|help|summarize|write|draft|generate)\b",
+        re.IGNORECASE,
+    )),
+    ("en", "capability_disclaimer", re.compile(
+        r"\bi\s+(?:cannot|can't|am\s+unable\s+to)\s+"
+        r"(?:browse|access|verify|open|retrieve|check|confirm)\b",
+        re.IGNORECASE,
+    )),
+    ("en", "current_artifact_ai_writing", re.compile(
+        r"\b(?:this|the\s+current|the)\s+(?:manuscript|paper|article|section)\s+"
+        r"(?:was|is|has\s+been)\s+"
+        r"(?:generated|written|drafted|authored|composed|prepared)\s+"
+        r"(?:by|using)\s+"
+        r"(?:an?\s+)?(?:ai(?:\s+(?:assistant|model))?|artificial intelligence|"
+        r"generative ai|llm|language model|chatgpt)\b",
+        re.IGNORECASE,
+    )),
+    ("en", "current_artifact_ai_writing", re.compile(
+        r"\b(?:ai(?:\s+(?:assistant|model))?|artificial intelligence|"
+        r"generative ai|llm|language model|chatgpt)\s+"
+        r"(?:was|is|has\s+been)\s+used\s+to\s+"
+        r"(?:draft|write|generate|author|compose|prepare)\s+"
+        r"(?:this|the\s+current|the)\s+(?:manuscript|paper|article|section)\b",
+        re.IGNORECASE,
+    )),
+    ("en", "current_response_frame", re.compile(
+        r"\b(?:in\s+(?:this|the\s+current)\s+(?:response|answer)|below)\s*,?\s*"
+        r"(?:i|we)\s+(?:(?:will|can|shall|would)\s+)?"
+        r"(?:summarize|provide|present|discuss|explain|outline|draft|write|answer)\b",
+        re.IGNORECASE,
+    )),
+    # Chinese
+    ("zh", "assistant_self_identity", re.compile(
+        r"作为(?:人工智能|AI)(?:语言)?(?:模型|助手)[，,]?\s*"
+        r"我(?:无法|不能|可以|能|将|会|能够|可)"
+    )),
+    ("zh", "capability_disclaimer", re.compile(
+        r"我(?:无法|不能)(?:浏览|访问|核实|验证|查证|获取|打开)"
+    )),
+    ("zh", "current_artifact_ai_writing", re.compile(
+        r"(?:本文|本论文|本稿|本手稿|本节|本章节|这篇论文|这篇文章|这个章节|这一节)"
+        r"\s*(?:由|是由)\s*(?:ChatGPT|人工智能|AI|大语言模型|语言模型|AI助手|人工智能助手)"
+        r".{0,20}?(?:生成|撰写|写成|起草|编写|创作|准备)"
+    )),
+    ("zh", "current_artifact_ai_writing", re.compile(
+        r"(?:ChatGPT|人工智能|AI|大语言模型|语言模型|AI助手|人工智能助手)"
+        r"\s*(?:被)?用于(?:生成|撰写|写作|起草|编写|准备)"
+        r"\s*(?:本文|本论文|本稿|本手稿|本节|本章节|这篇论文|这篇文章)"
+    )),
+    ("zh", "current_response_frame", re.compile(
+        r"(?:在)?(?:本回答|此回答|本回复|此回复)中?[，,]?\s*"
+        r"我(?:将|会|可以)?(?:总结|概述|提供|说明|解释|介绍|撰写|回答)"
+    )),
+    # Russian
+    ("ru", "assistant_self_identity", re.compile(
+        r"Как\s+(?:модель\s+искусственного\s+интеллекта|"
+        r"ИИ[- ]?(?:модель|ассистент)|языковая\s+модель|"
+        r"AI[- ]?(?:модель|ассистент))\s*,?\s*"
+        r"я\s+(?:не\s+могу|могу|буду|готов|способен|не\s+способен)",
+        re.IGNORECASE,
+    )),
+    ("ru", "capability_disclaimer", re.compile(
+        r"\bя\s+(?:не\s+могу|не\s+способен|не\s+имею\s+возможности)\s+"
+        r"(?:просмотр\w*|получить\s+доступ|провер\w*|подтверд\w*|откры\w*)",
+        re.IGNORECASE,
+    )),
+    ("ru", "current_artifact_ai_writing", re.compile(
+        r"\b(?:(?:эта|данная)\s+(?:рукопись|статья)|(?:этот|данный)\s+раздел)"
+        r"\s+(?:была|был|было|является|был\s+бы)?\s*"
+        r"(?:сгенерирован\w*|написан\w*|подготовлен\w*|создан\w*)"
+        r".{0,40}?(?:ChatGPT|ИИ|искусственн\w+\s+интеллект\w+|"
+        r"языков\w+\s+модел\w+|ИИ[- ]?(?:ассистент|модель))\b",
+        re.IGNORECASE,
+    )),
+    ("ru", "current_response_frame", re.compile(
+        r"\bВ\s+(?:этом|данном)\s+(?:ответе|отклике)\s+я\s+"
+        r"(?:(?:буду|могу)\s+)?"
+        r"(?:резюмир\w*|представ\w*|объясн\w*|опиш\w*|напиш\w*)",
+        re.IGNORECASE,
+    )),
+    # Kazakh
+    ("kk", "assistant_self_identity", re.compile(
+        r"(?:Жасанды\s+интеллект(?:\s+тіл)?\s+моделі|ЖИ[- ]?(?:моделі|көмекшісі))"
+        r"\s+ретінде\s*,?\s*мен\b.{0,120}?"
+        r"(?:алмаймын|аламын|боламын|көмектесе\s+аламын|ұсына\s+аламын)",
+        re.IGNORECASE,
+    )),
+    ("kk", "capability_disclaimer", re.compile(
+        r"\bмен\b.{0,80}?(?:тексере|қарай|қол\s+жеткізе|растай|аша)"
+        r".{0,30}?\b(?:алмаймын)\b",
+        re.IGNORECASE,
+    )),
+    ("kk", "current_artifact_ai_writing", re.compile(
+        r"\b(?:(?:Бұл|Осы)\s+(?:қолжазба|мақала)|(?:Бұл|Осы)\s+бөлім)"
+        r".{0,40}?(?:ChatGPT|ЖИ|жасанды\s+интеллект|тілдік\s+модель)"
+        r".{0,40}?(?:арқылы\s+)?(?:жасал\w*|жазыл\w*|дайындал\w*|құрастырыл\w*)",
+        re.IGNORECASE,
+    )),
+    ("kk", "current_response_frame", re.compile(
+        r"\b(?:Бұл|Осы)\s+жауапта\s+мен\b.{0,40}?"
+        r"(?:қорытындылаймын|ұсынамын|түсіндіремін|сипаттаймын|жазамын)",
+        re.IGNORECASE,
+    )),
+)
+
+
+def _merge_ranges(ranges: list[tuple[int, int]]) -> list[tuple[int, int]]:
+    merged: list[list[int]] = []
+    for start, end in sorted((max(0, int(a)), max(0, int(b))) for a, b in ranges if int(b) > int(a)):
+        if merged and start <= merged[-1][1]:
+            merged[-1][1] = max(merged[-1][1], end)
+        else:
+            merged.append([start, end])
+    return [(start, end) for start, end in merged]
+
+
+def _protected_natural_language_ranges(value: str) -> list[tuple[int, int]]:
+    """Ranges exempt from natural-language authorship detection, never from hard markers."""
+    ranges: list[tuple[int, int]] = []
+    reference_match = _REFERENCE_HEADING_RE.search(value)
+    if reference_match:
+        ranges.append((reference_match.start(), len(value)))
+
+    # Markdown blockquotes are explicit evidence/transcript zones.
+    ranges.extend((match.start(), match.end()) for match in re.finditer(r"(?m)^[ \t]*>.*(?:\n|$)", value))
+
+    # Fenced excerpts are treated as explicitly delimited evidence/prompt/stimulus
+    # spans for natural-language meta only. Hard SmartPaper markers still fail globally.
+    for fence in ("```", "~~~"):
+        fence_re = re.compile(
+            rf"(?ms)^[ \t]*{re.escape(fence)}[^\n]*\n.*?^[ \t]*{re.escape(fence)}[ \t]*(?:\n|$)"
+        )
+        ranges.extend((match.start(), match.end()) for match in fence_re.finditer(value))
+
+    # Explicit prompt/stimulus/transcript delimiters are protected evidence
+    # zones. Labels alone are insufficient; both opening and closing delimiters
+    # are required so ordinary authorial prose cannot opt itself out.
+    delimited_patterns = (
+        r"(?is)<(?:prompt|stimulus|transcript)>.*?</(?:prompt|stimulus|transcript)>",
+        r"(?is)\[(?:PROMPT|STIMULUS|TRANSCRIPT)\].*?\[/(?:PROMPT|STIMULUS|TRANSCRIPT)\]",
+        r"(?ims)^BEGIN\s+(?:PROMPT|STIMULUS|TRANSCRIPT)\s*$.*?^END\s+(?:PROMPT|STIMULUS|TRANSCRIPT)\s*$",
+    )
+    for pattern in delimited_patterns:
+        ranges.extend((match.start(), match.end()) for match in re.finditer(pattern, value))
+
+    # Well-formed quoted spans used for chatbot transcripts, participant evidence,
+    # paper titles, and experimental stimuli.
+    quote_patterns = (
+        r'"(?:\\.|[^"\\])*"',
+        r"“[^”]*”",
+        r"«[^»]*»",
+        r"「[^」]*」",
+        r"『[^』]*』",
+    )
+    for pattern in quote_patterns:
+        ranges.extend((match.start(), match.end()) for match in re.finditer(pattern, value, flags=re.DOTALL))
+    return _merge_ranges(ranges)
+
+
+def _mask_ranges(value: str, ranges: list[tuple[int, int]]) -> str:
+    """Mask protected text while retaining offsets/newlines for deterministic matching."""
+    if not ranges:
+        return value
+    chunks: list[str] = []
+    cursor = 0
+    for start, end in _merge_ranges(ranges):
+        if start > cursor:
+            chunks.append(value[cursor:start])
+        segment = value[start:end]
+        chunks.append("".join("\n" if char == "\n" else " " for char in segment))
+        cursor = end
+    chunks.append(value[cursor:])
+    return "".join(chunks)
+
+
+def find_authorial_ai_meta_spans(text: str) -> tuple[dict[str, Any], ...]:
+    """Return high-confidence natural-language authorial/process relations only."""
+    value = str(text or "")
+    masked = _mask_ranges(value, _protected_natural_language_ranges(value))
+    findings: list[dict[str, Any]] = []
+    seen: set[tuple[int, int, str]] = set()
+    for language, relation, pattern in _AUTHORIAL_META_PATTERNS:
+        for match in pattern.finditer(masked):
+            key = (match.start(), match.end(), relation)
+            if key in seen:
+                continue
+            seen.add(key)
+            findings.append(
+                {
+                    "kind": "meta",
+                    "language": language,
+                    "relation": relation,
+                    "start": match.start(),
+                    "end": match.end(),
+                    "text": value[match.start():match.end()],
+                }
+            )
+    findings.sort(key=lambda item: (int(item["start"]), int(item["end"]), str(item["relation"])))
+    return tuple(findings)
+
+
+def find_ai_writing_trace_findings(text: str) -> tuple[dict[str, Any], ...]:
+    """Classify fatal SmartPaper leaks and high-confidence authorial AI meta traces."""
+    value = str(text or "")
+    findings: list[dict[str, Any]] = []
+
+    # Hard SmartPaper markers and unresolved internal citation tags are global,
+    # including References and quotations.
+    for match in _HARD_SP_MARKER_RE.finditer(value):
+        findings.append(
+            {
+                "kind": "prompt_leak",
+                "relation": "smartpaper_marker",
+                "start": match.start(),
+                "end": match.end(),
+                "text": match.group(0),
+            }
+        )
+    for match in _UNRESOLVED_CITE_RE.finditer(value):
+        findings.append(
+            {
+                "kind": "prompt_leak",
+                "relation": "unresolved_citation",
+                "start": match.start(),
+                "end": match.end(),
+                "text": match.group(0),
+            }
+        )
+
+    protected = _protected_natural_language_ranges(value)
+    masked = _mask_ranges(value, protected)
+
+    # Soft internal prompt language is only fatal when its structured conjunction
+    # occurs together in an unprotected authorial block.
+    for block_match in re.finditer(r"(?ms)(?:^|\n\s*\n)(.*?)(?=\n\s*\n|\Z)", masked):
+        block = block_match.group(1)
+        if (
+            re.search(r"(?im)^\s*JOURNAL\s+VOICE\s*:", block)
+            and re.search(r"(?im)^\s*SECTION\s*:", block)
+            and re.search(r"(?im)^\s*TEXT\s*:", block)
+        ):
+            findings.append(
+                {
+                    "kind": "prompt_leak",
+                    "relation": "internal_prompt_envelope",
+                    "start": block_match.start(1),
+                    "end": block_match.end(1),
+                    "text": value[block_match.start(1):block_match.end(1)],
+                }
+            )
+    for match in re.finditer(r"(?im)^\s*\[SELF-REFLECTION\]\s*:", masked):
+        findings.append(
+            {
+                "kind": "prompt_leak",
+                "relation": "internal_control_heading",
+                "start": match.start(),
+                "end": match.end(),
+                "text": value[match.start():match.end()],
+            }
+        )
+
+    findings.extend(find_authorial_ai_meta_spans(value))
+    findings.sort(key=lambda item: (int(item["start"]), int(item["end"]), str(item.get("kind", ""))))
+    return tuple(findings)
+
+
 def validate_markdown_manuscript(text: str, *, language_name: str) -> None:
     value = str(text or "").strip()
     if len(value) < 1000:
         raise OutputValidationError(f"{language_name} manuscript is incomplete.")
-    if re.search(r"\[?CITE-\d+\]?", value, flags=re.IGNORECASE):
+
+    findings = find_ai_writing_trace_findings(value)
+    unresolved = next(
+        (item for item in findings if item.get("relation") == "unresolved_citation"),
+        None,
+    )
+    if unresolved is not None:
         raise OutputValidationError(f"{language_name} manuscript still contains unresolved citation tags.")
-    if re.search(r"(?i)\bas an ai(?: language model)?\b|\bai[- ]generated\b", value):
+    if any(item.get("kind") == "prompt_leak" for item in findings):
+        raise OutputValidationError(f"{language_name} manuscript contains internal prompt/pipeline leakage.")
+    if any(item.get("kind") == "meta" for item in findings):
         raise OutputValidationError(f"{language_name} manuscript contains AI-writing meta-commentary.")
     if not re.search(r"(?m)^#\s+", value):
         raise OutputValidationError(f"{language_name} manuscript has no title/section headings.")