#!/usr/bin/env python3 """Canina cross-department orchestration worker. A model response is analysis, not delivery. The worker records the exact prompt and response, creates deterministic cross-department child tasks, and keeps the parent open until dependencies and acceptance evidence are satisfied. """ from __future__ import annotations import hashlib import json import os import re import subprocess import uuid from dataclasses import dataclass from datetime import datetime, timezone from pathlib import Path from typing import Any import requests MAX_FANOUT_DEPTH = 2 VALID_DEPARTMENTS = { "PMO", "DEV", "DEVOPS", "SEO", "CONTENT", "CLINICAL_RD", "B2B", "SUPPORT" } def utc_now() -> str: return datetime.now(timezone.utc).isoformat() def parse_structured_response(text: str) -> dict[str, Any]: cleaned = text.strip() fenced = re.search(r"```(?:json)?\s*(\{.*\})\s*```", cleaned, re.DOTALL) if fenced: cleaned = fenced.group(1) else: start, end = cleaned.find("{"), cleaned.rfind("}") if start >= 0 and end > start: cleaned = cleaned[start : end + 1] parsed = json.loads(cleaned, strict=False) if not isinstance(parsed, dict): raise ValueError("Model response must be a JSON object") parsed.setdefault("summary", "") parsed.setdefault("child_tasks", []) parsed.setdefault("deliverable", {}) return parsed def _child_code(parent_code: str, department: str, title: str) -> str: digest = hashlib.sha256(f"{parent_code}|{department}|{title}".encode()).hexdigest()[:8].upper() return f"{parent_code}-{department[:4]}-{digest}"[:50] def build_child_tasks(parent_code: str, proposal: dict[str, Any], depth: int) -> list[dict[str, Any]]: if depth >= MAX_FANOUT_DEPTH: return [] children: list[dict[str, Any]] = [] for raw in proposal.get("child_tasks") or []: if not isinstance(raw, dict): continue department = str(raw.get("department") or "").upper().strip() title = str(raw.get("title") or "").strip() if department not in VALID_DEPARTMENTS or not title: continue criteria = raw.get("acceptance_criteria") or [] children.append( { "code": _child_code(parent_code, department, title), "department": department, "title": title[:255], "description": str(raw.get("description") or title), "priority": str(raw.get("priority") or "HIGH").upper(), "assignee": f"Canina-{department}-Agent", "acceptanceCriteria": { "parentTaskCode": parent_code, "depth": depth + 1, "criteria": criteria if isinstance(criteria, list) else [str(criteria)], "requiredDeliverableType": raw.get("deliverable_type"), }, } ) return children def determine_parent_status(*, has_children: bool, deliverable_url: str | None, verified: bool) -> str: if has_children: return "WAITING_DEPENDENCIES" # A model URL and its self-assessed verification cannot satisfy independent QA. return "TEST" @dataclass(frozen=True) class QAResult: passed: bool reason: str def verify_artifact(deliverable: dict[str, Any], verification: dict[str, Any]) -> QAResult: """Offline gate: claimed URLs and model assertions are not artifact evidence.""" return QAResult(False, "Independent artifact QA and approval required") def _literal(value: Any) -> str: return "'" + str(value).replace("'", "''") + "'" def claim_sql(token: str) -> str: """Select and lease one root or child in a single locked statement.""" event = json.dumps({"status": "CLAIMED", "claim_token": token}) return f""" WITH candidate AS ( SELECT id FROM department_tasks WHERE status = 'TODO' OR ( status = 'IN_PROGRESS' AND execution_logs->-1->>'status' = 'CLAIMED' AND updated_at < NOW() - INTERVAL '15 minutes' ) ORDER BY CASE priority WHEN 'CEO_EXPEDITE' THEN 0 WHEN 'CRITICAL' THEN 1 WHEN 'HIGH' THEN 2 WHEN 'MEDIUM' THEN 3 ELSE 4 END, updated_at ASC, id ASC FOR UPDATE SKIP LOCKED LIMIT 1 ), claimed AS ( UPDATE department_tasks t SET status = 'IN_PROGRESS', updated_at = NOW(), execution_logs = COALESCE(t.execution_logs, '[]'::jsonb) || {_literal(event)}::jsonb FROM candidate WHERE t.id = candidate.id RETURNING t.id, t.code, t.department, t.title, t.description, t.acceptance_criteria, t.execution_logs, t.assignee, t.priority ) SELECT COALESCE(json_agg(claimed), '[]'::json)::text FROM claimed; """ def complete_sql(task_id: str, token: str, status: str, event: dict[str, Any], children: list[dict[str, Any]] | None = None) -> str: """Fenced transition and idempotent child insert in one atomic SQL statement.""" if status not in ('TODO', 'TEST', 'WAITING_DEPENDENCIES', 'REJECTED'): raise ValueError('Invalid worker transition') entries = [] for child in children or []: entries.append('(' + ', '.join(_literal(x) for x in ( child['code'], child['department'], child['title'], child['description'], child['priority'], child['assignee'], json.dumps(child['acceptanceCriteria'], ensure_ascii=False) )) + ')') insert = '' if entries: insert = f""", inserted AS ( INSERT INTO department_tasks (id, code, department, title, description, status, priority, assignee, acceptance_criteria, execution_logs, created_at, updated_at) SELECT gen_random_uuid(), v.code, v.department, v.title, v.description, 'TODO', v.priority, v.assignee, v.criteria::jsonb, '[]'::jsonb, NOW(), NOW() FROM (VALUES {', '.join(entries)}) AS v(code, department, title, description, priority, assignee, criteria) WHERE EXISTS (SELECT 1 FROM completed) ON CONFLICT (code) DO NOTHING RETURNING id )""" return f""" WITH completed AS ( UPDATE department_tasks SET status = {_literal(status)}, updated_at = NOW(), execution_logs = COALESCE(execution_logs, '[]'::jsonb) || {_literal(json.dumps(event, ensure_ascii=False))}::jsonb WHERE id = {_literal(task_id)}::uuid AND status = 'IN_PROGRESS' AND updated_at >= NOW() - INTERVAL '15 minutes' AND execution_logs->-1->>'claim_token' = {_literal(token)} RETURNING id ){insert} SELECT id FROM completed; """ class Database: def __init__(self) -> None: self.ssh = ["ssh", "-F", "/opt/data/.ssh/config", "parsa-host"] self.psql = [ "docker", "exec", "-i", "canino_db_prod", "psql", "-U", "canino_prod", "-d", "caninodb_prod", "-t", "-A", ] def sql(self, statement: str) -> str: if os.environ.get('CANINA_ORCHESTRATION_LIVE_WRITE') != 'I_ACCEPT_LIVE_MUTATION': raise RuntimeError('Live database writes disabled; use injected mock database for dry runs') result = subprocess.run( self.ssh + self.psql, input=statement, text=True, capture_output=True, timeout=45, check=True, ) return result.stdout.strip() def rows_json(self, query: str) -> list[dict[str, Any]]: wrapped = f"SELECT COALESCE(json_agg(q), '[]'::json)::text FROM ({query}) q;" raw = self.sql(wrapped) return json.loads(raw or "[]") def claim_next(self) -> dict[str, Any] | None: token = str(uuid.uuid4()) rows = json.loads(self.sql(claim_sql(token)) or '[]') if not rows: return None return {**rows[0], 'claim_token': token} def finish_claim(self, task: dict[str, Any], event: dict[str, Any], status: str, children: list[dict[str, Any]] | None = None) -> bool: return bool(self.sql(complete_sql(task['id'], task['claim_token'], status, event, children))) class ModelClient: def __init__(self) -> None: config_path = Path(os.environ.get("HERMES_CONFIG", "/opt/data/config.yaml")) text = config_path.read_text(encoding="utf-8") match = re.search(r"name: 9router (?:Combo|Antigravity).*?api_key:\s*([^\s]+)", text, re.DOTALL) if not match: raise RuntimeError("9router API key not configured") self.api_key = match.group(1).strip() def complete(self, prompt: str) -> str: response = requests.post( "https://nr.parsaaghayi.ir/v1/chat/completions", headers={"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}, json={ "model": "Canina-content", "messages": [ {"role": "system", "content": "You are Canina's cross-department PMO. Return strict JSON only."}, {"role": "user", "content": prompt}, ], "temperature": 0.1, "stream": False, }, timeout=180, ) response.raise_for_status() try: return response.json()["choices"][0]["message"]["content"] except Exception: chunks: list[str] = [] for line in response.text.splitlines(): if not line.startswith("data: ") or line.endswith("[DONE]"): continue try: chunks.append(json.loads(line[6:])["choices"][0]["delta"].get("content", "")) except Exception: pass return "".join(chunks) def decomposition_prompt(task: dict[str, Any]) -> str: logs = task.get("execution_logs") or [] raw_output = logs[-1].get("model_response", "") if logs else "" depth = int((task.get("acceptance_criteria") or {}).get("depth", 0)) return f""" ماموریت {task['code']} در دپارتمان {task['department']} فقط یک تحلیل متنی تولید کرده و هنوز تحویل اجرایی تاییدشده ندارد. عنوان: {task['title']} خروجی خام واقعی مدل: {raw_output} این خروجی را به یک برنامه اجرایی میان‌دپارتمانی تبدیل کن. پاسخ فقط JSON معتبر با این ساختار باشد: {{ "summary": "نتیجه واقعی مرحله تحلیل، بدون ادعای انتشار یا استقرار", "deliverable": {{"type": "analysis", "url": null, "verified": false}}, "child_tasks": [ {{ "department": "یکی از SEO,CONTENT,CLINICAL_RD,B2B,DEV,DEVOPS,SUPPORT,PMO", "title": "اقدام مستقل و قابل تحویل", "description": "شرح دقیق اجرا", "priority": "HIGH", "deliverable_type": "نوع خروجی قابل راستی‌آزمایی", "acceptance_criteria": ["معیار عینی اول", "معیار عینی دوم"] }} ] }} قواعد: حداکثر ۶ child task؛ تکراری نساز؛ کار صرفاً تحلیلی را DONE ننام؛ انتشار، تماس، پیامک، تغییر کد یا پروداکشن را انجام‌شده فرض نکن؛ عمق فعلی {depth} است. """.strip() def execution_prompt(task: dict[str, Any]) -> str: criteria = task.get("acceptance_criteria") or {} return f""" شما ایجنت اجرایی دپارتمان {task['department']} کنینا هستید. کد: {task['code']} عنوان: {task['title']} شرح: {task.get('description') or ''} معیار پذیرش: {json.dumps(criteria, ensure_ascii=False)} این مرحله را واقعاً تا حدی که بدون دسترسی به ابزار خارجی ممکن است انجام بده. پاسخ فقط JSON معتبر: {{ "summary": "آنچه واقعاً تولید یا بررسی شد", "deliverable": {{ "type": "draft|research|code_plan|contact_plan|clinical_review|seo_plan", "content": "خروجی کامل و قابل استفاده، نه خلاصه نمایشی", "url": null, "verified": false }}, "verification": {{"passed": false, "evidence": []}}, "child_tasks": [] }} هیچ انتشار، تماس، دپلوی، تغییر سایت یا تایید بالینی را انجام‌شده فرض نکن. اگر نیازمند ابزار/دپارتمان دیگری است، child_tasks ساختاریافته بساز. """.strip() def execute_next_task(db: Database, model: ModelClient) -> bool: """Produce reviewable drafts; never publish or trust model QA assertions.""" task = db.claim_next() if not task: return False prompt = execution_prompt(task) try: raw = model.complete(prompt) result = parse_structured_response(raw) criteria = task.get('acceptance_criteria') or {} children = build_child_tasks(task['code'], result, int(criteria.get('depth', 0))) deliverable = result.get('deliverable') or {} qa = verify_artifact(deliverable, result.get('verification') or {}) status = determine_parent_status(has_children=bool(children), deliverable_url=deliverable.get('url'), verified=qa.passed) event = {'timestamp': utc_now(), 'status': 'QA_PENDING', 'prompt_to_model': prompt, 'model_response': raw, 'deliverable': deliverable, 'qa': qa.reason, 'childrenProposed': len(children)} if not db.finish_claim(task, event, status, children): raise RuntimeError('Claim lost before completion; no result committed') except Exception as exc: db.finish_claim(task, {'timestamp': utc_now(), 'status': 'AGENT_EXECUTION_FAILED', 'error': str(exc)}, 'TODO') raise return True execute_next_child = execute_next_task def reconcile_parent_states(db: Database) -> bool: parents = db.rows_json( """ SELECT id, code, status FROM department_tasks p WHERE status = 'WAITING_DEPENDENCIES' AND EXISTS (SELECT 1 FROM department_tasks c WHERE c.acceptance_criteria->>'parentTaskCode' = p.code) AND NOT EXISTS ( SELECT 1 FROM department_tasks c WHERE c.acceptance_criteria->>'parentTaskCode' = p.code AND c.status NOT IN ('DONE') ) ORDER BY created_at ASC LIMIT 1 """ ) if not parents: return False # Dependency completion alone cannot pass parent QA. Leave it blocked pending # independently persisted attestations; no synthetic URL or DONE transition. return False def reconcile_pseudo_done(db: Database, model: ModelClient) -> bool: # Legacy DONE records require a separate human audit, not autonomous rewrites. return False def main() -> None: db = Database() model = ModelClient() if execute_next_task(db, model): print("Executed one child task; unverified model output remains in TEST, never DONE.") return # Parent reconciliation requires independent persisted QA attestations. print("No actionable orchestration task found.") if __name__ == "__main__": main()