gatewaysdk 0.3.2__py3-none-any.whl

gatewaysdk/environment/schema/_slack_scenario.py

@@ -0,0 +1,183 @@
+"""Slack collaboration scenarios and read-only baseline preservation grading."""
+
+import json
+
+from .validation import encoded
+
+
+def _literal(value):
+    return "'" + value.replace("'", "''") + "'"
+
+
+def _preservation(entities, mutations, parent):
+    """Compare each baseline entity as a set with fixed, authorized row deltas.
+
+    VALUES has no per-row compound SELECT or AND chain. One EXCEPT comparison
+    per nonempty entity detects changed/missing payloads; exact counts plus the
+    task's semantic predicates constrain additional rows. The literal baseline
+    is bundle-owned SQL data, never a writable table or a second state store.
+    """
+    expected = {entity: [] for entity in sorted(entities)}
+    for mutation in mutations:
+        entity, value = mutation["entity"], dict(mutation["value"])
+        if entity == "slack_messages" and value == parent:
+            value.pop("reply_count", None)
+            value.pop("latest_reply", None)
+        if (
+            entity == "slack_reaction_summaries"
+            and value["channel_id"] == parent["channel_id"]
+            and value["message_ts"] == parent["ts"]
+            and value["name"] == "white_check_mark"
+        ):
+            value["count"] += 1
+        expected[entity].append(json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False))
+    counts = {entity: len(rows) for entity, rows in expected.items()}
+    for entity in ("slack_messages", "slack_message_threads", "slack_reaction_users"):
+        counts[entity] += 1
+    if not any(
+        m["entity"] == "slack_reaction_summaries"
+        and m["value"]["channel_id"] == parent["channel_id"]
+        and m["value"]["message_ts"] == parent["ts"]
+        and m["value"]["name"] == "white_check_mark"
+        for m in mutations
+    ):
+        counts["slack_reaction_summaries"] += 1
+    ctes, comparisons = [], []
+    for index, (entity, rows) in enumerate(expected.items()):
+        if rows:
+            name = f"expected_{index}"
+            values = ",\n".join(f"({_literal(row)})" for row in rows)
+            ctes.append(f"{name}(payload) AS (VALUES\n{values})")
+            actual = "json(payload)"
+            if entity == "slack_messages":
+                actual = (
+                    f"CASE WHEN channel_id = {_literal(parent['channel_id'])} AND ts = {_literal(parent['ts'])} "
+                    "THEN json_remove(payload, '$.reply_count', '$.latest_reply') ELSE json(payload) END"
+                )
+            comparisons.append(f'NOT EXISTS (SELECT payload FROM {name} EXCEPT SELECT {actual} FROM "{entity}")')
+        comparisons.append(f'(SELECT COUNT(*) FROM "{entity}") = {counts[entity]}')
+    return "WITH " + ",\n".join(ctes), "\nAND ".join(comparisons)
+
+
+def _scenario(destination, evidence, batch, *, entities):
+    synthetic = evidence.get("synthetic") is True
+    messages = [m["value"] for m in batch["mutations"] if m["entity"] == "slack_messages"]
+    replies = {
+        (m["value"]["channel_id"], m["value"]["reply_ts"])
+        for m in batch["mutations"]
+        if m["entity"] == "slack_message_threads"
+    }
+    member_channels = {
+        m["value"]["channel_id"]
+        for m in batch["mutations"]
+        if m["entity"] == "slack_memberships" and m["value"]["user_id"] == evidence["principal"]["user_id"]
+    }
+    writable = {
+        m["value"]["id"]
+        for m in batch["mutations"]
+        if m["entity"] == "slack_channels" and not m["value"].get("is_archived") and not m["value"].get("is_frozen")
+    }
+    acknowledged = {
+        (m["value"]["channel_id"], m["value"]["message_ts"])
+        for m in batch["mutations"]
+        if m["entity"] == "slack_reaction_users"
+        and m["value"]["name"] == "white_check_mark"
+        and m["value"]["user_id"] == evidence["principal"]["user_id"]
+    }
+    roots = [
+        m
+        for m in messages
+        if (m["channel_id"], m["ts"]) not in replies | acknowledged
+        and m["channel_id"] in member_channels & writable
+        and m.get("subtype") not in ("channel_join", "channel_leave")
+    ]
+    if not roots:
+        (destination / "verifiers/state_present.sql").unlink(missing_ok=True)
+        return {"status": "unavailable", "reason": "No observed member conversation with a persistent root message."}
+    parent = next(
+        (m for m in roots if m["channel_id"] == "CGENERAL" and m["ts"] == "1700000000.000000000000000001"), roots[0]
+    )
+    text = (
+        "Handoff complete: release checklist reviewed; owner Alice; next update 17:00 UTC."
+        if synthetic
+        else "Review complete: captured workspace handoff acknowledged."
+    )
+
+    w, c, p, actor, body = map(
+        _literal,
+        (evidence["workspace"]["id"], parent["channel_id"], parent["ts"], evidence["principal"]["user_id"], text),
+    )
+    baseline, preserved = _preservation(entities, batch["mutations"], parent)
+    acknowledgement_count = 1 + sum(
+        mutation["value"]["count"]
+        for mutation in batch["mutations"]
+        if mutation["entity"] == "slack_reaction_summaries"
+        and mutation["value"]["channel_id"] == parent["channel_id"]
+        and mutation["value"]["message_ts"] == parent["ts"]
+        and mutation["value"]["name"] == "white_check_mark"
+    )
+    sql = f"""-- Read-only set comparisons keep preparation depth independent of record count.
+{baseline}
+SELECT CASE WHEN EXISTS (
+  SELECT 1 FROM slack_reaction_users r JOIN slack_reaction_summaries summary
+  ON summary.workspace_id = r.workspace_id AND summary.channel_id = r.channel_id
+  AND summary.message_ts = r.message_ts AND summary.name = r.name
+  WHERE r.workspace_id = {w}
+  AND r.channel_id = {c} AND r.message_ts = {p} AND r.user_id = {actor}
+  AND r.name = 'white_check_mark'
+  AND summary.count = {acknowledgement_count}
+) AND EXISTS (
+  SELECT 1 FROM slack_messages m JOIN slack_message_threads t
+  ON t.workspace_id = m.workspace_id AND t.channel_id = m.channel_id AND t.reply_ts = m.ts
+  JOIN slack_messages parent
+  ON parent.workspace_id = t.workspace_id AND parent.channel_id = t.channel_id AND parent.ts = t.parent_ts
+  WHERE m.workspace_id = {w} AND m.channel_id = {c} AND t.parent_ts = {p}
+  AND m.user = {actor} AND m.text = {body}
+  AND parent.reply_count = {parent.get('reply_count', 0) + 1} AND parent.latest_reply = m.ts
+) AND {preserved} THEN 1.0 ELSE 0.0 END;
+"""
+    (destination / "verifiers/state_present.sql").unlink(missing_ok=True)
+    (destination / "verifiers/handoff_complete.sql").write_text(sql)
+    task = (
+        f"Find the release-handoff discussion asking for checklist review. Read its thread and associated checklist metadata. Acknowledge the parent with white_check_mark and reply exactly: {text} Keep all other workspace state unchanged."
+        if synthetic
+        else f"Find and review the captured discussion beginning {parent.get('text', '')[:160]!r}. Read its thread, acknowledge the parent with white_check_mark and reply exactly: {text} Keep other workspace state unchanged."
+    )
+    discovery = [
+        {"tool": "conversations.list", "arguments": {"types": "public_channel,private_channel,im,mpim"}},
+        {"tool": "conversations.history", "arguments": {"channel": parent["channel_id"]}},
+        {"tool": "conversations.replies", "arguments": {"channel": parent["channel_id"], "ts": parent["ts"]}},
+    ]
+    if synthetic:
+        discovery.append({"tool": "files.info", "arguments": {"file": "FCHECKLIST"}})
+    return {
+        "status": "available",
+        "kind": "synthetic" if synthetic else "captured-subset",
+        "task": task,
+        "target": {"channel": parent["channel_id"], "thread_ts": parent["ts"]},
+        "oracle": [
+            *discovery,
+            {
+                "tool": "reactions.add",
+                "arguments": {"channel": parent["channel_id"], "timestamp": parent["ts"], "name": "white_check_mark"},
+            },
+            {
+                "tool": "chat.postMessage",
+                "arguments": {"channel": parent["channel_id"], "thread_ts": parent["ts"], "text": text},
+            },
+        ],
+        "verifier": "handoff_complete",
+    }
+
+
+def write_scenario(destination, evidence, state, *, entities):
+    scenario = _scenario(destination, evidence, state, entities=entities)
+    (destination / "scenario.json").write_bytes(encoded(scenario))
+    tasks = []
+    if scenario["status"] == "available":
+        tasks.append({"id": "handoff_complete", "prompt": scenario["task"], "verifier": scenario["verifier"]})
+    else:
+        (destination / "verifiers/handoff_complete.sql").unlink(missing_ok=True)
+    # Both the direct runner and hosted schema session resolve tasks.json. Keep
+    # the instruction with the verifier instead of relying on a generic fallback.
+    (destination / "tasks.json").write_bytes(encoded(tasks))