file-observer 1.2.0__tar.gz → 1.2.2__tar.gz

{file_observer-1.2.0/src/file_observer.egg-info → file_observer-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: file-observer
-Version: 1.2.0
+Version: 1.2.2
 Summary: Not a file watcher — a one-shot, read-only scan that emits a deterministic JSON manifest of what's in a directory before you ingest it.
 Author-email: Russell Pfister <russalo@russalo.com>
 License: AGPL-3.0-or-later
@@ -104,11 +104,11 @@ Every derived field carries a `signal_provenance` entry; every vector an `identi
 |---|---|
 | **Package** | `file-observer` |
 | **CLI** | `file-observer` or `fo` (shorthand) |
-| **Version** | `1.2.0` |
+| **Version** | `1.2.1` |
 | **Schema** | `1.2` |
 | **Python** | `>= 3.12` |
 | **License** | [AGPL-3.0](https://github.com/russalo/file-observer/blob/main/LICENSE) (commercial license available) |
-| **Tests** | 595 passed; ran clean (zero fatal errors) across 12 corpora / 28,756 files |
+| **Tests** | 606 passed; ran clean (zero fatal errors) across 12 corpora / 28,756 files |
 
 ---
 

{file_observer-1.2.0 → file_observer-1.2.2}/docs/README.md

@@ -59,11 +59,11 @@ Every derived field carries a `signal_provenance` entry; every vector an `identi
 |---|---|
 | **Package** | `file-observer` |
 | **CLI** | `file-observer` or `fo` (shorthand) |
-| **Version** | `1.2.0` |
+| **Version** | `1.2.1` |
 | **Schema** | `1.2` |
 | **Python** | `>= 3.12` |
 | **License** | [AGPL-3.0](https://github.com/russalo/file-observer/blob/main/LICENSE) (commercial license available) |
-| **Tests** | 595 passed; ran clean (zero fatal errors) across 12 corpora / 28,756 files |
+| **Tests** | 606 passed; ran clean (zero fatal errors) across 12 corpora / 28,756 files |
 
 ---
 

{file_observer-1.2.0 → file_observer-1.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "file-observer"
-version = "1.2.0"
+version = "1.2.2"
 description = "Not a file watcher — a one-shot, read-only scan that emits a deterministic JSON manifest of what's in a directory before you ingest it."
 readme = "docs/README.md"
 requires-python = ">=3.12"

{file_observer-1.2.0 → file_observer-1.2.2}/src/file_observer/scanner.py

@@ -5,7 +5,7 @@ Observation layer for document pipelines. Recursively discovers files,
 extracts metadata and signals, emits a deterministic JSON manifest.
 
     Package:    file_observer
-    Version:    1.2.0
+    Version:    1.2.1
     Schema:     1.2
     Python:     >= 3.12
     Spec:       docs/v1.2.0_RFC_Specification.md (current)
@@ -71,8 +71,8 @@ except ImportError:
     _defusedxml_available = False
 
 
-SCANNER_VERSION = "1.2.0"
-LOGIC_VERSION = "1.1.0"
+SCANNER_VERSION = "1.2.2"
+LOGIC_VERSION = "1.1.2"
 SCHEMA_VERSION = "1.2"
 
 
@@ -546,17 +546,21 @@ CHATLOG_TOOL = "chatlog_signals"
 # any detection regex or extraction algorithm requires bumping METHOD_VERSION
 # and updating the rules definition string.
 CHATLOG_VECTOR_ID = "chatlog"
-CHATLOG_METHOD_VERSION = 4  # v1.2: generalized conversational detection + per-speaker structure
+CHATLOG_METHOD_VERSION = 6  # v1.2.2: prose Rule 1 requires a recurring speaker; expanded stop-list (FP fixes)
 CHATLOG_RULES_DEFINITION = (
-    "detect:speaker_label_re(3+,stop_list,alternation),h3_header_re(5+),section_divider_re(3+),"
+    "detect:speaker_label_re(distinct>=2,total>=3,recurring>=1,stop_list),"
+    "h3_header_re(5+)|section_divider_re(3+)[require speaker_cosignal_distinct>=2],"
     "json_conversation(role_keys{type,role,from,speaker,author}+content_keys{text,value,content,message,body},"
-    "line/array/tree,embedded_speaker_labels);"
+    "line/array/tree,embedded_speaker_labels,require msgs>=3 AND distinct_speakers>=2);"
     "extract:turn_count,speaker_labels(freq>=3,stop_list),section_markers,"
     "turn_char_stats,speaker_turn_counts,speaker_turn_chars,alternation,"
     "reference_tokens(at_mentions,wiki_links,code_fence_blocks,url_count),"
     "top_capitalized_tokens(freq>=3,top20),vocabulary_size_estimate;"
-    "stop_list:Allow,CAUTION,Disallow,Error,Example,Examples,FIXME,"
-    "IMPORTANT,NOTE,Note,Result,TIP,TODO,Warning"
+    "stop_list:Allow,Arguments,Authorization,Bcc,CAUTION,Cc,Command,Commands,"
+    "Copyright,Date,Description,Disallow,Distribution,Documentation,Error,Example,"
+    "Examples,FIXME,Format,From,IMPORTANT,License,Lines,Message,NOTE,Newsgroups,"
+    "Note,Options,Organization,Parameters,Password,Path,References,Result,Returns,"
+    "Sender,Subject,Summary,Synopsis,TIP,TODO,To,Usage,Version,Warning"
 )
 CHATLOG_STATIC_TUNING = {
     "detection_threshold": 3,
@@ -578,6 +582,16 @@ CHATLOG_ROLE_FIELD_KEYS = ("type", "role", "from", "speaker", "author")
 CHATLOG_CONTENT_FIELD_KEYS = ("text", "value", "content", "message", "body")
 CHATLOG_ROLE_FIELD_KEYSET = frozenset(CHATLOG_ROLE_FIELD_KEYS)
 CHATLOG_CONTENT_FIELD_KEYSET = frozenset(CHATLOG_CONTENT_FIELD_KEYS)
+# v1.2.1: `type` is ambiguous — it names a speaker only in some schemas
+# (Claude: type:user/assistant) and is otherwise a wrapper (type:"message"), a
+# log level (type:"info"/"error"), or a content-block kind (type:"text"). Accept
+# `type` as the speaker ONLY when its value is a conversational role; the other
+# role keys (role/from/speaker/author) accept any value. This kills log /
+# rich-content / envelope false positives without a denylist.
+CHATLOG_CONVERSATIONAL_TYPE_VALUES = frozenset({
+    "user", "assistant", "human", "system", "model", "bot", "gpt", "ai",
+    "prompter", "tool", "function",
+})
 # v1.2: regex fallback for truncated/large single-JSON samples (e.g. a multi-MB
 # ShareGPT file whose bounded sample won't json.loads). Matches a flat object
 # carrying both a role-field and a content-field key, in either order.
@@ -587,16 +601,29 @@ CHATLOG_JSON_MESSAGE_RE = re.compile(
     r'|\{[^{}]*"(?:text|value|content|message|body)"\s*:[^{}]*'
     r'"(?:type|role|from|speaker|author)"\s*:\s*"[^"]{1,40}"'
 )
-# v1.2: date-stamped headers distinguish a journal/vault ('# 2026-04-10') from
-# a prose doc ('### Parameters'). Lets rules 2/3 keep detecting journals while
-# no longer over-firing on documentation markdown.
-CHATLOG_DATE_HEADER_RE = re.compile(r'(?m)^#{1,6}\s.*\b\d{4}-\d{2}-\d{2}\b')
+# v1.2.1: capture the role-field VALUE so detection can require >=2 DISTINCT
+# speakers. A conversation alternates (user/assistant, u0/u1, human/gpt); a
+# structured log is all "type":"info" (1 distinct) and a changelog has none.
+# This single requirement fixes the v1.2.0 false positives on logs, single-role
+# JSONL, and Claude rich-content blocks (all <2 distinct roles).
+CHATLOG_JSON_ROLE_VALUE_RE = re.compile(
+    r'"(?:type|role|from|speaker|author)"\s*:\s*"([^"]{1,40})"')
 # v0.9.1: speaker labels matching these tokens are excluded from detection
 # and extraction. These are common documentation patterns (Note:, Example:, etc.)
 # that match the speaker label regex but are not conversation participants.
 CHATLOG_SPEAKER_STOP_LIST: set[str] = {
+    # documentation / admonition labels (v0.9.1)
     "Note", "NOTE", "Example", "Examples", "Result", "Warning", "Error",
     "Disallow", "Allow", "TODO", "FIXME", "TIP", "IMPORTANT", "CAUTION",
+    # v1.2.2: structural/header labels that recur but are never speakers,
+    # surfaced by the corpus sweep — email/usenet headers, man-page sections,
+    # legal notices, form fields. `User` is intentionally NOT here (it is a
+    # legitimate speaker in many transcripts); `Password` and the rest never are.
+    "From", "To", "Cc", "Bcc", "Date", "Subject", "Sender", "References",
+    "Message", "Newsgroups", "Organization", "Lines", "Distribution", "Path",
+    "Version", "Usage", "Options", "Command", "Commands", "Format", "Synopsis",
+    "Description", "Arguments", "Parameters", "Returns", "Summary",
+    "Authorization", "Documentation", "License", "Copyright", "Password",
 }
 
 # v0.9: Reference tokens vector identity constants.
@@ -2507,22 +2534,32 @@ class Scanner:
         """
         if not text:
             return False
-        # Rule 1: speaker labels, excluding stop-list matches
+        # Rule 1: prose speaker labels (stop-list filtered). A conversation has
+        # speakers who RECUR and alternate; a header/label block (email headers,
+        # man-page sections, UTF-8 demos, language lists) has many one-shot
+        # labels. v1.2.2: require >=2 distinct speakers, >=3 total turns, AND at
+        # least one speaker who takes multiple turns (real back-and-forth). This
+        # ports the v1.2.1 distinct-speaker hardening (added then only to the
+        # JSON path) to prose, and adds recurrence — the discriminator the corpus
+        # sweep showed separates transcripts (recurring) from header blocks (one-shot).
         speaker_matches = [
             m.group(1) for m in CHATLOG_SPEAKER_LABEL_RE.finditer(text)
             if m.group(1) not in CHATLOG_SPEAKER_STOP_LIST
         ]
-        if len(speaker_matches) >= 3:
+        speaker_counts = Counter(speaker_matches)
+        if (len(speaker_counts) >= 2 and sum(speaker_counts.values()) >= 3
+                and any(c >= 2 for c in speaker_counts.values())):
             return True
         # Rules 2/3 (v1.2): markdown structure (H3 headers / section dividers)
         # only counts as a chatlog/journal signal when accompanied by a
         # conversational co-signal — 2+ speaker labels OR 2+ date-stamped
         # headers (journal entries). Prose docs have neither, so they no
         # longer false-positive; transcripts and dated journals still do.
-        structure_cosignal = (
-            len(speaker_matches) >= 2
-            or len(CHATLOG_DATE_HEADER_RE.findall(text)) >= 2
-        )
+        # v1.2.1: markdown structure (H3 headers / dividers) counts only with a
+        # SPEAKER co-signal (2+ labels). Dropped the v1.2 date-header co-signal —
+        # it merely relocated the false positive to dated docs (changelogs,
+        # release notes, dated journals are structurally indistinguishable).
+        structure_cosignal = len(speaker_counts) >= 2
         if structure_cosignal and len(CHATLOG_H3_HEADER_RE.findall(text)) >= 5:
             return True
         if structure_cosignal and len(CHATLOG_SECTION_DIVIDER_RE.findall(text)) >= 3:
@@ -2531,56 +2568,6 @@ class Scanner:
         # (line-delimited, arrays, nested trees, embedded speaker labels).
         return self._detect_conversational_json(text)
 
-    @staticmethod
-    def _is_message_like(obj: Any) -> bool:
-        """A dict carrying a role-field key (names the speaker) AND a
-        content-field key (holds the utterance). Schema-general."""
-        if not isinstance(obj, dict):
-            return False
-        has_role = any(
-            k in obj and isinstance(obj[k], (str, int)) and str(obj[k]).strip()
-            for k in CHATLOG_ROLE_FIELD_KEYS
-        )
-        if not has_role:
-            return False
-        for k in CHATLOG_CONTENT_FIELD_KEYS:
-            if k not in obj:
-                continue
-            v = obj[k]
-            if isinstance(v, str) and v.strip():
-                return True
-            if isinstance(v, dict) and isinstance(v.get("content"), (str, list)):
-                return True  # e.g. Claude: message.content
-            if isinstance(v, list) and v:
-                return True  # content as a list of parts
-        return False
-
-    def _count_message_like(self, node: Any, budget: int = 5000) -> int:
-        """Count message-like dicts in a parsed JSON structure (arrays of
-        messages, nested reply trees). Bounded; early-exits at 3."""
-        count = 0
-        stack = [node]
-        seen = 0
-        while stack and seen < budget:
-            cur = stack.pop()
-            seen += 1
-            if isinstance(cur, dict):
-                if self._is_message_like(cur):
-                    count += 1
-                    if count >= 3:
-                        return count
-                    # Don't recurse into this message's own role/content —
-                    # Claude rich-content blocks would double-count. Continue
-                    # only into other fields (e.g. nested `replies`).
-                    stack.extend(v for k, v in cur.items()
-                                 if k not in CHATLOG_ROLE_FIELD_KEYSET
-                                 and k not in CHATLOG_CONTENT_FIELD_KEYSET)
-                else:
-                    stack.extend(cur.values())
-            elif isinstance(cur, list):
-                stack.extend(cur)
-        return count
-
     @staticmethod
     def _string_has_speaker_dialogue(s: Any) -> bool:
         """Dialogue embedded in a JSON string value (e.g. hh-rlhf's
@@ -2594,59 +2581,84 @@ class Scanner:
         return len(labels) >= 3
 
     def _detect_conversational_json(self, text: str) -> bool:
-        """Generalized conversational JSON/JSONL detection (v1.2).
-
-        Handles: line-delimited messages (ConvoKit speaker/text, Claude
-        type+message.content), nested trees (oasst prompt.role+replies),
-        message arrays (ShareGPT from/value), dialogue embedded in a string
-        field (hh-rlhf), and truncated large single-JSON via a regex fallback.
+        """Generalized conversational JSON/JSONL detection (v1.2; tightened v1.2.1).
+
+        Handles line-delimited messages (ConvoKit speaker/text, Claude
+        type+message.content), nested trees (oasst prompt.role+replies), message
+        arrays (ShareGPT from/value), dialogue embedded in a string field
+        (hh-rlhf), and truncated large single-JSON via a regex fallback.
+
+        A conversation requires **3+ messages with 2+ DISTINCT speakers**. The
+        distinct-speaker rule (v1.2.1) is what separates a real conversation
+        from a structured log (`type:"info"` repeated), a single-role stream, or
+        Claude rich-content blocks — all of which carry <2 distinct roles and
+        previously false-positived.
         """
-        msg_count = 0
-        any_parsed = False
-        # Strategy 1: line-delimited JSON (JSONL)
-        for line in text.split("\n"):
-            line = line.strip()
-            if not line or line[0] not in "{[":
-                continue
-            try:
-                obj = json.loads(line)
-            except (json.JSONDecodeError, ValueError):
-                continue
-            any_parsed = True
-            msg_count += self._count_message_like(obj)
-            if msg_count >= 3:
-                return True
-            if isinstance(obj, dict):
-                for v in obj.values():
-                    if self._string_has_speaker_dialogue(v):
-                        return True
-        # Strategy 2: single JSON document/array small enough to fit the sample
-        if not any_parsed:
-            stripped = text.strip()
-            if stripped[:1] in "{[":
+        speakers = [sp for sp, _ in self._extract_json_conversation(text)]
+        if len(speakers) >= 3 and len(set(speakers)) >= 2:
+            return True
+        # Regex fallback ONLY when the parser extracted nothing — a truncated/
+        # large single-JSON it couldn't read (e.g. a multi-MB ShareGPT file).
+        # Gated on `not speakers` so it can't override the parser on readable
+        # input (otherwise inner content blocks would re-inflate the count).
+        # Regex fallback ONLY for a truncated/unparseable single-JSON (the
+        # parser read nothing AND the sample doesn't parse). A parseable-but-
+        # non-conversational doc (e.g. a structured log whose `type` values were
+        # correctly rejected as non-speakers) must NOT be rescued here.
+        if not speakers and not self._sample_parses_as_json(text):
+            matches = CHATLOG_JSON_MESSAGE_RE.findall(text)
+            if len(matches) >= 3:
+                # role values from the message-like matches only, 2+ distinct
+                roles = [m.group(1) for m in
+                         (CHATLOG_JSON_ROLE_VALUE_RE.search(s) for s in matches) if m]
+                if len(set(roles)) >= 2:
+                    return True
+        return False
+
+    @staticmethod
+    def _sample_parses_as_json(text: str) -> bool:
+        """True if the sample contains at least one parseable JSON value.
+        Gates the regex fallback so it fires only on truly-unparseable
+        (truncated) input, not on readable non-conversational JSON."""
+        for ln in text.split("\n"):
+            ln = ln.strip()
+            if ln and ln[0] in "{[":
                 try:
-                    if self._count_message_like(json.loads(stripped)) >= 3:
-                        return True
+                    json.loads(ln)
+                    return True
                 except (json.JSONDecodeError, ValueError):
                     pass
-            # Strategy 3: regex fallback ONLY when nothing parsed (a truncated
-            # large single-JSON). When lines parsed, strategy 1's accurate
-            # object count governs — otherwise the regex would also match inner
-            # content blocks (e.g. Claude's rich-content) and over-count.
-            if len(CHATLOG_JSON_MESSAGE_RE.findall(text)) >= 3:
+        s = text.strip()
+        if s[:1] in "{[":
+            try:
+                json.loads(s)
                 return True
+            except (json.JSONDecodeError, ValueError):
+                pass
         return False
 
     @staticmethod
     def _message_role_content(obj: dict) -> tuple[str, str] | None:
-        """(speaker, content_text) for a message-like dict, else None."""
+        """(speaker, content_text) for a message-like dict, else None.
+
+        v1.2.1: `type` counts as the speaker only when its value is a
+        conversational role (Claude's type:user/assistant); a non-conversational
+        `type` (a wrapper like "message", a log level "info", a content block
+        "text") is skipped so the next role key (role/from/speaker/author) wins.
+        """
         speaker = None
         for k in CHATLOG_ROLE_FIELD_KEYS:
             v = obj.get(k)
             if isinstance(v, str) and v.strip():
-                speaker = v.strip(); break
-            if isinstance(v, int):
-                speaker = str(v); break
+                val = v.strip()
+            elif isinstance(v, int):
+                val = str(v)
+            else:
+                continue
+            if k == "type" and val.lower() not in CHATLOG_CONVERSATIONAL_TYPE_VALUES:
+                continue  # `type` is a speaker only for conversational values
+            speaker = val
+            break
         if speaker is None:
             return None
         for k in CHATLOG_CONTENT_FIELD_KEYS:

{file_observer-1.2.0 → file_observer-1.2.2/src/file_observer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: file-observer
-Version: 1.2.0
+Version: 1.2.2
 Summary: Not a file watcher — a one-shot, read-only scan that emits a deterministic JSON manifest of what's in a directory before you ingest it.
 Author-email: Russell Pfister <russalo@russalo.com>
 License: AGPL-3.0-or-later
@@ -104,11 +104,11 @@ Every derived field carries a `signal_provenance` entry; every vector an `identi
 |---|---|
 | **Package** | `file-observer` |
 | **CLI** | `file-observer` or `fo` (shorthand) |
-| **Version** | `1.2.0` |
+| **Version** | `1.2.1` |
 | **Schema** | `1.2` |
 | **Python** | `>= 3.12` |
 | **License** | [AGPL-3.0](https://github.com/russalo/file-observer/blob/main/LICENSE) (commercial license available) |
-| **Tests** | 595 passed; ran clean (zero fatal errors) across 12 corpora / 28,756 files |
+| **Tests** | 606 passed; ran clean (zero fatal errors) across 12 corpora / 28,756 files |
 
 ---
 

{file_observer-1.2.0 → file_observer-1.2.2}/src/file_observer.egg-info/SOURCES.txt

@@ -18,4 +18,6 @@ tests/test_integration.py
 tests/test_packaging.py
 tests/test_unit.py
 tests/test_v1_1.py
-tests/test_v1_2.py
+tests/test_v1_2.py
+tests/test_v1_2_1.py
+tests/test_v1_2_2.py

{file_observer-1.2.0 → file_observer-1.2.2}/tests/test_packaging.py

@@ -17,7 +17,7 @@ def test_canonical_top_level_api():
 
     import file_observer
 
-    assert file_observer.__version__ == "1.2.0"
+    assert file_observer.__version__ == "1.2.2"
     assert "Scanner" in file_observer.__all__
 
 
@@ -49,9 +49,9 @@ def test_canonical_submodule_constants_unchanged():
     """Constants and the manifest field they feed stay stable across the 1.0.x → 1.1 line (the 1.0.1 import-package rename left them intact)."""
     from file_observer.scanner import SCANNER_VERSION, LOGIC_VERSION, SCHEMA_VERSION
 
-    assert SCANNER_VERSION == "1.2.0"
+    assert SCANNER_VERSION == "1.2.2"
     assert SCHEMA_VERSION == "1.2"  # additive minor bump (v1.1 corpus-intelligence fields)
-    assert LOGIC_VERSION == "1.1.0"  # no routing change
+    assert LOGIC_VERSION == "1.1.2"  # v1.2.2: prose chatlog detection tightened (recurrence + stop-list)
 
 
 def test_legacy_scanner_import_warns():

{file_observer-1.2.0 → file_observer-1.2.2}/tests/test_unit.py

@@ -811,8 +811,8 @@ class TestScanContext:
         (tmp_path / "a.txt").write_text("hello")
         manifest = Scanner(source_dir=tmp_path).scan()
         ctx = manifest.context
-        assert ctx.scanner_version == "1.2.0"
-        assert ctx.logic_version == "1.1.0"
+        assert ctx.scanner_version == "1.2.2"
+        assert ctx.logic_version == "1.1.2"
         assert ctx.python_version  # non-empty
         assert ctx.platform  # non-empty
 
@@ -850,7 +850,7 @@ class TestScanContext:
         manifest = Scanner(source_dir=tmp_path).scan()
         data = json_mod.loads(manifest_to_json(manifest))
         assert "context" in data
-        assert data["context"]["scanner_version"] == "1.2.0"
+        assert data["context"]["scanner_version"] == "1.2.2"
 
 
 # ---------------------------------------------------------------------------
@@ -1313,11 +1313,10 @@ class TestDetectChatlogPattern:
     # ---- Rule 2: ### headers ----
 
     def test_five_h3_headers_triggers(self, scanner: Scanner) -> None:
-        # v1.2: H3 headers count as a journal signal when accompanied by a
-        # co-signal (here, date-stamped entries). Bare prose headers no longer
-        # trigger — see test_generic_h3_headers_no_cosignal_does_not_trigger.
-        text = ("### 2026-01-01\nbody\n### 2026-01-02\nbody\n### 2026-01-03\n"
-                "body\n### 2026-01-04\nbody\n### 2026-01-05\nbody\n")
+        # v1.2.1: H3 headers count only with a SPEAKER co-signal (2+ labels).
+        # The v1.2 date-header co-signal was dropped (it FP'd on changelogs).
+        text = ("### One\nAlice: hi\n### Two\nBob: yo\n### Three\nbody\n"
+                "### Four\nbody\n### Five\nbody\n")
         assert scanner._detect_chatlog_pattern(text) is True
 
     def test_generic_h3_headers_no_cosignal_does_not_trigger(self, scanner: Scanner) -> None:
@@ -1342,8 +1341,8 @@ class TestDetectChatlogPattern:
     # ---- Rule 3: section dividers ----
 
     def test_three_dash_dividers_triggers(self, scanner: Scanner) -> None:
-        # v1.2: dividers count when accompanied by a co-signal (dated entries).
-        text = "## 2026-01-01\n---\n## 2026-01-02\n---\n## 2026-01-03\n---\nfooter\n"
+        # v1.2.1: dividers count only with a SPEAKER co-signal (2+ labels).
+        text = "Alice: hi\n---\nBob: yo\n---\nmore prose\n---\nfooter\n"
         assert scanner._detect_chatlog_pattern(text) is True
 
     def test_generic_dividers_no_cosignal_does_not_trigger(self, scanner: Scanner) -> None:
@@ -1385,6 +1384,10 @@ class TestDetectChatlogPattern:
         assert scanner._detect_chatlog_pattern(text) is True
 
     def test_realistic_journal_with_dividers(self, scanner: Scanner) -> None:
+        # v1.2.1: a dated prose journal with NO speakers is structurally
+        # indistinguishable from a changelog — it must NOT be flagged. (The
+        # journal/vault use case now requires a speaker signal or conversational
+        # JSON.) This guards the changelog/dated-doc false positive.
         text = (
             "# 2026-04-10\n"
             "Worked on the scanner. Patched the OLE2 bug.\n"
@@ -1396,7 +1399,7 @@ class TestDetectChatlogPattern:
             "Schema reshape day.\n"
             "---\n"
         )
-        assert scanner._detect_chatlog_pattern(text) is True
+        assert scanner._detect_chatlog_pattern(text) is False
 
     # ---- regression guards for PR #9 review comments ----
 
@@ -1550,9 +1553,9 @@ class TestIsChatlogIntegration:
 
     def test_chatlog_txt_file_detected(self, tmp_path: Path) -> None:
         # The .txt extension is also in the chatlog detection allow list.
-        # v1.2: dividers need a co-signal (dated journal entries here).
+        # v1.2.1: dividers need a SPEAKER co-signal.
         content = (
-            "## 2026-01-01\n---\n## 2026-01-02\n---\n## 2026-01-03\n---\nfooter\n"
+            "Alice: hi\n---\nBob: yo\n---\nmore prose\n---\nfooter\n"
         )
         (tmp_path / "log.txt").write_text(content)
         manifest = Scanner(source_dir=tmp_path).scan()
@@ -1601,7 +1604,7 @@ class TestIsChatlogIntegration:
     def test_is_chatlog_serializes_to_json(self, tmp_path: Path) -> None:
         from file_observer.scanner import manifest_to_json
         import json as _json
-        content = "### 2026-01-01\n### 2026-01-02\n### 2026-01-03\n### 2026-01-04\n### 2026-01-05\n"
+        content = "### One\nAlice: hi\n### Two\nBob: yo\n### Three\n### Four\n### Five\n"
         (tmp_path / "headers.md").write_text(content)
         manifest = Scanner(source_dir=tmp_path).scan()
         data = _json.loads(manifest_to_json(manifest))
@@ -1997,12 +2000,12 @@ class TestChatlogFixtures:
         assert chat["turn_count"] >= 6
 
     def test_journal_fixture_section_dividers(self, tmp_path: Path) -> None:
+        # v1.2.1: chatlog_journal.md is dated prose with dividers but NO
+        # speakers — structurally a changelog. It must NOT be flagged now
+        # (journal/vault detection requires a speaker signal or conversational
+        # JSON). Guards the dated-doc false positive.
         rec = self._scan_one_file("chatlog_journal.md", tmp_path)
-        assert rec.is_chatlog is True
-        chat = rec.specialist_metadata["chatlog"]
-        # Has both --- dividers AND # headers
-        assert chat["section_marker_count"] >= 3
-        assert "---" in chat["section_marker_styles"]
+        assert rec.is_chatlog is False
 
     def test_headers_fixture_h3_rule(self, tmp_path: Path) -> None:
         # v1.2 FP fix: this fixture is prose-doc-like (bare ### headers, no
@@ -2039,8 +2042,8 @@ class TestSemanticToolNames:
 
     def test_version_is_current(self) -> None:
         from file_observer.scanner import SCANNER_VERSION, LOGIC_VERSION
-        assert SCANNER_VERSION == "1.2.0"
-        assert LOGIC_VERSION == "1.1.0"
+        assert SCANNER_VERSION == "1.2.2"
+        assert LOGIC_VERSION == "1.1.2"
 
 
 # ---------------------------------------------------------------------------
@@ -3527,4 +3530,4 @@ class TestMarkdownReport:
         from file_observer.scanner import manifest_to_markdown
         (tmp_path / "a.txt").write_text("hello")
         md = manifest_to_markdown(Scanner(source_dir=tmp_path).scan())
-        assert "1.2.0" in md
+        assert "1.2.2" in md

{file_observer-1.2.0 → file_observer-1.2.2}/tests/test_v1_2.py

@@ -111,13 +111,16 @@ class TestErrorDetail:
 
 class TestDeterminismAndCounting:
     def test_multi_role_key_picks_priority_deterministically(self, tmp_path):
-        # A message with several role keys must select by fixed priority
-        # (type > role > from > speaker > author), not hash-randomized set
-        # order — guards the determinism contract (RFC §2).
-        c = "\n".join(json.dumps({"type": "USER", "role": "x", "content": f"m{i}"})
-                      for i in range(3))
+        # Messages with several role keys must select the speaker by fixed
+        # priority (type > role > from > speaker > author), not hash-randomized
+        # set order — guards the determinism contract (RFC §2). Uses 2 distinct
+        # speakers so it's a real conversation (v1.2.1 needs >=2 distinct).
+        c = ('{"type": "USER", "role": "x", "content": "a"}\n'
+             '{"type": "ASSISTANT", "role": "y", "content": "b"}\n'
+             '{"type": "USER", "role": "z", "content": "c"}\n')
         chat = _scan_text(tmp_path, "m.jsonl", c).specialist_metadata["chatlog"]
-        assert chat["speaker_turn_counts"] == {"USER": 3}
+        # speaker comes from `type` (priority), not `role`'s x/y/z
+        assert chat["speaker_turn_counts"] == {"ASSISTANT": 1, "USER": 2}
 
     def test_rich_content_blocks_not_double_counted(self, tmp_path):
         # One message whose content is a list of text blocks must count as a

file_observer-1.2.2/tests/test_v1_2_1.py

@@ -0,0 +1,112 @@
+"""v1.2.1 — false-positive corpus + determinism property test.
+
+Written FIRST (falsify-before-fix). On v1.2.0 the two FP tests FAIL — they
+reproduce the shipped regression (CHANGELOG.md and structured JSONL logs
+mis-detected as chatlogs). The fix makes them pass. See scratch/critical_review.md
+and [[feedback_falsify_dont_confirm]].
+"""
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from file_observer.scanner import Scanner, ScannerConfig, manifest_to_json
+
+
+def _is_chatlog(tmp_path, name, content):
+    (tmp_path / name).write_text(content)
+    return Scanner(source_dir=tmp_path, config=ScannerConfig()).scan().files[0].is_chatlog
+
+
+class TestFalsePositiveCorpus:
+    """Common-but-not-conversational files MUST NOT be flagged as chatlogs."""
+
+    def test_changelog_not_flagged(self, tmp_path):
+        # Dated headers + dividers, no speakers — a changelog/release-notes.
+        c = "\n".join(f"## 2026-0{i}-15\n- fixed bug {i}\n- added feature {i}\n---"
+                      for i in range(1, 6))
+        assert _is_chatlog(tmp_path, "CHANGELOG.md", c) is False
+
+    def test_dated_journal_without_speakers_not_flagged(self, tmp_path):
+        c = ("# 2026-01-01\nWorked on the parser.\n---\n"
+             "# 2026-01-02\nFixed the bug.\n---\n# 2026-01-03\nShipped.\n---\n")
+        assert _is_chatlog(tmp_path, "journal.md", c) is False
+
+    def test_structured_jsonl_log_not_flagged(self, tmp_path):
+        # type + message per line — the output of most logging libraries.
+        c = "\n".join(json.dumps({"timestamp": f"t{i}", "type": "info",
+                                  "message": f"request {i} ok"}) for i in range(6))
+        assert _is_chatlog(tmp_path, "app.jsonl", c) is False
+
+    def test_single_role_jsonl_not_flagged(self, tmp_path):
+        # All same role value → not a conversation (no alternation).
+        c = "\n".join(json.dumps({"role": "system", "content": f"event {i}"})
+                      for i in range(6))
+        assert _is_chatlog(tmp_path, "events.jsonl", c) is False
+
+    def test_mixed_level_log_not_flagged(self, tmp_path):
+        # type=info/error/warn are LOG LEVELS, not speakers — must not pass the
+        # distinct-speaker gate just because the level varies (PR #28 review).
+        levels = ["info", "error", "warn", "info", "error", "debug"]
+        c = "\n".join(json.dumps({"timestamp": f"t{i}", "type": lv, "message": f"event {i}"})
+                      for i, lv in enumerate(levels))
+        assert _is_chatlog(tmp_path, "app.jsonl", c) is False
+
+    def test_config_json_not_flagged(self, tmp_path):
+        c = json.dumps({"name": "pkg", "version": "1.0",
+                        "scripts": {"build": "tsc", "test": "pytest"}})
+        assert _is_chatlog(tmp_path, "package.json", c) is False
+
+
+class TestStillDetectsRealConversations:
+    """The FP fix must not regress genuine conversational content."""
+
+    def test_two_speaker_jsonl(self, tmp_path):
+        c = ('{"speaker": "u0", "text": "hi"}\n{"speaker": "u1", "text": "yo"}\n'
+             '{"speaker": "u0", "text": "bye"}\n')
+        assert _is_chatlog(tmp_path, "conv.jsonl", c) is True
+
+    def test_user_assistant_jsonl(self, tmp_path):
+        c = ('{"role": "user", "content": "hi"}\n{"role": "assistant", "content": "hello"}\n'
+             '{"role": "user", "content": "bye"}\n')
+        assert _is_chatlog(tmp_path, "chat.jsonl", c) is True
+
+    def test_markdown_transcript_with_speakers(self, tmp_path):
+        c = "### Scene 1\nAlice: hi\n### Scene 2\nBob: hello\n### Scene 3\nmore\n### S4\n### S5\n"
+        assert _is_chatlog(tmp_path, "t.md", c) is True
+
+    def test_type_message_envelope_with_role(self, tmp_path):
+        # {type:"message", role:user/assistant} — `type` is a constant wrapper;
+        # the real speaker is `role`. Must detect (PR #28 review regression).
+        c = ('{"type": "message", "role": "user", "content": "hi"}\n'
+             '{"type": "message", "role": "assistant", "content": "hello"}\n'
+             '{"type": "message", "role": "user", "content": "bye"}\n')
+        assert _is_chatlog(tmp_path, "chat.jsonl", c) is True
+
+
+class TestDeterminism:
+    """Flagship property: same bytes -> same manifest, across hash seeds."""
+
+    def test_manifest_checksum_stable_across_hash_seeds(self, tmp_path):
+        d = str(tmp_path)
+        # multi-role-key objects — the case the set-iteration bug broke
+        Path(d, "c.jsonl").write_text(
+            '{"role": "user", "content": "a"}\n'
+            '{"role": "assistant", "content": "b"}\n'
+            '{"speaker": "u", "text": "c"}\n')
+        code = (
+            "from file_observer.scanner import Scanner, ScannerConfig, manifest_to_json;"
+            "import json; from pathlib import Path;"
+            f"m = Scanner(source_dir=Path({d!r}), config=ScannerConfig(enable_specialists=True)).scan();"
+            "print(json.loads(manifest_to_json(m))['manifest_checksum'])"
+        )
+        checksums = set()
+        for seed in ("0", "1", "12345"):
+            env = dict(os.environ, PYTHONHASHSEED=seed)
+            out = subprocess.run([sys.executable, "-c", code], capture_output=True,
+                                 text=True, env=env)
+            assert out.returncode == 0, out.stderr
+            checksums.add(out.stdout.strip())
+        assert len(checksums) == 1 and "" not in checksums

file_observer-1.2.2/tests/test_v1_2_2.py

@@ -0,0 +1,95 @@
+"""v1.2.2 — prose-mode chatlog false-positive corpus + recurrence rule.
+
+Found by the empirical corpus sweep harness (scratch/review/corpus_sweep.py) on
+its first run: the v1.2.1 ">=2 distinct speakers" hardening was added to the JSON
+path but never ported to prose Rule 1, which still fired on >=3 total
+`^Capitalized:` matches with no distinctness/recurrence. Email headers, legal
+notices, UTF-8 demos, man-page labels, and form fields were all flagged.
+
+Written FIRST (falsify-before-fix): on the unfixed code the TestProseFalsePositives
+cases FAIL (they reproduce the shipped FPs). The fix — Rule 1 requires a recurring
+speaker (real back-and-forth) + an expanded stop-list — makes them pass without
+regressing the genuine-transcript cases. See scratch/review/v1_2_2_fp_findings.md
+and [[feedback_falsify_dont_confirm]].
+"""
+
+from file_observer.scanner import Scanner, ScannerConfig
+
+
+def _is_chatlog(tmp_path, name, content):
+    (tmp_path / name).write_text(content)
+    return Scanner(source_dir=tmp_path, config=ScannerConfig()).scan().files[0].is_chatlog
+
+
+class TestProseFalsePositives:
+    """Header/label blocks are NOT conversations. Each catalogued from a real
+    corpus file the sweep flagged under v1.2.1."""
+
+    def test_email_headers_not_flagged(self, tmp_path):
+        # obs-studio QSV11-License-Clarification-Email.txt shape
+        c = ("From: alice@example.com\nTo: bob@example.com\nCc: team@example.com\n"
+             "Date: Mon, 1 Jun 2026 10:00:00\nSubject: License clarification\n\n"
+             "Please see the attached clarification regarding the license terms.\n")
+        assert _is_chatlog(tmp_path, "email.txt", c) is False
+
+    def test_usenet_headers_not_flagged(self, tmp_path):
+        # tika testRFC822 / testMessageNews shape — 7 distinct one-shot headers
+        c = ("Path: news.example.com\nFrom: poster@example.com\n"
+             "Newsgroups: comp.lang.python\nSubject: Re: question\n"
+             "Date: 1 Jun 2026\nOrganization: Example\nLines: 12\n\nbody text here\n")
+        assert _is_chatlog(tmp_path, "news.txt", c) is False
+
+    def test_utf8_demo_labels_not_flagged(self, tmp_path):
+        # tmux tools/UTF-8-demo.txt shape — 6 distinct one-shot script labels
+        c = ("APL: ⍝ ⌽ ⊖\nBraille: ⠁⠂⠃\nGeorgian: შემოქმედი\n"
+             "Russian: Съешь же\nEthiopian: ሰላም\nRunes: ᚠᚢᚦ\n")
+        assert _is_chatlog(tmp_path, "UTF-8-demo.txt", c) is False
+
+    def test_language_label_block_not_flagged(self, tmp_path):
+        # tika multi-language.txt shape
+        c = ("English: The quick brown fox.\nPortuguese: A rápida raposa.\n"
+             "Spanish: El zorro rápido.\n")
+        assert _is_chatlog(tmp_path, "multi-language.txt", c) is False
+
+    def test_manpage_labels_not_flagged(self, tmp_path):
+        # autogpt docs/content/classic/usage.md shape — recurring doc labels
+        c = ("Usage: tool [opts]\nOptions: --verbose\nCommands: run\n"
+             "Usage: tool run [opts]\nOptions: --dry\nCommands: list\n")
+        assert _is_chatlog(tmp_path, "usage.md", c) is False
+
+    def test_doc_section_labels_not_flagged(self, tmp_path):
+        # autogpt battleship product spec shape — one-shot section labels
+        c = ("Overview: build battleship\nShips: 5 types\n"
+             "Setup: place ships\nObjective: sink all\n")
+        assert _is_chatlog(tmp_path, "spec.txt", c) is False
+
+    def test_legal_notice_not_flagged(self, tmp_path):
+        # tika NOTICE.txt shape
+        c = ("License: Apache 2.0\nLicense: see LICENSE file\n"
+             "OpenCSV: bundled under Apache 2.0\n")
+        assert _is_chatlog(tmp_path, "NOTICE.txt", c) is False
+
+    def test_oauth_form_fields_not_flagged(self, tmp_path):
+        # fastapi simple-oauth2.md shape — User:/Password: pairs (Password stop-listed)
+        c = ("User: johndoe\nPassword: secret\nUser: alice\nPassword: hunter2\n")
+        assert _is_chatlog(tmp_path, "oauth.md", c) is False
+
+
+class TestProseTruePositivesStillDetect:
+    """The fix must not regress genuine prose transcripts."""
+
+    def test_three_turn_two_speaker_recurs(self, tmp_path):
+        # 2 speakers, one recurs — minimal real back-and-forth
+        c = "Alice: hi there friend\nBob: hello back\nAlice: goodbye now\n"
+        assert _is_chatlog(tmp_path, "chat.txt", c) is True
+
+    def test_human_assistant_transcript(self, tmp_path):
+        c = ("Human: what's the weather\nAssistant: sunny today\n"
+             "Human: thanks\nAssistant: anytime\n")
+        assert _is_chatlog(tmp_path, "transcript.txt", c) is True
+
+    def test_markdown_transcript_with_h3_structure(self, tmp_path):
+        # detects via the structure rule (5+ H3 + speaker co-signal), not Rule 1
+        c = ("### Scene 1\nAlice: hi\n### Scene 2\nBob: hello\n### Scene 3\n"
+             "more\n### Scene 4\n### Scene 5\n")
+        assert _is_chatlog(tmp_path, "play.md", c) is True