feat(board): clarify and filter source detail states

backend/app/demo_scope.py

@@ -40,6 +40,10 @@ async def has_real_source_context(
                        or nullif(btrim(source_post.source_process_unit_name), '') is not null
                        or nullif(btrim(source_post.source_sales_pool_code), '') is not null
                        or nullif(btrim(source_post.source_sales_pool_name), '') is not null
+                       or nullif(btrim(source_post.source_order_pool_code), '') is not null
+                       or nullif(btrim(source_post.source_sales_order_code), '') is not null
+                       or source_post.source_sales_order_item_number is not null
+                       or nullif(btrim(source_post.source_inspection_point_code), '') is not null
                        or nullif(btrim(source_post.source_customer_code), '') is not null
                        or nullif(btrim(source_post.source_customer_name), '') is not null
                        or nullif(btrim(source_post.source_project_code), '') is not null
@@ -72,6 +76,10 @@ async def fetch_demo_corporate_entity_ids(conn: asyncpg.Connection) -> set[str]:
                       or nullif(btrim(real_post.source_process_unit_name), '') is not null
                       or nullif(btrim(real_post.source_sales_pool_code), '') is not null
                       or nullif(btrim(real_post.source_sales_pool_name), '') is not null
+                      or nullif(btrim(real_post.source_order_pool_code), '') is not null
+                      or nullif(btrim(real_post.source_sales_order_code), '') is not null
+                      or real_post.source_sales_order_item_number is not null
+                      or nullif(btrim(real_post.source_inspection_point_code), '') is not null
                       or nullif(btrim(real_post.source_customer_code), '') is not null
                       or nullif(btrim(real_post.source_customer_name), '') is not null
                       or nullif(btrim(real_post.source_project_code), '') is not null

backend/app/five_w1h_ingestion.py

@@ -35,7 +35,8 @@ async def load_five_w1h_slots(
     linked_titles: list[str] = []
     if candidate_ids:
         rows = await conn.fetch(
-            "select post_id, post_title, visibility_code, corporate_entity_id "
+            "select post_id, post_title, visibility_code, corporate_entity_id, "
+            "author_account_id, source_detail_state_code "
             "from source_post where post_id = any($1::uuid[])",
             candidate_ids,
         )

backend/app/global_ask_history.py

@@ -112,7 +112,8 @@ async def _visible_post_ids(
     rows = await conn.fetch(
         f"""
         select relation.{id_column}::text as post_id, relation.{ordinal_column} as ordinal,
-               post.post_title, post.visibility_code, post.corporate_entity_id
+               post.post_title, post.visibility_code, post.corporate_entity_id,
+               post.author_account_id, post.source_detail_state_code
           from {table} relation
           join source_post post on post.post_id = relation.{id_column}
          where relation.global_ask_session_id = $1

backend/app/issue_ticket_ingestion.py

@@ -139,6 +139,7 @@ async def fetch_upcoming_commitments(conn: asyncpg.Connection) -> list[dict[str,
         "issue_ticket.commitment_summary, issue_ticket.created_at, "
         "issue_ticket.updated_at, "
         "p.post_title, p.visibility_code, p.corporate_entity_id, "
+        "p.author_account_id, p.source_detail_state_code, "
         f"({_SOURCE_CONTEXT_PRESENT_SQL}) as has_real_source_context "
         "from issue_ticket "
         "join source_post p on p.post_id = issue_ticket.post_id "
@@ -154,6 +155,8 @@ async def fetch_upcoming_commitments(conn: asyncpg.Connection) -> list[dict[str,
                 "post_title": row["post_title"],
                 "visibility_code": row["visibility_code"],
                 "corporate_entity_id": str(row["corporate_entity_id"]),
+                "author_account_id": str(row["author_account_id"]),
+                "source_detail_state_code": row["source_detail_state_code"],
                 "has_real_source_context": bool(row["has_real_source_context"]),
             }
             for row in rows

backend/app/knowledge_graph.py

@@ -35,6 +35,7 @@
     select_related_nodes,
 )
 from lineageweave.ontology import ontology_annotations, semantic_predicate_annotations
+from lineageweave.source_lineage_hints import source_lineage_hints
 
 _GRAPH_PROJECTION_LOCK_KEY = "lineageweave:knowledge_graph_projection"
 
@@ -60,6 +61,7 @@
     "quality_assessment": "https://contextualwisdomlab.github.io/lineageweave/ontology#QualityAssessment",
     "risk_statement": "https://contextualwisdomlab.github.io/lineageweave/ontology#RiskStatement",
     "organization_context": "https://contextualwisdomlab.github.io/lineageweave/ontology#OrganizationContext",
+    "source_observation": "https://contextualwisdomlab.github.io/lineageweave/ontology#Observation",
 }
 
 
@@ -283,7 +285,8 @@ async def visible_mention_post_ids(
     # Safe SQL: the eligibility predicate is an immutable schema fragment; person id is bound.
     rows = await conn.fetch(  # nosemgrep: python.lang.security.audit.sqli.asyncpg-sqli.asyncpg-sqli
         f"""
-        select post.post_id, post.visibility_code, post.corporate_entity_id
+        select post.post_id, post.visibility_code, post.corporate_entity_id,
+               post.author_account_id, post.source_detail_state_code
           from combined_post_person_mention mention
           join source_post post on post.post_id = mention.post_id
          where mention.person_id = $1
@@ -304,7 +307,8 @@ async def visible_affiliation_post_ids(
     rows = await conn.fetch(  # nosemgrep: python.lang.security.audit.sqli.asyncpg-sqli.asyncpg-sqli
         f"""
         select distinct post.post_id, post.visibility_code,
-                        post.corporate_entity_id, post.created_at
+                        post.corporate_entity_id, post.author_account_id,
+                        post.source_detail_state_code, post.created_at
           from source_post post
          where {SOURCE_POST_ELIGIBILITY_SQL.format(alias='post')}
            and post.post_id in (
@@ -334,7 +338,8 @@ async def visible_team_mention_post_ids(
     # Safe SQL: the eligibility predicate is an immutable schema fragment; team id is bound.
     rows = await conn.fetch(  # nosemgrep: python.lang.security.audit.sqli.asyncpg-sqli.asyncpg-sqli
         f"""
-        select post.post_id, post.visibility_code, post.corporate_entity_id
+        select post.post_id, post.visibility_code, post.corporate_entity_id,
+               post.author_account_id, post.source_detail_state_code
           from post_team_mention mention
           join source_post post on post.post_id = mention.post_id
          where mention.team_id = $1
@@ -666,6 +671,81 @@ def semantic_key(node_type: str, name: str) -> str:
                 "evidence_post_ids": [post_id],
             }
         )
+
+    source_row = await conn.fetchrow(
+        """
+        select source_customer_code, source_order_pool_code,
+               source_sales_order_code, source_sales_order_item_number,
+               source_stage_code, source_detail_state_code,
+               source_inspection_point_code, source_deleted_flag
+          from source_post
+         where post_id = $1
+        """,
+        post_id,
+    )
+    if source_row is not None:
+        source_values = dict(source_row)
+        observed_source_fields = any(
+            value is not None and (not isinstance(value, str) or bool(value.strip()))
+            for value in source_values.values()
+        )
+        if observed_source_fields:
+            source_hints = source_lineage_hints(
+                customer_code=source_row["source_customer_code"],
+                order_pool_code=source_row["source_order_pool_code"],
+                sales_order_code=source_row["source_sales_order_code"],
+                sales_order_item_number=source_row["source_sales_order_item_number"],
+                stage_code=source_row["source_stage_code"],
+                detail_state_code=source_row["source_detail_state_code"],
+                inspection_point_code=source_row["source_inspection_point_code"],
+                deleted_flag=source_row["source_deleted_flag"],
+            )
+            source_observations = [
+                (
+                    "commercial_context",
+                    f"Commercial context: {source_hints['commercial_context_code']}",
+                    "combination="
+                    f"{source_hints['combination_code']}; "
+                    f"present_fields={','.join(source_hints['present_fields']) or 'none'}; "
+                    "inference=inferred; provenance=source_post.field_presence",
+                ),
+                (
+                    "lifecycle_vector",
+                    f"Lifecycle vector: {source_hints['lifecycle_vector']}",
+                    "raw_codes_only; provenance=source_post.lifecycle_fields",
+                ),
+            ]
+            predicate = semantic_predicate_annotations("prov_was_derived_from")
+            for kind, label, evidence_text in source_observations:
+                digest = hashlib.sha256(
+                    f"{post_id}\0{kind}\0{label}".encode()
+                ).hexdigest()[:16]
+                observation_key = f"source-observation:{post_id}:{digest}"
+                nodes.setdefault(
+                    observation_key,
+                    {
+                        "id": observation_key,
+                        "node_type_code": "semantic_source_observation",
+                        "node_id": observation_key,
+                        "label": label,
+                        "ontology_iri": _SEMANTIC_NODE_CLASS_IRIS["source_observation"],
+                        "ontology_label": "Observation",
+                        "is_focus": False,
+                        "is_evidence_text_node": True,
+                    },
+                )
+                edges.append(
+                    {
+                        "source": observation_key,
+                        "target": node_key(NODE_POST, post_id),
+                        "edge_type_code": "prov_was_derived_from",
+                        "ontology_iri": predicate.get("ontology_iri"),
+                        "ontology_label": predicate.get("ontology_label", "Was derived from"),
+                        "confidence": 1.0,
+                        "evidence_text": evidence_text,
+                        "evidence_post_ids": [post_id],
+                    }
+                )
     return {
         "post_id": post_id,
         "nodes": list(nodes.values()),

backend/app/lineage_ingestion.py

@@ -98,7 +98,8 @@ async def visible_lineage_graph(
     """
     posts = await conn.fetch(
         "select post_id, post_title, voc_type_code, visibility_code, "
-        "corporate_entity_id, process_unit_id, thread_group_key, created_at "
+        "corporate_entity_id, author_account_id, source_detail_state_code, "
+        "process_unit_id, thread_group_key, created_at "
         f"from source_post where {SOURCE_POST_ELIGIBILITY_SQL.format(alias='source_post')}"
     )
     visible_all = [row for row in posts if can_see_post(row)]