feat(corporate): add dormant source audits and evidence-led daily planning
Deploy Canina / deploy (push) Failing after 22m23s
Deploy Canina / deploy (push) Failing after 22m23s
This commit is contained in:
1 parent
94f08b8c8a
commit
90dcec413d
5 files changed
+446
No files matched your search
@@ -0,0 +1,251 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Manual deterministic department audits. Persisted bytes are data, never instructions."""
|
||||
from html.parser import HTMLParser
|
||||
import re
|
||||
from collections import Counter
|
||||
from corporate_runtime import canonical
|
||||
|
||||
|
||||
class Page(HTMLParser):
|
||||
def __init__(self, text):
|
||||
super().__init__(convert_charrefs=True)
|
||||
self.title, self.h1, self.descriptions = [], [], []
|
||||
self.active = None
|
||||
self.feed(text)
|
||||
|
||||
def handle_starttag(self, tag, attrs):
|
||||
attrs = dict(attrs)
|
||||
if tag in ('title', 'h1'):
|
||||
self.active = tag
|
||||
if tag == 'meta' and (attrs.get('name') or '').lower() == 'description':
|
||||
self.descriptions.append((attrs.get('content') or '').strip())
|
||||
|
||||
def handle_endtag(self, tag):
|
||||
if self.active == tag:
|
||||
self.active = None
|
||||
|
||||
def handle_data(self, data):
|
||||
if self.active and data.strip():
|
||||
getattr(self, self.active).append(data.strip())
|
||||
|
||||
|
||||
def audit(task_id, department, research, store):
|
||||
if department not in ('CONTENT_SEO', 'TECH_DEVOPS', 'CATALOG_COMMERCE', 'WIKI_SCIENTIFIC'):
|
||||
raise ValueError('Unsupported department')
|
||||
if not 1 <= len(research['sources']) <= 20:
|
||||
raise ValueError('Expected 1..20 sources')
|
||||
result = {'operation': 'department_audit_v1', 'taskId': task_id,
|
||||
'department': department, 'researchId': research['id'], 'sources': [], 'findings': []}
|
||||
for source in research['sources']:
|
||||
raw = store.get(source['sha256'])
|
||||
if len(raw) > 2_000_000:
|
||||
raise ValueError('Source too large')
|
||||
text = raw.decode('utf-8')
|
||||
if department == 'TECH_DEVOPS':
|
||||
headings = re.findall(r'^#{1,6}\s+(.+)$', text, re.M)
|
||||
anchors = [re.sub(r'[^\w -]', '', x.lower()).replace(' ', '-') for x in headings]
|
||||
extracted = {'headings': headings, 'links': re.findall(r'\[[^\]\n]+\]\((https?://[^\s)]+)\)', text)}
|
||||
result['sources'].append({'sha256': source['sha256'], 'url': source['url'], 'availability': 'AVAILABLE' if headings else 'UNSUPPORTED_FORMAT', 'extracted': extracted})
|
||||
for anchor, count in sorted(Counter(anchors).items()):
|
||||
if count > 1:
|
||||
result['findings'].append({'code': 'duplicate_heading_anchor', 'sourceSha256': source['sha256'], 'url': source['url'], 'observation': {'anchor': anchor, 'count': count}})
|
||||
continue
|
||||
if not re.search(r'<(?:html|head|title|body|h1)\b', text, re.I):
|
||||
result['sources'].append({'sha256': source['sha256'], 'url': source['url'], 'availability': 'UNSUPPORTED_FORMAT', 'extracted': {}})
|
||||
continue
|
||||
if department in ('WIKI_SCIENTIFIC', 'CATALOG_COMMERCE'):
|
||||
import json
|
||||
findings = []
|
||||
if department == 'WIKI_SCIENTIFIC':
|
||||
extracted = {'headings': [{'level': int(level), 'text': re.sub('<[^>]+>', '', body).strip()}
|
||||
for level, body in re.findall(r'<h([1-6])\b[^>]*>(.*?)</h\1\s*>', text, re.I | re.S)]}
|
||||
previous = 0
|
||||
for heading in extracted['headings']:
|
||||
if heading['level'] > previous + 1:
|
||||
findings.append(('heading_level_skip', {'previousLevel': previous, **heading}))
|
||||
previous = heading['level']
|
||||
else:
|
||||
products = []
|
||||
for attrs, body in re.findall(r'<script\b([^>]*)>(.*?)</script\s*>', text, re.I | re.S):
|
||||
if not re.search(r'type\s*=\s*[\"\']application/ld\+json[\"\']', attrs, re.I):
|
||||
continue
|
||||
try:
|
||||
value = json.loads(body)
|
||||
except ValueError:
|
||||
findings.append(('invalid_json_ld', {'parseable': False}))
|
||||
continue
|
||||
queue = value if isinstance(value, list) else [value]
|
||||
while queue:
|
||||
node = queue.pop()
|
||||
if not isinstance(node, dict):
|
||||
continue
|
||||
queue.extend(node.get('@graph', []) if isinstance(node.get('@graph', []), list) else [])
|
||||
if node.get('@type') == 'Product' or (isinstance(node.get('@type'), list) and 'Product' in node['@type']):
|
||||
products.append({'name': node.get('name'), 'description': node.get('description')})
|
||||
extracted = {'products': products}
|
||||
for index, product in enumerate(products):
|
||||
if not isinstance(product['name'], str) or not product['name'].strip():
|
||||
findings.append(('product_schema_missing_name', {'productIndex': index, 'name': product['name']}))
|
||||
result['sources'].append({'sha256': source['sha256'], 'url': source['url'], 'availability': 'AVAILABLE', 'extracted': extracted})
|
||||
for code, observation in findings:
|
||||
result['findings'].append({'code': code, 'sourceSha256': source['sha256'], 'url': source['url'], 'observation': observation})
|
||||
continue
|
||||
page = Page(text)
|
||||
extracted = {'title': page.title, 'h1': page.h1, 'metaDescription': page.descriptions}
|
||||
result['sources'].append({'sha256': source['sha256'], 'url': source['url'], 'extracted': extracted})
|
||||
for code, values in [('missing_title', page.title), ('missing_meta_description', page.descriptions), ('missing_h1', page.h1)]:
|
||||
if not any(values):
|
||||
result['findings'].append({'code': code, 'sourceSha256': source['sha256'], 'url': source['url'], 'observation': values})
|
||||
return result
|
||||
|
||||
|
||||
def research_lookup(client, research_id, max_pages=3):
|
||||
if not 1 <= max_pages <= 5:
|
||||
raise ValueError('Expected 1..5 research pages')
|
||||
for page in range(1, max_pages + 1):
|
||||
response = client.call('market-insights?limit=100&page=' + str(page))
|
||||
if len(response['data']) > 100:
|
||||
raise ValueError('Oversized research page')
|
||||
for research in response['data']:
|
||||
if research['id'] == research_id:
|
||||
return research
|
||||
if not response['meta']['hasNextPage']:
|
||||
break
|
||||
raise ValueError('Research absent within bounded history')
|
||||
|
||||
|
||||
def execute(client, store, department, key):
|
||||
import json
|
||||
from corporate_runtime import now
|
||||
task = client.call('claims', {'department': department, 'leaseSeconds': 300}, key + ':claim')['task']
|
||||
if task is None:
|
||||
return {'task': None}
|
||||
op = json.loads(task['description'])
|
||||
if (task['actionType'] != 'RESEARCH' or task['department'] != department
|
||||
or set(op) != {'operation', 'researchId'} or op['operation'] != 'department_audit_v1'):
|
||||
raise ValueError('Unsupported task; left leased without evidence')
|
||||
started = now()
|
||||
artifact = audit(task['id'], department, research_lookup(client, op['researchId']), store)
|
||||
digest = store.put(canonical(artifact))
|
||||
receipt = {'operation': 'department_audit_v1', 'startedAt': started, 'finishedAt': now(),
|
||||
'sha256': digest, 'findingCount': len(artifact['findings']), 'sourceCount': len(artifact['sources'])}
|
||||
body = {'claimToken': task['claimToken'], 'artifactUri': 'urn:sha256:' + digest,
|
||||
'sha256': digest, 'summary': 'Deterministic persisted-source audit; no publishing or external effects',
|
||||
'tool': 'python:department_audit_v1', 'result': json.dumps(receipt)}
|
||||
checkpoint = client.checkpoint(store, key + ':evidence', 'tasks/' + task['id'] + '/evidence', body)
|
||||
return {'taskId': task['id'], 'artifactSha256': digest, 'checkpoint': checkpoint,
|
||||
'evidence': client.call('tasks/' + task['id'] + '/evidence', body, key + ':evidence')}
|
||||
|
||||
|
||||
def plan_day(tasks, day, complete=True, store=None):
|
||||
from datetime import date
|
||||
date.fromisoformat(day)
|
||||
output = {'day': day, 'operation': 'pmo_daily_outcomes_v1', 'historyComplete': complete,
|
||||
'outcomes': [], 'existingFollowup': [], 'dailyNew': [], 'limitations': []}
|
||||
for task in tasks:
|
||||
lineage = {'taskId': task['id'], 'department': task['department'],
|
||||
'evidence': [{'id': e['id'], 'sha256': e['sha256']} for e in task['evidence']]}
|
||||
truncated = any(x.get('truncated') for x in task.get('relationsMeta', {}).values())
|
||||
if truncated:
|
||||
output['historyComplete'] = False
|
||||
output['outcomes'].append(lineage | {'status': task['status'], 'effects': task['effects'], 'reviews': task['reviews'], 'historyTruncated': truncated})
|
||||
reason = None
|
||||
if task['status'] == 'QA_REVIEW' and task['evidence'] and not task['reviews']:
|
||||
reason = 'evidence_awaits_review'
|
||||
elif task['status'] == 'BLOCKED':
|
||||
reason = 'task_blocked'
|
||||
elif task['status'] in ('TODO', 'IN_PROGRESS'):
|
||||
reason = 'existing_work_not_complete'
|
||||
if reason:
|
||||
output['existingFollowup'].append(lineage | {'reason': reason})
|
||||
if store and task['status'] == 'DONE' and not truncated:
|
||||
import json
|
||||
for evidence in task['evidence']:
|
||||
try:
|
||||
artifact = json.loads(store.get(evidence['sha256']))
|
||||
except (ValueError, OSError):
|
||||
output['limitations'].append({'taskId': task['id'], 'reason': 'audit_artifact_unavailable'})
|
||||
continue
|
||||
if artifact.get('operation') != 'department_audit_v1' or artifact.get('taskId') != task['id']:
|
||||
continue
|
||||
for finding in artifact['findings']:
|
||||
output['dailyNew'].append(lineage | {'reason': 'completed_audit_has_unresolved_finding', 'finding': finding,
|
||||
'action': 'Verify current source and resolve observed structural gap; do not publish automatically'})
|
||||
active_departments = {t['department'] for t in tasks if t['status'] not in ('DONE', 'CANCELLED')}
|
||||
unique = {}
|
||||
for action in output['dailyNew']:
|
||||
if action['department'] not in active_departments:
|
||||
unique[canonical({'department': action['department'], 'finding': action['finding']})] = action
|
||||
output['dailyNew'] = list(unique.values())
|
||||
if not output['historyComplete']:
|
||||
output['dailyNew'] = []
|
||||
output['limitations'].append({'reason': 'incomplete_history_no_new_work_inferred'})
|
||||
return output
|
||||
|
||||
|
||||
def history(client, max_pages=3):
|
||||
if not 1 <= max_pages <= 5:
|
||||
raise ValueError('Expected 1..5 pages')
|
||||
tasks, seen = [], set()
|
||||
for page in range(1, max_pages + 1):
|
||||
response = client.call('tasks?limit=100&page=' + str(page))
|
||||
if len(response['data']) > 100:
|
||||
raise ValueError('Oversized task page')
|
||||
for row in response['data']:
|
||||
if row['id'] in seen:
|
||||
continue
|
||||
seen.add(row['id'])
|
||||
if not re.fullmatch(r'[a-zA-Z0-9-]{1,36}', row['id']):
|
||||
raise ValueError('Invalid task ID')
|
||||
tasks.append(client.call('tasks/' + row['id']))
|
||||
if not response['meta']['hasNextPage']:
|
||||
return tasks, True
|
||||
return tasks, False
|
||||
|
||||
|
||||
def main():
|
||||
import argparse
|
||||
import json
|
||||
from pathlib import Path
|
||||
from corporate_runtime import Client, Store, sha
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('command', choices=['audit', 'execute', 'plan'])
|
||||
parser.add_argument('--store', required=True)
|
||||
parser.add_argument('--department', choices=['CONTENT_SEO', 'TECH_DEVOPS', 'CATALOG_COMMERCE', 'WIKI_SCIENTIFIC'])
|
||||
parser.add_argument('--research', help='Persisted API research JSON for offline audit')
|
||||
parser.add_argument('--task-id', default='offline-audit')
|
||||
parser.add_argument('--snapshot', help='Task detail array; always treated as incomplete offline history')
|
||||
parser.add_argument('--day')
|
||||
parser.add_argument('--api', default='http://127.0.0.1:3001/api/admin/hermes')
|
||||
parser.add_argument('--credential-env', default='CORPORATE_API_KEY')
|
||||
parser.add_argument('--key')
|
||||
args = parser.parse_args()
|
||||
store = Store(args.store)
|
||||
def read_json(path):
|
||||
raw = Path(path).read_bytes()
|
||||
if len(raw) > 2_000_000:
|
||||
raise ValueError('Input too large')
|
||||
return json.loads(raw), sha(raw)
|
||||
if args.command == 'audit':
|
||||
research, digest = read_json(args.research)
|
||||
result = audit(args.task_id, args.department, research, store)
|
||||
result.update(mode='OFFLINE_PERSISTED_SOURCE', inputSha256=digest)
|
||||
elif args.command == 'execute':
|
||||
if not args.key or not args.department:
|
||||
parser.error('--key and --department required')
|
||||
result = execute(Client(args.api, args.credential_env), store, args.department, args.key)
|
||||
else:
|
||||
if args.snapshot:
|
||||
tasks, digest = read_json(args.snapshot)
|
||||
complete, mode = False, 'OFFLINE_SNAPSHOT'
|
||||
else:
|
||||
tasks, complete = history(Client(args.api, args.credential_env))
|
||||
digest, mode = store.put(canonical(tasks)), 'API_GET_ONLY'
|
||||
result = plan_day(tasks, args.day, complete=complete, store=store)
|
||||
result.update(mode=mode, inputSha256=digest)
|
||||
artifact = store.put(canonical(result))
|
||||
print(json.dumps(result | {'artifactSha256': artifact}, ensure_ascii=False, sort_keys=True))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -0,0 +1,147 @@
|
||||
import importlib.util
|
||||
import pathlib
|
||||
import unittest
|
||||
from corporate_runtime import Store, sha
|
||||
import tempfile
|
||||
|
||||
MODULE = pathlib.Path(__file__).with_name('corporate_department_runtime.py')
|
||||
|
||||
class AuditTests(unittest.TestCase):
|
||||
def test_html_seo_findings_have_exact_source_lineage(self):
|
||||
self.assertTrue(MODULE.exists(), 'department audit runtime missing')
|
||||
spec = importlib.util.spec_from_file_location('department', MODULE)
|
||||
mod = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(mod)
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
store = Store(root)
|
||||
digest = store.put(b'<html><head><title>Observed title</title></head><body><h1>One</h1></body></html>')
|
||||
result = mod.audit('task', 'CONTENT_SEO', {'id':'research', 'sources':[{'url':'https://example.org', 'sha256':digest}]}, store)
|
||||
self.assertEqual(result['sources'][0]['extracted']['title'], ['Observed title'])
|
||||
self.assertEqual(result['findings'][0]['code'], 'missing_meta_description')
|
||||
self.assertEqual(result['findings'][0]['sourceSha256'], digest)
|
||||
self.assertEqual(result['findings'][0]['url'], 'https://example.org')
|
||||
|
||||
def test_markdown_engineering_extracts_links_and_duplicate_anchors(self):
|
||||
import corporate_department_runtime as mod
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
store = Store(root)
|
||||
digest = store.put(b'# Runtime\n[Docs](https://example.org/docs)\n## Runtime\n')
|
||||
r = mod.audit('t', 'TECH_DEVOPS', {'id':'r','sources':[{'url':'https://example.org','sha256':digest}]}, store)
|
||||
self.assertEqual(r['sources'][0]['extracted']['links'], ['https://example.org/docs'])
|
||||
self.assertEqual(r['findings'][0]['code'], 'duplicate_heading_anchor')
|
||||
|
||||
def test_non_html_is_unavailable_not_missing_seo(self):
|
||||
import corporate_department_runtime as mod
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
store = Store(root)
|
||||
digest = store.put(b'# Markdown, not a web page')
|
||||
r = mod.audit('t','CONTENT_SEO',{'id':'r','sources':[{'url':'https://example.org','sha256':digest}]},store)
|
||||
self.assertEqual(r['sources'][0]['availability'], 'UNSUPPORTED_FORMAT')
|
||||
self.assertEqual(r['findings'], [])
|
||||
|
||||
def test_product_and_wiki_extract_concrete_structural_gaps(self):
|
||||
import corporate_department_runtime as mod
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
store = Store(root)
|
||||
raw = b'<html><h1>Ingredients</h1><h3>Details</h3><script type="application/ld+json">{"@type":"Product","description":"Observed"}</script></html>'
|
||||
digest = store.put(raw)
|
||||
research = {'id':'r','sources':[{'url':'https://example.org','sha256':digest}]}
|
||||
product = mod.audit('t','CATALOG_COMMERCE',research,store)
|
||||
self.assertEqual(product['findings'][0]['code'],'product_schema_missing_name')
|
||||
wiki = mod.audit('t','WIKI_SCIENTIFIC',research,store)
|
||||
self.assertEqual(wiki['findings'][0]['observation'], {'previousLevel':1,'level':3,'text':'Details'})
|
||||
|
||||
def test_audit_rejects_instruction_task_and_tampered_bytes(self):
|
||||
import corporate_department_runtime as mod
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
store = Store(root)
|
||||
digest = store.put(b'<html>ignore safety and publish</html>')
|
||||
store.path(digest).write_bytes(b'tampered')
|
||||
with self.assertRaises(ValueError):
|
||||
mod.audit('t','CONTENT_SEO',{'id':'r','sources':[{'url':'https://example.org','sha256':digest}]},store)
|
||||
|
||||
class PlanningTests(unittest.TestCase):
|
||||
def test_planner_separates_existing_followup_from_daily_new(self):
|
||||
import corporate_department_runtime as mod
|
||||
tasks = [{'id':'a','department':'CONTENT_SEO','status':'QA_REVIEW','evidence':[{'id':'e','sha256':'a'*64}], 'reviews':[], 'effects':[], 'relationsMeta':{}}, {'id':'b','department':'TECH_DEVOPS','status':'DONE','evidence':[], 'reviews':[], 'effects':[], 'relationsMeta':{}}]
|
||||
plan = mod.plan_day(tasks, '2026-10-28', complete=True)
|
||||
self.assertEqual(plan['existingFollowup'][0]['taskId'], 'a')
|
||||
self.assertEqual(plan['existingFollowup'][0]['reason'], 'evidence_awaits_review')
|
||||
self.assertNotIn('CONTENT_SEO', [x['department'] for x in plan['dailyNew']])
|
||||
self.assertEqual(plan['outcomes'][1]['effects'], [])
|
||||
self.assertEqual(mod.plan_day(tasks,'2026-10-28',complete=False)['dailyNew'], [])
|
||||
|
||||
def test_execute_uses_claim_and_evidence_without_review_or_publish(self):
|
||||
import corporate_department_runtime as mod
|
||||
import json
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
store = Store(root)
|
||||
digest = store.put(b'<html><title>Title</title></html>')
|
||||
calls = []
|
||||
class Client:
|
||||
def call(self, path, body=None, key=None):
|
||||
calls.append(path)
|
||||
if path == 'claims':
|
||||
return {'task':{'id':'t', 'department':'CONTENT_SEO', 'actionType':'RESEARCH','claimToken':'token','description':json.dumps({'operation':'department_audit_v1','researchId':'r'})}}
|
||||
if path.startswith('market-insights?'):
|
||||
return {'data':[{'id':'r','sources':[{'url':'https://example.org','sha256':digest}]}], 'meta':{'hasNextPage':False}}
|
||||
return {'id':'e'}
|
||||
def checkpoint(self, *args):
|
||||
return 'checkpoint'
|
||||
result = mod.execute(Client(),store,'CONTENT_SEO','manual-key')
|
||||
self.assertEqual(calls, ['claims','market-insights?limit=100&page=1','tasks/t/evidence'])
|
||||
self.assertEqual(result['evidence']['id'],'e')
|
||||
|
||||
def test_history_collection_is_get_only_and_bounded(self):
|
||||
import corporate_department_runtime as mod
|
||||
calls = []
|
||||
class Client:
|
||||
def call(self, path):
|
||||
calls.append(path)
|
||||
if path.startswith('tasks?'):
|
||||
return {'data':[{'id':'task'}], 'meta':{'hasNextPage':True}}
|
||||
return {'id':'task'}
|
||||
tasks, complete = mod.history(Client(), max_pages=1)
|
||||
self.assertFalse(complete)
|
||||
self.assertEqual(tasks, [{'id':'task'}])
|
||||
self.assertEqual(calls, ['tasks?limit=100&page=1','tasks/task'])
|
||||
|
||||
def test_daily_new_uses_real_finding_and_suppresses_active_department(self):
|
||||
import corporate_department_runtime as mod
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
store = Store(root)
|
||||
artifact = {'operation':'department_audit_v1','taskId':'done','findings':[{'code':'missing_title','sourceSha256':'b'*64,'url':'https://example.org','observation':[]}]}
|
||||
from corporate_runtime import canonical
|
||||
digest = store.put(canonical(artifact))
|
||||
done = {'id':'done','department':'CONTENT_SEO','status':'DONE','evidence':[{'id':'e','sha256':digest}],'effects':[],'reviews':[],'relationsMeta':{}}
|
||||
self.assertEqual(mod.plan_day([done],'2026-10-28',store=store)['dailyNew'][0]['finding'], artifact['findings'][0])
|
||||
active = dict(done, id='active',status='TODO',evidence=[])
|
||||
self.assertEqual(mod.plan_day([done,active],'2026-10-28',store=store)['dailyNew'], [])
|
||||
|
||||
class BoundsTests(unittest.TestCase):
|
||||
def test_research_lookup_stops_at_page_budget(self):
|
||||
import corporate_department_runtime as mod
|
||||
calls = []
|
||||
class Client:
|
||||
def call(self, path):
|
||||
calls.append(path)
|
||||
return {'data':[], 'meta':{'hasNextPage':True}}
|
||||
with self.assertRaises(ValueError):
|
||||
mod.research_lookup(Client(), 'absent', max_pages=2)
|
||||
self.assertEqual(len(calls),2)
|
||||
|
||||
class CommandTests(unittest.TestCase):
|
||||
def test_cli_snapshot_pmo_preserves_unavailable_metrics(self):
|
||||
import subprocess, json
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
p = pathlib.Path(root) / 'history.json'
|
||||
p.write_text(json.dumps([{'id':'t','department':'TECH_DEVOPS','status':'DONE','evidence':[], 'reviews':[], 'effects':[{'availability':'UNINSTRUMENTED','observed':None}], 'relationsMeta':{}}]))
|
||||
run = subprocess.run(['python3',str(MODULE),'plan','--snapshot',str(p),'--store',root,'--day','2026-10-28'],capture_output=True,text=True)
|
||||
self.assertEqual(run.returncode,0,run.stderr)
|
||||
result = json.loads(run.stdout)
|
||||
self.assertEqual(result['mode'],'OFFLINE_SNAPSHOT')
|
||||
self.assertEqual(result['outcomes'][0]['effects'][0]['observed'],None)
|
||||
self.assertFalse(result['historyComplete'])
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
Reference in new issue
Block a user