Add persona pool methodology and crisis references

metadata/v3/stage2_pools.py

@@ -0,0 +1,297 @@
+"""Stage 2: DeepSeek V4 Flash writes 8 candidate pools per persona.
+
+Conditioned on the seed card + the persona core from stage 1. Each pool has
+6-9 items deeply specific to this persona. No conversation generation here —
+just pool generation.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import threading
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from persona.pipeline.codex_local_client import (  # noqa: E402
+    CodexLocalError,
+    call_chat,
+    parse_json_strict,
+)
+from persona.pipeline.stage0_seed import (  # noqa: E402
+    CRISIS_AGE_SPAN_BY_NAME,
+    CRISIS_CATEGORY_NAMES,
+)
+
+PIPELINE_ROOT = Path(__file__).parent
+SYSTEM_PROMPT_PATH = PIPELINE_ROOT / "prompts" / "stage2_pools_system.md"
+DEFAULT_OUTPUT_DIR = PIPELINE_ROOT / "output_v2" / "pools"
+
+REQUIRED_POOLS = (
+    "pool_a_crisis_profiles",
+    "pool_b_natural_tendency_sets",
+    "pool_c_symptom_sets",
+    "pool_d_trigger_sets",
+    "pool_e_age_contexts",
+    "pool_f_values_expressions",
+    "pool_g_coping_styles",
+    "pool_h_family_social_configs",
+)
+
+
+def load_system_prompt() -> str:
+    return SYSTEM_PROMPT_PATH.read_text(encoding="utf-8")
+
+
+def _format_age_span_table(current_age: int) -> str:
+    lines = []
+    for name in CRISIS_CATEGORY_NAMES:
+        low, high = CRISIS_AGE_SPAN_BY_NAME[name]
+        ok = "OK" if low <= current_age <= high else "OUT_OF_SPAN"
+        lines.append(f"  {name}: span [{low}, {high}] -> {ok} for age {current_age}")
+    return "\n".join(lines)
+
+
+def build_user_message(seed_card: dict, core: dict) -> str:
+    age = int(seed_card.get("current_age", 0))
+    parts = [
+        "SEED CARD (demographic anchors, fixed):",
+        json.dumps(seed_card, ensure_ascii=False, indent=2),
+        "",
+        "PERSONA CORE (just written by stage 1, do not change):",
+        json.dumps(core, ensure_ascii=False, indent=2),
+        "",
+        "45 CRISIS CATEGORIES with age-span eligibility for current_age = "
+        f"{age}:",
+        _format_age_span_table(age),
+        "",
+        "Write the 8 pools now, 6-9 items each. Strict JSON.",
+        "Pool A must include the seed card's assigned crisis_category as one item;"
+        " other items may be other categories from the list above marked OK for the"
+        " persona's current age.",
+    ]
+    return "\n".join(parts)
+
+
+def validate_pools(pools: dict, seed_card: dict) -> list[str]:
+    issues: list[str] = []
+    for pool_name in REQUIRED_POOLS:
+        items = pools.get(pool_name)
+        if not isinstance(items, list):
+            issues.append(f"{pool_name} missing or not a list")
+            continue
+        if not (6 <= len(items) <= 9):
+            issues.append(f"{pool_name} has {len(items)} items (need 6-9)")
+
+    crisis_pool = pools.get("pool_a_crisis_profiles") or []
+    seed_category = seed_card.get("crisis_category")
+    found = any(
+        isinstance(item, dict) and item.get("category") == seed_category
+        for item in crisis_pool
+    )
+    if not found:
+        issues.append(
+            f"pool_a_crisis_profiles missing seed-card category {seed_category!r}"
+        )
+
+    age = int(seed_card.get("current_age", 0))
+    for index, item in enumerate(crisis_pool):
+        if not isinstance(item, dict):
+            continue
+        cat = item.get("category")
+        span = CRISIS_AGE_SPAN_BY_NAME.get(cat)
+        if span is None:
+            issues.append(
+                f"pool_a_crisis_profiles[{index}] unknown category {cat!r}"
+            )
+            continue
+        low, high = span
+        if not (low <= age <= high):
+            issues.append(
+                f"pool_a_crisis_profiles[{index}] category {cat!r}"
+                f" age-span [{low},{high}] does not include age {age}"
+            )
+    return issues
+
+
+def generate_one(seed_card: dict, core: dict, *, system: str) -> dict:
+    user_message = build_user_message(seed_card, core)
+    result = call_chat(
+        system=system,
+        user=user_message,
+        json_mode=True,
+    )
+    pools = parse_json_strict(result.content)
+    issues = validate_pools(pools, seed_card)
+    return {
+        "pools": pools,
+        "issues": issues,
+        "model": result.model,
+        "finish_reason": result.finish_reason,
+        "prompt_tokens": result.prompt_tokens,
+        "completion_tokens": result.completion_tokens,
+    }
+
+
+def _process_one_core(core_payload: dict, *, output_dir: Path, system: str) -> dict:
+    seed_card = core_payload["seed_card"]
+    core = core_payload["core"]
+    persona_id = seed_card["persona_id"]
+    output_path = output_dir / f"{persona_id}.json"
+    if output_path.exists():
+        return {"persona_id": persona_id, "status": "skipped"}
+    try:
+        payload = generate_one(seed_card, core, system=system)
+    except (CodexLocalError, json.JSONDecodeError, ValueError) as exc:
+        return {
+            "persona_id": persona_id,
+            "status": "failed",
+            "error": f"{type(exc).__name__}: {str(exc)[:280]}",
+        }
+    output_path.write_text(
+        json.dumps(
+            {
+                "persona_id": persona_id,
+                "seed_card": seed_card,
+                "pools": payload["pools"],
+                "validation_issues": payload["issues"],
+                "model": payload["model"],
+                "finish_reason": payload["finish_reason"],
+                "prompt_tokens": payload["prompt_tokens"],
+                "completion_tokens": payload["completion_tokens"],
+            },
+            ensure_ascii=False,
+            indent=2,
+        ),
+        encoding="utf-8",
+    )
+    return {
+        "persona_id": persona_id,
+        "status": "succeeded",
+        "prompt_tokens": payload["prompt_tokens"],
+        "completion_tokens": payload["completion_tokens"],
+        "validation_issues": payload["issues"],
+    }
+
+
+def process_cores(
+    cores_dir: Path,
+    output_dir: Path,
+    *,
+    limit: int | None = None,
+    workers: int = 100,
+) -> dict:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    system = load_system_prompt()
+    summary = {
+        "stage": "stage2_pools",
+        "cores_dir": str(cores_dir),
+        "output_dir": str(output_dir),
+        "workers": workers,
+        "processed": 0,
+        "succeeded": 0,
+        "skipped": 0,
+        "failed": 0,
+        "validation_issues": 0,
+        "prompt_tokens": 0,
+        "completion_tokens": 0,
+        "errors": [],
+    }
+    core_files = sorted(cores_dir.glob("seeker_*.json"))
+    if limit is not None:
+        core_files = core_files[:limit]
+    core_payloads = [json.loads(p.read_text(encoding="utf-8")) for p in core_files]
+
+    print(
+        f"INFO stage2_pools start workers={workers} count={len(core_payloads)}",
+        flush=True,
+    )
+    progress_lock = threading.Lock()
+    progress = {"done": 0}
+    total = len(core_payloads)
+
+    with ThreadPoolExecutor(max_workers=workers) as pool:
+        futures = {
+            pool.submit(_process_one_core, payload, output_dir=output_dir, system=system): payload[
+                "seed_card"
+            ]["persona_id"]
+            for payload in core_payloads
+        }
+        for future in as_completed(futures):
+            persona_id = futures[future]
+            try:
+                result = future.result()
+            except Exception as exc:  # noqa: BLE001
+                summary["processed"] += 1
+                summary["failed"] += 1
+                summary["errors"].append({"persona_id": persona_id, "error": str(exc)[:280]})
+                with progress_lock:
+                    progress["done"] += 1
+                    print(
+                        f"INFO stage2_pools progress {progress['done']}/{total} persona={persona_id} ERROR",
+                        flush=True,
+                    )
+                continue
+            summary["processed"] += 1
+            status = result.get("status")
+            if status == "succeeded":
+                summary["succeeded"] += 1
+                summary["prompt_tokens"] += result.get("prompt_tokens", 0)
+                summary["completion_tokens"] += result.get("completion_tokens", 0)
+                if result.get("validation_issues"):
+                    summary["validation_issues"] += 1
+            elif status == "skipped":
+                summary["skipped"] += 1
+            else:
+                summary["failed"] += 1
+                summary["errors"].append(
+                    {"persona_id": persona_id, "error": result.get("error", "unknown")}
+                )
+            with progress_lock:
+                progress["done"] += 1
+                print(
+                    f"INFO stage2_pools progress {progress['done']}/{total} persona={persona_id} {status}",
+                    flush=True,
+                )
+    return summary
+
+
+def build_arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Stage 2 pools writer (DeepSeek V4 Flash).")
+    parser.add_argument(
+        "--cores-dir",
+        type=Path,
+        default=PIPELINE_ROOT / "output_v2" / "cores",
+        help="Directory of stage1 core JSON files.",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=DEFAULT_OUTPUT_DIR,
+        help="Directory to write per-persona pools JSON files.",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=None,
+        help="Optional cap on personas processed.",
+    )
+    parser.add_argument("--workers", type=int, default=30)
+    return parser
+
+
+def main() -> int:
+    args = build_arg_parser().parse_args()
+    summary = process_cores(
+        args.cores_dir, args.output_dir, limit=args.limit, workers=args.workers
+    )
+    print(json.dumps(summary, ensure_ascii=False, indent=2))
+    return 0 if summary["failed"] == 0 else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())