domainforge 0.13.0

package/scripts/update_launch_program.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""
+Update `.vscode/launch.json` program path for "Debug Rust Test (auto)" configuration
+to point at the prepared debug binary `target/debug/deps/sea_debug_test`.
+
+Usage:
+  python3 scripts/update_launch_program.py --program <path>
+
+If the file does not exist, writes the default program path.
+"""
+
+import argparse
+import json
+import os
+import sys
+
+
+def find_config_index(configs, name):
+    for idx, c in enumerate(configs):
+        if c.get("name") == name:
+            return idx
+    return -1
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--program", help="Path to the rust test binary (symlink)")
+    parser.add_argument("--launch", default=".vscode/launch.json")
+    parser.add_argument("--config-name", default="Debug Rust Test (auto)")
+    args = parser.parse_args()
+
+    # Prefer a workspace-relative program path so launch.json remains portable
+    program_path = args.program or os.path.join(
+        "${workspaceFolder}", "target", "debug", "deps", "sea_debug_test"
+    )
+    # If program_path is absolute and inside the workspace, replace the prefix with ${workspaceFolder}
+    workspace_prefix = os.path.abspath(".")
+    if "${workspaceFolder}" not in program_path:
+        abs_program_path = os.path.abspath(program_path)
+        normalized_workspace = os.path.normcase(os.path.normpath(workspace_prefix))
+        normalized_program = os.path.normcase(os.path.normpath(abs_program_path))
+        if normalized_program.startswith(normalized_workspace):
+            rel_path = os.path.relpath(abs_program_path, workspace_prefix)
+            program_path = os.path.join("${workspaceFolder}", rel_path).replace("\\", "/")
+        else:
+            program_path = abs_program_path.replace("\\", "/")
+    launch_path = args.launch
+
+    if not os.path.exists(launch_path):
+        print(
+            f"Warning: {launch_path} not found, creating a new launch.json with default config"
+        )
+        launch = {"version": "0.2.0", "configurations": []}
+    else:
+        try:
+            with open(launch_path, "r") as f:
+                launch = json.load(f)
+        except json.JSONDecodeError as err:
+            print(f"Failed to parse {launch_path}: {err}")
+            sys.exit(1)
+
+    configs = launch.setdefault("configurations", [])
+    idx = find_config_index(configs, args.config_name)
+
+    if idx == -1:
+        # If not found, add a new configuration stub
+        configs.append(
+            {
+                "name": args.config_name,
+                "type": "codelldb",
+                "request": "launch",
+                "program": program_path,
+                "args": ["--nocapture", "${input:rustTestName}"],
+                "cwd": "${workspaceFolder}",
+                "stopAtEntry": False,
+                "terminal": "integrated",
+            }
+        )
+        print(f"Added {args.config_name} to launch.json with program={program_path}")
+    else:
+        configs[idx]["program"] = program_path
+        print(f"Updated {args.config_name} program to {program_path}")
+
+    launch_dir = os.path.dirname(launch_path)
+    if launch_dir:
+        os.makedirs(launch_dir, exist_ok=True)
+    with open(launch_path, "w") as f:
+        json.dump(launch, f, indent=2)
+    print(f"Wrote updated launch.json: {launch_path}")
+
+
+if __name__ == "__main__":
+    main()

package/secrets/README.md

@@ -0,0 +1,27 @@
+# Secrets directory
+
+This folder contains templates for project secrets and instructions to encrypt them using SOPS and Age.
+
+- `secrets.template.yaml` — placeholders only. Do not add real secrets here.
+- `secrets.yaml` — recommended final encrypted file, committed to the repo as encrypted by sops.
+
+Quick usage:
+
+```bash
+# copy the template to a file, populate it with real values (locally only)
+cp secrets/secrets.template.yaml secrets/secrets.yaml
+# encrypt in-place (replace AGE recipient)
+sops --encrypt --age "age1PUBKEY" --in-place secrets/secrets.yaml
+# verify, commit
+git add secrets/secrets.yaml && git commit -m "Add encrypted secrets"
+```
+
+Get your age public key (example):
+
+```bash
+# generate a new key pair and display the public key
+age-keygen -o ~/.config/age/identity.key
+# the command prints "Public key: age1..." which you can use in .sops.yaml or sops --age
+```
+
+If you accidentally commit unencrypted secrets, remove them from git history, rotate any keys, and inform the team.

package/secrets/secrets.yaml

@@ -0,0 +1,21 @@
+#ENC[AES256_GCM,data:6pK7hcKpV/T/PZUR6LoVAFhLk/QI2HS7y9743J+IQRcEzzaNCIAg8f86POhGLwC1tl7m4nIcRA==,iv:7dZQwgSghllovVRcTylOifbL8jV+WV8kJOijpGyPg6M=,tag:TlNZlriOr9yQLwmaBeGrmA==,type:comment]
+#ENC[AES256_GCM,data:RxrXMhdDFDkWjGUZMXMUGp+esb6lcIooaEuG3wAUi0R4pmzjD6BzQktHo5pcHrqA5UmvE5+rZg==,iv:OqpXUv5NsmOAllRFC/axsR8BFHx48iQzJauo3ZrGPUE=,tag:TVY8WqkSSWQivmVTbMWSZw==,type:comment]
+PYPI_TEST_API_TOKEN: ENC[AES256_GCM,data:pfbrKqZpTIOmvrjbPR8PwysN8PskPLSgKBmeYtL/HVhPpQVRM6zs/gAB1Kvey2sx4YaL8KfQdJd+T9JnOQuMDgH0EqYsMS7I7tuP4dJbQtOL0hFRuJBPs+nTNeSQ6LV95zW6curqNhXC9shYIg3jQNiCej2mewlYEshnb19MwSVyCLKZ3eejEEmfFadQN0KPPJWX9l6nxsepZ9ke8v9gVRMjT37Sf/sN5oGDPv18ry72bNBLPvNvxjc=,iv:fWLP0faTnWPrWfvyd2GEr3+Qn0Ls7Rk4VbKosMioKEA=,tag:YUm3PYmCQFSoUoZ3Php9+w==,type:str]
+PYPI_API_TOKEN: ENC[AES256_GCM,data:ErgZWsXEeNvpYFjOooqzIXei8uBUpZkm7NmTS6FrOc/Cn3V53uSWs0Z96eBVh/4DbZCEOBze5EUstWYNjgGpmug/D7a4AE7Y171k/oDDPBfXVQyuQi1FZhGz2eRBxq7KjVyJbc850nyDGGoVpxpGMplXogRS1sQvg+kiV50bxgD9PzkFi5dvzrwoRxONu0keJjgDT50hEev18w4M85paJ4dXufD6gJazuI4sMOGV7U1Mn1Q=,iv:meNgGdAfDMYtPOdtZdXKngF2vOu5wFvkeMN6vvMeRwQ=,tag:tEBH4jhMbW9tFb6ukQ3oqg==,type:str]
+NPM_TOKEN: ENC[AES256_GCM,data:cHmw67qQfoMEVyOR2a0gW6y2mTlU1E5ujbY5t0SHV9DoS2wY9MDiOg==,iv:T5iTNP0jZtf+nsa8HTC8yepqdjmUPISg9biU1p5EMC4=,tag:2yJc5aLgxvIWEUooZdPgYg==,type:str]
+CARGO_REGISTRY_TOKEN: ENC[AES256_GCM,data:8bf8hkiv0myqffATBNYdvJm5tf3P5llxxdyo8C9/YuYeD0k=,iv:zg1qdDwClMSs4LmXR1pqSlla4jOoxaGRE1aNQnDl/s4=,tag:UOekLRYsxcxTLw/0AphXOg==,type:str]
+sops:
+    age:
+        - recipient: age1mq5sj8gj4k5vqtgefkuvs05nghanzhgmcqkxxspk0vffq9hxm5ssnj93a5
+          enc: |
+            -----BEGIN AGE ENCRYPTED FILE-----
+            YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSBhZGNoaWFnK0VUR3Y4WWlq
+            V2pvU25WZjZPam1WenRzNmtCc0dtOFBQbDBVCjBrd2pXQnlnY0JUVWsrdGZPcFVy
+            cXFoUThNWjdDNTJOTXFERWlHK2ZzRUkKLS0tIFUzblkveE5DYXRVUldQemE4T3pC
+            dGZabzFkMEVzZDZYcmFZTWFSTkNXejAKPHhdfuiXu4ZCpoM3cQi48Pc0i17yCqph
+            QD8lsKfQXdFvbzz6XxXwpsYcXH+eQpvFiMOgrIkmuz7Zegfp+Oa++g==
+            -----END AGE ENCRYPTED FILE-----
+    lastmodified: "2025-12-07T02:12:19Z"
+    mac: ENC[AES256_GCM,data:h9h0FqOkoZFutnzkJ4w4zZ/Yg2aTspObl/Hyt6PcGylZNTsWpaw2VNgvO0pNkzpLO3RoEvcws74YrWAMycP4NR5xml73LXFPEDYNiDnSHqwSaWTJla6ED9oGGEmG2Zs8GDS/UyhtqMsk+pEllmi4C+1TcAp5JhDwVNdLmhHvRVE=,iv:PbWb/uSG/hUciJRGNhPORXITCahACR5HDL6g+5dRzQs=,tag:fA/X0hgGcjlzvTzF0GlHHQ==,type:str]
+    unencrypted_suffix: _unencrypted
+    version: 3.11.0

package/test_integration.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+import domainforge
+
+# Create a supply chain model
+graph = domainforge.Graph()
+
+# Create entities
+supplier = domainforge.Entity("Supplier", "supply_chain")
+warehouse = domainforge.Entity("Warehouse", "supply_chain")
+store = domainforge.Entity("Store", "retail")
+
+# Create resources
+widgets = domainforge.Resource("Widgets", "units")
+gadgets = domainforge.Resource("Gadgets", "units")
+
+# Add to graph
+graph.add_entity(supplier)
+graph.add_entity(warehouse)
+graph.add_entity(store)
+graph.add_resource(widgets)
+graph.add_resource(gadgets)
+
+# Create flows
+flow1 = domainforge.Flow(widgets.id, supplier.id, warehouse.id, 500.0)
+flow2 = domainforge.Flow(widgets.id, warehouse.id, store.id, 300.0)
+flow3 = domainforge.Flow(gadgets.id, supplier.id, warehouse.id, 200.0)
+
+graph.add_flow(flow1)
+graph.add_flow(flow2)
+graph.add_flow(flow3)
+
+# Query the graph
+print(f"Graph Statistics:")
+print(f"  Entities: {graph.entity_count()}")
+print(f"  Resources: {graph.resource_count()}")
+print(f"  Flows: {graph.flow_count()}")
+print()
+
+# Find entity by name
+warehouse_id = graph.find_entity_by_name("Warehouse")
+if warehouse_id is None:
+    raise ValueError("Warehouse entity not found in graph")
+print(f"Warehouse ID: {warehouse_id}")
+print()
+
+# Get flows from warehouse
+flows_from_warehouse = graph.flows_from(warehouse_id)
+print(f"Flows from Warehouse: {len(flows_from_warehouse)}")
+for flow in flows_from_warehouse:
+    print(f"  - {flow.quantity} units")
+print()
+
+# Parse DSL source
+dsl_source = '''
+Entity "Supplier" in supply_chain
+Entity "Factory" in manufacturing
+Resource "Steel" tons
+Flow "Steel" from "Supplier" to "Factory" quantity 100
+'''
+
+parsed = domainforge.Graph.parse(dsl_source)
+print(f"Parsed Graph:")
+print(f"  Entities: {parsed.entity_count()}")
+print(f"  Resources: {parsed.resource_count()}")
+print(f"  Flows: {parsed.flow_count()}")
+
+print("\nAll tests passed! Python bindings are working correctly.")

package/tests/test_authority.py

@@ -0,0 +1,328 @@
+"""
+Tests for the new Policy Authority API exports added in this PR.
+
+Covers:
+- Enum exports: FinalDecision, PolicyModality, SourceClass, ClaimLevel
+- Class: AuthorityEnvironment
+- Function: evaluate_authority
+"""
+
+import json
+import pytest
+import domainforge
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def make_minimal_config_json(packs=None) -> str:
+    if packs is None:
+        packs = []
+    return json.dumps({
+        "resolver_semantics_version": "0.4",
+        "specificity_profile": {
+            "id": "default",
+            "dimensions": [],
+            "scoring_rules": {},
+            "hash": "",
+        },
+        "unknown_handling": {
+            "permission": {"default": "escalate"},
+            "prohibition": {"default": "deny"},
+            "obligation": {"default": "escalate"},
+            "override_": {"default": "not_applicable"},
+        },
+        "fact_sources": [],
+        "fact_transforms": [],
+        "authority_packs": packs,
+        "strict_mode": False,
+        "compatibility_lowering_version": "0.4",
+        "resolver_version": "0.1",
+    })
+
+
+def make_minimal_request_json(operation="TestAction", resource_type="Order") -> str:
+    return json.dumps({
+        "request_id": "req-001",
+        "actor": {"id": "user-1"},
+        "operation": operation,
+        "resource": {"type": resource_type},
+        "context": {},
+        "requested_at": "2026-06-07T00:00:00Z",
+    })
+
+
+# ---------------------------------------------------------------------------
+# Enum import tests
+# ---------------------------------------------------------------------------
+
+def test_final_decision_enum_importable():
+    """FinalDecision enum is importable from domainforge."""
+    assert hasattr(domainforge, "FinalDecision")
+
+
+def test_final_decision_enum_values():
+    """FinalDecision has Allow, Deny, Escalate, NotApplicable, Reject members."""
+    assert hasattr(domainforge.FinalDecision, "Allow")
+    assert hasattr(domainforge.FinalDecision, "Deny")
+    assert hasattr(domainforge.FinalDecision, "Escalate")
+    assert hasattr(domainforge.FinalDecision, "NotApplicable")
+    assert hasattr(domainforge.FinalDecision, "Reject")
+
+
+def test_final_decision_members_are_distinct():
+    """FinalDecision enum members are not equal to each other."""
+    assert domainforge.FinalDecision.Allow != domainforge.FinalDecision.Deny
+    assert domainforge.FinalDecision.Allow != domainforge.FinalDecision.Escalate
+    assert domainforge.FinalDecision.Allow != domainforge.FinalDecision.NotApplicable
+    assert domainforge.FinalDecision.Allow != domainforge.FinalDecision.Reject
+    assert domainforge.FinalDecision.Deny != domainforge.FinalDecision.Reject
+
+
+def test_policy_modality_enum_importable():
+    """PolicyModality enum is importable from domainforge."""
+    assert hasattr(domainforge, "PolicyModality")
+
+
+def test_policy_modality_enum_values():
+    """PolicyModality has Permission, Prohibition, Obligation, Override members."""
+    assert hasattr(domainforge.PolicyModality, "Permission")
+    assert hasattr(domainforge.PolicyModality, "Prohibition")
+    assert hasattr(domainforge.PolicyModality, "Obligation")
+    assert hasattr(domainforge.PolicyModality, "Override")
+
+
+def test_policy_modality_members_are_distinct():
+    """PolicyModality enum members are not equal to each other."""
+    assert domainforge.PolicyModality.Permission != domainforge.PolicyModality.Prohibition
+    assert domainforge.PolicyModality.Obligation != domainforge.PolicyModality.Override
+
+
+def test_source_class_enum_importable():
+    """SourceClass enum is importable from domainforge."""
+    assert hasattr(domainforge, "SourceClass")
+
+
+def test_source_class_enum_values():
+    """SourceClass has all seven members."""
+    for member in [
+        "CallerSupplied", "RuntimeObserved", "SystemOfRecord",
+        "Attested", "ManualApproval", "Derived", "UnknownSource",
+    ]:
+        assert hasattr(domainforge.SourceClass, member), f"Missing SourceClass.{member}"
+
+
+def test_source_class_members_are_distinct():
+    """SourceClass enum members are not equal to each other."""
+    assert domainforge.SourceClass.CallerSupplied != domainforge.SourceClass.SystemOfRecord
+    assert domainforge.SourceClass.Derived != domainforge.SourceClass.UnknownSource
+
+
+def test_claim_level_enum_importable():
+    """ClaimLevel enum is importable from domainforge."""
+    assert hasattr(domainforge, "ClaimLevel")
+
+
+def test_claim_level_enum_values():
+    """ClaimLevel has AuditBacked, Validated, FormallyProven members."""
+    assert hasattr(domainforge.ClaimLevel, "AuditBacked")
+    assert hasattr(domainforge.ClaimLevel, "Validated")
+    assert hasattr(domainforge.ClaimLevel, "FormallyProven")
+
+
+def test_claim_level_members_are_distinct():
+    """ClaimLevel enum members are not equal to each other."""
+    assert domainforge.ClaimLevel.AuditBacked != domainforge.ClaimLevel.Validated
+    assert domainforge.ClaimLevel.Validated != domainforge.ClaimLevel.FormallyProven
+
+
+# ---------------------------------------------------------------------------
+# AuthorityEnvironment class
+# ---------------------------------------------------------------------------
+
+def test_authority_environment_class_importable():
+    """AuthorityEnvironment class is importable from domainforge."""
+    assert hasattr(domainforge, "AuthorityEnvironment")
+
+
+def test_authority_environment_instantiation():
+    """AuthorityEnvironment can be instantiated from a minimal config JSON."""
+    env = domainforge.AuthorityEnvironment(make_minimal_config_json())
+    assert env is not None
+
+
+def test_authority_environment_raises_on_invalid_config():
+    """AuthorityEnvironment raises ValueError on invalid config JSON."""
+    with pytest.raises((ValueError, Exception)):
+        domainforge.AuthorityEnvironment("not valid json")
+
+
+def test_authority_environment_validate():
+    """AuthorityEnvironment.validate() succeeds for a valid config."""
+    env = domainforge.AuthorityEnvironment(make_minimal_config_json())
+    # Should not raise
+    env.validate()
+
+
+def test_authority_environment_evaluate_returns_tuple():
+    """AuthorityEnvironment.evaluate() returns a (trace_json, decision_json) tuple."""
+    env = domainforge.AuthorityEnvironment(make_minimal_config_json())
+    env.validate()
+    result = env.evaluate(make_minimal_request_json())
+    assert isinstance(result, tuple)
+    assert len(result) == 2
+
+
+def test_authority_environment_evaluate_returns_valid_json():
+    """AuthorityEnvironment.evaluate() returns valid JSON strings."""
+    env = domainforge.AuthorityEnvironment(make_minimal_config_json())
+    env.validate()
+    trace_json, decision_json = env.evaluate(make_minimal_request_json())
+    json.loads(trace_json)   # must parse
+    json.loads(decision_json)  # must parse
+
+
+def test_authority_environment_evaluate_raises_on_invalid_request():
+    """AuthorityEnvironment.evaluate() raises on invalid request JSON."""
+    env = domainforge.AuthorityEnvironment(make_minimal_config_json())
+    env.validate()
+    with pytest.raises((ValueError, Exception)):
+        env.evaluate("not valid json")
+
+
+def test_authority_environment_evaluate_with_empty_facts():
+    """AuthorityEnvironment.evaluate() accepts empty facts array."""
+    env = domainforge.AuthorityEnvironment(make_minimal_config_json())
+    env.validate()
+    trace_json, decision_json = env.evaluate(make_minimal_request_json(), "[]")
+    decision = json.loads(decision_json)
+    assert "final_decision" in decision
+
+
+def test_authority_environment_not_applicable_with_no_packs():
+    """AuthorityEnvironment returns not_applicable when no packs are loaded."""
+    env = domainforge.AuthorityEnvironment(make_minimal_config_json([]))
+    env.validate()
+    _, decision_json = env.evaluate(make_minimal_request_json())
+    decision = json.loads(decision_json)
+    assert decision["final_decision"] == "not_applicable"
+
+
+def test_authority_environment_repr():
+    """AuthorityEnvironment has a string representation."""
+    env = domainforge.AuthorityEnvironment(make_minimal_config_json())
+    assert isinstance(str(env), str)
+
+
+# ---------------------------------------------------------------------------
+# evaluate_authority function
+# ---------------------------------------------------------------------------
+
+def test_evaluate_authority_is_callable():
+    """evaluate_authority is a callable function in domainforge."""
+    assert callable(domainforge.evaluate_authority)
+
+
+def test_evaluate_authority_returns_tuple():
+    """evaluate_authority returns a (trace_json, decision_json) tuple."""
+    result = domainforge.evaluate_authority(
+        make_minimal_config_json(),
+        make_minimal_request_json(),
+    )
+    assert isinstance(result, tuple)
+    assert len(result) == 2
+
+
+def test_evaluate_authority_returns_valid_json():
+    """evaluate_authority returns valid JSON strings in both elements."""
+    trace_json, decision_json = domainforge.evaluate_authority(
+        make_minimal_config_json(),
+        make_minimal_request_json(),
+    )
+    json.loads(trace_json)
+    json.loads(decision_json)
+
+
+def test_evaluate_authority_raises_on_invalid_config():
+    """evaluate_authority raises on invalid config JSON."""
+    with pytest.raises((ValueError, Exception)):
+        domainforge.evaluate_authority("not valid json", make_minimal_request_json())
+
+
+def test_evaluate_authority_raises_on_invalid_request():
+    """evaluate_authority raises on invalid request JSON."""
+    with pytest.raises((ValueError, Exception)):
+        domainforge.evaluate_authority(make_minimal_config_json(), "not valid json")
+
+
+def test_evaluate_authority_raises_on_invalid_facts():
+    """evaluate_authority raises on invalid facts JSON."""
+    with pytest.raises((ValueError, Exception)):
+        domainforge.evaluate_authority(
+            make_minimal_config_json(),
+            make_minimal_request_json(),
+            "not valid json",
+        )
+
+
+def test_evaluate_authority_not_applicable_with_no_packs():
+    """evaluate_authority returns not_applicable when no packs are loaded."""
+    _, decision_json = domainforge.evaluate_authority(
+        make_minimal_config_json([]),
+        make_minimal_request_json(),
+    )
+    decision = json.loads(decision_json)
+    assert decision["final_decision"] == "not_applicable"
+
+
+def test_evaluate_authority_decision_has_final_decision_field():
+    """evaluate_authority decision contains a final_decision field."""
+    _, decision_json = domainforge.evaluate_authority(
+        make_minimal_config_json(),
+        make_minimal_request_json(),
+    )
+    decision = json.loads(decision_json)
+    assert "final_decision" in decision
+    valid_decisions = {"allow", "deny", "escalate", "not_applicable", "reject"}
+    assert decision["final_decision"] in valid_decisions
+
+
+def test_evaluate_authority_trace_references_request_id():
+    """evaluate_authority trace references the request_id from the request."""
+    trace_json, _ = domainforge.evaluate_authority(
+        make_minimal_config_json(),
+        make_minimal_request_json(),
+    )
+    assert "req-001" in trace_json
+
+
+def test_evaluate_authority_with_explicit_empty_facts():
+    """evaluate_authority accepts explicit empty facts JSON array."""
+    trace_json, decision_json = domainforge.evaluate_authority(
+        make_minimal_config_json(),
+        make_minimal_request_json(),
+        "[]",
+    )
+    assert isinstance(trace_json, str)
+    assert isinstance(decision_json, str)
+
+
+def test_evaluate_authority_is_deterministic():
+    """Two calls with identical inputs produce the same final_decision."""
+    config = make_minimal_config_json()
+    request = make_minimal_request_json()
+    _, d1 = domainforge.evaluate_authority(config, request)
+    _, d2 = domainforge.evaluate_authority(config, request)
+    assert json.loads(d1)["final_decision"] == json.loads(d2)["final_decision"]
+
+
+def test_evaluate_authority_handles_different_operations():
+    """evaluate_authority processes requests with different operations."""
+    for operation in ["CreateOrder", "DeleteOrder", "UpdateOrder"]:
+        _, decision_json = domainforge.evaluate_authority(
+            make_minimal_config_json(),
+            make_minimal_request_json(operation=operation),
+        )
+        decision = json.loads(decision_json)
+        assert "final_decision" in decision

package/tests/test_ci_tasks.py

@@ -0,0 +1,143 @@
+import io
+import os
+import tarfile
+import tempfile
+import zipfile
+
+import pytest
+
+from scripts.ci_tasks import (
+    _is_safe_path,
+    _validate_tar_member,
+    _validate_zip_member,
+    unpack_and_verify,
+)
+
+
+class TestSafePath:
+    def test_normal_path_is_safe(self):
+        assert _is_safe_path("/tmp/dest", "file.txt")
+
+    def test_subdirectory_is_safe(self):
+        assert _is_safe_path("/tmp/dest", "sub/file.txt")
+
+    def test_traversal_is_unsafe(self):
+        assert not _is_safe_path("/tmp/dest", "../outside.txt")
+
+    def test_deep_traversal_is_unsafe(self):
+        assert not _is_safe_path("/tmp/dest", "foo/../../outside.txt")
+
+    def test_absolute_path_is_unsafe(self):
+        assert not _is_safe_path("/tmp/dest", "/etc/passwd")
+
+
+class TestTarValidation:
+    def test_safe_member_passes(self):
+        member = tarfile.TarInfo(name="safe_file.txt")
+        _validate_tar_member("/tmp/dest", member)
+
+    def test_traversal_rejected(self):
+        member = tarfile.TarInfo(name="../outside.txt")
+        with pytest.raises(ValueError, match="Unsafe path"):
+            _validate_tar_member("/tmp/dest", member)
+
+    def test_absolute_path_rejected(self):
+        member = tarfile.TarInfo(name="/etc/passwd")
+        with pytest.raises(ValueError, match="Unsafe path"):
+            _validate_tar_member("/tmp/dest", member)
+
+    def test_symlink_rejected(self):
+        member = tarfile.TarInfo(name="link")
+        member.type = tarfile.SYMTYPE
+        member.linkname = "/etc/passwd"
+        with pytest.raises(ValueError, match="Symlink"):
+            _validate_tar_member("/tmp/dest", member)
+
+    def test_hardlink_rejected(self):
+        member = tarfile.TarInfo(name="link")
+        member.type = tarfile.LNKTYPE
+        member.linkname = "/etc/passwd"
+        with pytest.raises(ValueError, match="Hardlink|Symlink"):
+            _validate_tar_member("/tmp/dest", member)
+
+    def test_deep_traversal_rejected(self):
+        member = tarfile.TarInfo(name="foo/../../outside.txt")
+        with pytest.raises(ValueError, match="Unsafe path"):
+            _validate_tar_member("/tmp/dest", member)
+
+
+class TestZipValidation:
+    def test_safe_entry_passes(self):
+        _validate_zip_member("/tmp/dest", "safe_file.txt")
+
+    def test_traversal_rejected(self):
+        with pytest.raises(ValueError, match="Unsafe path"):
+            _validate_zip_member("/tmp/dest", "../outside.txt")
+
+    def test_absolute_path_rejected(self):
+        with pytest.raises(ValueError, match="Unsafe path"):
+            _validate_zip_member("/tmp/dest", "/etc/passwd")
+
+
+class TestMaliciousArchiveExtraction:
+    def test_malicious_tar_with_traversal_fails(self, tmp_path):
+        tar_path = tmp_path / "malicious.tar.gz"
+        with tarfile.open(str(tar_path), "w:gz") as tf:
+            data = b"malicious content"
+            member = tarfile.TarInfo(name="../outside.txt")
+            member.size = len(data)
+            tf.addfile(member, io.BytesIO(data))
+
+        with pytest.raises(ValueError, match="Unsafe path"):
+            unpack_and_verify(str(tar_path), "domainforge")
+
+    def test_malicious_tar_with_symlink_fails(self, tmp_path):
+        tar_path = tmp_path / "symlink.tar.gz"
+        with tarfile.open(str(tar_path), "w:gz") as tf:
+            member = tarfile.TarInfo(name="evil_link")
+            member.type = tarfile.SYMTYPE
+            member.linkname = "/etc/passwd"
+            tf.addfile(member)
+
+        with pytest.raises(ValueError, match="Symlink"):
+            unpack_and_verify(str(tar_path), "domainforge")
+
+    def test_malicious_tar_with_absolute_path_fails(self, tmp_path):
+        tar_path = tmp_path / "absolute.tar.gz"
+        with tarfile.open(str(tar_path), "w:gz") as tf:
+            data = b"absolute path content"
+            member = tarfile.TarInfo(name="/tmp/evil.txt")
+            member.size = len(data)
+            tf.addfile(member, io.BytesIO(data))
+
+        with pytest.raises(ValueError, match="Unsafe path"):
+            unpack_and_verify(str(tar_path), "domainforge")
+
+    def test_malicious_zip_with_traversal_fails(self, tmp_path):
+        zip_path = tmp_path / "malicious.zip"
+        with zipfile.ZipFile(str(zip_path), "w") as zf:
+            zf.writestr("../outside.txt", "malicious content")
+
+        with pytest.raises(ValueError, match="Unsafe path"):
+            unpack_and_verify(str(zip_path), "domainforge")
+
+    def test_safe_tar_extracts_successfully(self, tmp_path):
+        tar_path = tmp_path / "safe.tar.gz"
+        with tarfile.open(str(tar_path), "w:gz") as tf:
+            data = b"#!/bin/sh\necho v1.0.0"
+            member = tarfile.TarInfo(name="domainforge")
+            member.size = len(data)
+            member.mode = 0o755
+            tf.addfile(member, io.BytesIO(data))
+
+        with patch_verify_cli(tmp_path):
+            result = unpack_and_verify(str(tar_path), "domainforge")
+            assert result == 0
+
+
+def patch_verify_cli(tmp_path):
+    import unittest.mock
+
+    return unittest.mock.patch(
+        "scripts.ci_tasks.verify_cli_binary", return_value=0
+    )