Synthetic Session Generator

# ⚠️ SYNTHETIC — AI-generated fictional session. Not a real person, not clinical advice.

[00:00] Therapist: Hey Maya, good to see you. How's the connection — can you hear me okay?
[00:08] Client: Yeah, fine. Sorry, just — give me a sec, closing Slack. Okay. I'm here.
[00:20] Therapist: No rush. Last week you were going to try handing the launch checklist to Sam. How'd that land?
[00:34] Client: I mean… I drafted the handoff doc. Then I sort of rewrote his part. It's probably fine, but I figured it'd be faster if I just— yeah.
[00:52] Therapist: So the thought was 'it'll be faster if I do it myself.' What's the evidence for that?
[01:05] Client: Honestly? It wasn't faster. I was up till one. I just— I couldn't stand the idea of it going out with a typo and it being on me.
[01:22] Therapist: That sounds like the 'if it's not perfect it's on me' belief again. Want to put it through a thought record this week?
[01:34] Client: ...Yeah. Okay. I can do that.

{
  "watermark": "⚠️ SYNTHETIC — AI-generated fictional session. Not a real person, not clinical advice.",
  "synthetic": true,
  "not_clinical_advice": true,
  "spec": {
    "modality": "cbt",
    "practitioner_label": "Therapist",
    "client_label": "Client",
    "persona": "maya",
    "session_position": "mid-arc",
    "length": "short",
    "format": "json",
    "turn_budget": 15
  },
  "beats": [
    {
      "phase": "check-in",
      "target_turns": 2,
      "notes": ""
    },
    {
      "phase": "agenda",
      "target_turns": 3,
      "notes": ""
    },
    {
      "phase": "homework-review",
      "target_turns": 3,
      "notes": ""
    },
    {
      "phase": "main-work",
      "target_turns": 3,
      "notes": ""
    },
    {
      "phase": "new-homework",
      "target_turns": 3,
      "notes": ""
    },
    {
      "phase": "summary",
      "target_turns": 2,
      "notes": ""
    }
  ],
  "turns": [
    {
      "speaker": "Therapist",
      "timestamp": "00:00",
      "text": "Hey Maya, good to see you. How's the connection — can you hear me okay?",
      "technique": "check-in",
      "emotion": "neutral",
      "phase": "check-in"
    },
    {
      "speaker": "Client",
      "timestamp": "00:08",
      "text": "Yeah, fine. Sorry, just — give me a sec, closing Slack. Okay. I'm here.",
      "technique": null,
      "emotion": "distracted",
      "phase": "check-in"
    },
    {
      "speaker": "Therapist",
      "timestamp": "00:20",
      "text": "No rush. Last week you were going to try handing the launch checklist to Sam. How'd that land?",
      "technique": "homework-review",
      "emotion": "warm",
      "phase": "homework-review"
    },
    {
      "speaker": "Client",
      "timestamp": "00:34",
      "text": "I mean… I drafted the handoff doc. Then I sort of rewrote his part. It's probably fine, but I figured it'd be faster if I just— yeah.",
      "technique": null,
      "emotion": "defensive",
      "phase": "homework-review"
    },
    {
      "speaker": "Therapist",
      "timestamp": "00:52",
      "text": "So the thought was 'it'll be faster if I do it myself.' What's the evidence for that?",
      "technique": "socratic-questioning",
      "emotion": "curious",
      "phase": "main-work"
    },
    {
      "speaker": "Client",
      "timestamp": "01:05",
      "text": "Honestly? It wasn't faster. I was up till one. I just— I couldn't stand the idea of it going out with a typo and it being on me.",
      "technique": null,
      "emotion": "anxious",
      "phase": "main-work"
    },
    {
      "speaker": "Therapist",
      "timestamp": "01:22",
      "text": "That sounds like the 'if it's not perfect it's on me' belief again. Want to put it through a thought record this week?",
      "technique": "homework-assignment",
      "emotion": "collaborative",
      "phase": "new-homework"
    },
    {
      "speaker": "Client",
      "timestamp": "01:34",
      "text": "...Yeah. Okay. I can do that.",
      "technique": null,
      "emotion": "reluctant-agreement",
      "phase": "new-homework"
    }
  ],
  "ground_truth": {
    "themes": [
      "perfectionism",
      "delegation"
    ],
    "action_items": [
      "complete one thought record on the 'it's on me' belief"
    ],
    "techniques_used": [
      "socratic-questioning",
      "homework-assignment"
    ],
    "emotional_arc": "distracted -> defensive -> reluctant openness"
  }
}

#!/usr/bin/env python3
"""Shared helpers for the synthetic-session-generator scripts.

Centralizes the mandatory watermark, config loading/validation, turn allocation, timestamp
emulation, and YAML-safe frontmatter so the four CLI scripts stay consistent.
"""
import argparse
import json
import os
import sys

# --- Single source of truth for the mandatory watermark (exact-match downstream checks rely on it).
WATERMARK = ("⚠️ SYNTHETIC — AI-generated fictional session. "
             "Not a real person, not clinical advice.")

LANGUAGES = {
    "en": "English", "ru": "Russian", "de": "German", "es": "Spanish",
    "fr": "French", "pt": "Portuguese", "it": "Italian", "nl": "Dutch",
}
MODALITIES = ["icf-grow", "cbt", "ifs", "act-mi"]
DEFAULTS = {"language": "en", "modality": "cbt", "duration_minutes": 50}

CONFIG_PATH = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "config.json")


# --- argparse validators -----------------------------------------------------
def positive_int(value):
    try:
        ivalue = int(value)
    except (TypeError, ValueError):
        raise argparse.ArgumentTypeError(f"expected a positive integer, got {value!r}")
    if ivalue <= 0:
        raise argparse.ArgumentTypeError(f"must be a positive integer, got {ivalue}")
    return ivalue


# --- config ------------------------------------------------------------------
def load_config():
    """Return validated defaults merged with config.json. Invalid values fall back to DEFAULTS."""
    cfg = dict(DEFAULTS)
    if os.path.exists(CONFIG_PATH):
        try:
            with open(CONFIG_PATH, encoding="utf-8") as fh:
                raw = json.load(fh)
        except (OSError, ValueError):  # ValueError covers JSON decode, bad UTF-8, oversized ints
            return cfg
        if isinstance(raw, dict):
            # isinstance(str) guards both type and hashability (a list value would raise TypeError).
            if isinstance(raw.get("language"), str) and raw["language"] in LANGUAGES:
                cfg["language"] = raw["language"]
            if isinstance(raw.get("modality"), str) and raw["modality"] in MODALITIES:
                cfg["modality"] = raw["modality"]
            dur = raw.get("duration_minutes")
            # bool is an int subclass — exclude it so `true` is not accepted as a duration.
            if isinstance(dur, int) and not isinstance(dur, bool) and dur > 0:
                cfg["duration_minutes"] = dur
    return cfg


def run_cli(main):
    """Run a CLI main(), swallowing BrokenPipeError when a downstream consumer closes the pipe."""
    try:
        main()
        # Flush inside the guard: buffered stdout to a closed pipe otherwise raises at shutdown (exit 120).
        sys.stdout.flush()
    except BrokenPipeError:
        # Redirect stdout to devnull so the interpreter's shutdown flush doesn't re-raise.
        devnull = os.open(os.devnull, os.O_WRONLY)
        os.dup2(devnull, sys.stdout.fileno())
        sys.exit(0)
    except KeyboardInterrupt:
        sys.exit(130)


def write_text(path, text):
    """Write text, exiting cleanly (code 2) on any filesystem error instead of a traceback."""
    try:
        with open(path, "w", encoding="utf-8") as fh:
            fh.write(text)
    except OSError as e:
        print(f"ERROR: could not write {path} ({e})", file=sys.stderr)
        sys.exit(2)


def save_config(cfg):
    write_text(CONFIG_PATH, json.dumps(cfg, ensure_ascii=False, indent=2))


def duration_to_length(mins):
    """Map clock minutes to a turn budget (~0.6 turns/min, clamped 8–80) and a length bucket."""
    # Clamp the input first so absurdly large ints can't overflow float conversion in `mins * 0.6`.
    mins = max(1, min(int(mins), 100_000))
    turns = max(8, min(80, round(mins * 0.6)))
    bucket = "short" if turns <= 20 else "standard" if turns <= 38 else "long"
    return turns, bucket


def allocate_turns(weights, budget):
    """Distribute `budget` turns across phases by `weights`, summing exactly to budget.

    Uses the largest-remainder method; guarantees at least 1 per phase when budget >= len(weights).
    """
    n = len(weights)
    total = sum(weights) or n
    raw = [budget * w / total for w in weights]
    floor = [int(x) for x in raw]
    remainder = budget - sum(floor)
    order = sorted(range(n), key=lambda i: raw[i] - floor[i], reverse=True)
    for k in range(max(0, remainder)):
        floor[order[k % n]] += 1
    # Ensure no phase is 0 when we can afford it, by borrowing from the largest.
    if budget >= n:
        for i in range(n):
            if floor[i] == 0:
                donor = max(range(n), key=lambda j: floor[j])
                if floor[donor] > 1:
                    floor[donor] -= 1
                    floor[i] += 1
    return floor


# --- session JSON validation -------------------------------------------------
class SessionError(ValueError):
    pass


def validate_session(data):
    """Validate and normalize a session dict in place. Returns the spec and turns."""
    if not isinstance(data, dict):
        raise SessionError("session JSON root must be an object")
    spec = data.get("spec")
    if spec is None:
        spec = {}
    if not isinstance(spec, dict):
        raise SessionError("'spec' must be an object")
    turns = data.get("turns")
    if turns is None:
        turns = []
    if not isinstance(turns, list):
        raise SessionError("'turns' must be a list")
    norm = []
    for i, t in enumerate(turns):
        if not isinstance(t, dict):
            raise SessionError(f"turn {i} must be an object")
        t["speaker"] = "" if t.get("speaker") is None else str(t.get("speaker"))
        t["text"] = "" if t.get("text") is None else str(t.get("text"))
        if t.get("timestamp") is not None:
            t["timestamp"] = str(t["timestamp"])
        norm.append(t)
    data["spec"] = spec
    data["turns"] = norm
    return spec, norm


def as_str_list(value):
    """Coerce a ground_truth field to a list of strings (a bare string becomes a 1-item list)."""
    if value is None:
        return []
    if isinstance(value, str):
        return [value]
    if isinstance(value, list):
        return [str(v) for v in value]
    return [str(value)]


# --- timestamps --------------------------------------------------------------
def fmt_ts(seconds):
    seconds = int(round(max(0, seconds)))
    h, rem = divmod(seconds, 3600)
    m, s = divmod(rem, 60)
    return f"{h}:{m:02d}:{s:02d}" if h else f"{m:02d}:{s:02d}"


def emulate_timestamps(turns, wpm=150, gap=1.5):
    """Compute internally consistent timestamps from turn length (overwrites authored values)."""
    wps = max(0.1, wpm / 60.0)
    t = 0.0
    for turn in turns:
        turn["timestamp"] = fmt_ts(t)
        words = max(1, len(str(turn.get("text", "")).split()))
        t += words / wps + max(0.0, gap)
    return turns


# --- YAML-safe frontmatter ---------------------------------------------------
def yaml_scalar(value):
    """Render a scalar safely for YAML frontmatter (JSON strings are valid YAML)."""
    if isinstance(value, bool):
        return "true" if value else "false"
    if value is None:
        return "null"
    if isinstance(value, (int, float)):
        return str(value)
    return json.dumps(str(value), ensure_ascii=False)


def frontmatter(pairs):
    """Build a YAML frontmatter block from an iterable of (key, value)."""
    lines = ["---"]
    for k, v in pairs:
        lines.append(f"{k}: {yaml_scalar(v)}")
    lines.append("---")
    return "\n".join(lines)

#!/usr/bin/env python3
"""Convert an authored session JSON into a target transcript format.

Reads a session JSON (the scaffold with its `turns` array filled in by the model) and renders it to
`fathom`, `plain`, `markdown`, or `json` (pass-through). The synthetic watermark is re-emitted in
every target so it can never be dropped during conversion.

Usage:
    python3 convert_format.py --in /tmp/session.json --to markdown --auto-timestamps
    python3 convert_format.py --in /tmp/session.json --to fathom --out /tmp/session.txt
"""
import argparse
import json
import sys

from _common import (WATERMARK, validate_session, emulate_timestamps, frontmatter,
                     positive_int, SessionError, write_text, run_cli)


def load(path):
    try:
        with open(path, encoding="utf-8") as fh:
            data = json.load(fh)
    except FileNotFoundError:
        raise SessionError(f"file not found: {path}")
    except (OSError, ValueError) as e:  # ValueError: JSON decode / bad UTF-8 / oversized ints
        raise SessionError(f"could not parse JSON ({e})")
    spec, turns = validate_session(data)  # raises SessionError on bad shape
    if not turns:
        print("WARNING: 'turns' is empty — rendering a watermark-only document.", file=sys.stderr)
    return data


def _label(turn, spec):
    sp = (turn.get("speaker") or "").strip()
    low = sp.lower()
    if low in ("practitioner", "coach", "therapist"):
        return spec.get("practitioner_label", "Practitioner")
    if low == "client":
        return spec.get("client_label", "Client")
    return sp or "Speaker"


def to_fathom(data):
    spec = data["spec"]
    lines = [f"# {WATERMARK}", ""]
    for t in data["turns"]:
        ts = t.get("timestamp") or "00:00"
        lines.append(f"[{ts}] {_label(t, spec)}: {t.get('text','')}")
    return "\n".join(lines) + "\n"


def to_plain(data):
    spec = data["spec"]
    lines = [f"<!-- {WATERMARK} -->", ""]
    for t in data["turns"]:
        lines.append(f"{_label(t, spec)}: {t.get('text','')}")
        lines.append("")
    return "\n".join(lines).rstrip() + "\n"


def to_markdown(data):
    spec = data["spec"]
    out = [
        frontmatter([
            ("persona", spec.get("persona", "")),
            ("modality", spec.get("modality", "")),
            ("session_position", spec.get("session_position", "")),
            ("language", spec.get("language", "")),
            ("synthetic", True),
            ("not_clinical_advice", True),
        ]),
        "",
        f"> {WATERMARK}",
        "",
        f"# Session — {spec.get('persona','')} ({spec.get('modality','')})",
        "",
    ]
    for t in data["turns"]:
        ts = t.get("timestamp")
        prefix = f"`{ts}` " if ts else ""
        out.append(f"**{_label(t, spec)}:** {prefix}{t.get('text','')}")
        out.append("")
    return "\n".join(out).rstrip() + "\n"


def to_json(data):
    # Pass-through: emit the (validated, possibly re-timestamped) session JSON.
    # Enforce the mandatory watermark/flags so the JSON target can never lose provenance.
    data["watermark"] = WATERMARK
    data["synthetic"] = True
    data["not_clinical_advice"] = True
    return json.dumps(data, ensure_ascii=False, indent=2) + "\n"


RENDERERS = {"fathom": to_fathom, "plain": to_plain, "markdown": to_markdown, "json": to_json}


def main():
    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    p.add_argument("--in", dest="inp", required=True, help="authored session JSON")
    p.add_argument("--to", required=True, choices=sorted(RENDERERS), help="target format")
    p.add_argument("--out", help="output path (default: stdout)")
    p.add_argument("--auto-timestamps", action="store_true",
                   help="recompute timestamps from turn length instead of using authored ones")
    p.add_argument("--wpm", type=positive_int, default=150, help="speaking rate for --auto-timestamps")
    args = p.parse_args()

    try:
        data = load(args.inp)
    except SessionError as e:
        print(f"ERROR: invalid session JSON — {e}", file=sys.stderr)
        sys.exit(2)

    if args.auto_timestamps:
        emulate_timestamps(data["turns"], wpm=args.wpm)
    rendered = RENDERERS[args.to](data)

    if args.out:
        write_text(args.out, rendered)
        print(f"Wrote {args.to}: {args.out}", file=sys.stderr)
    else:
        sys.stdout.write(rendered)


if __name__ == "__main__":
    run_cli(main)

#!/usr/bin/env python3
"""Build a case-conceptualization card from an authored session JSON.

Emits a markdown card scaffold that summarizes the (synthetic) client: a snapshot, the
modality-appropriate formulation skeleton, themes and goals pulled from the session's `ground_truth`,
and a slot for a portrait image. The clinical narrative (the `<!-- FILL: ... -->` blocks) is authored
by the model; this script supplies structure, watermark, and a ready-to-use portrait prompt for the
`gpt-image-2` skill.

Usage:
    python3 make_card.py --in /tmp/maya_ifs.json --out /tmp/maya_card.md
    python3 make_card.py --in /tmp/maya_ifs.json --image assets/maya_portrait.png --out card.md
    python3 make_card.py --in /tmp/maya_ifs.json --print-prompt
"""
import argparse
import json
import sys

from _common import (WATERMARK, validate_session, as_str_list, frontmatter, SessionError,
                     write_text, run_cli)

# Card-specific provenance line, shown in addition to the mandatory base watermark.
CARD_NOTE = "Case card for a fictional persona — not a real clinical record."

FORMULATIONS = {
    "cbt": [
        ("Core belief / schema", "the central 'I am…' belief driving the pattern"),
        ("Key automatic thoughts", "recurring hot thoughts and the situations that trigger them"),
        ("Cognitive distortions", "named distortions evidenced in the session"),
        ("Maintenance cycle", "thought → emotion → behaviour → consequence loop"),
    ],
    "ifs": [
        ("Parts map", "managers / firefighters / exiles identified, and their roles"),
        ("Protective intent", "what each protector is guarding against"),
        ("Burdens", "the beliefs/feelings the exile carries and where they came from"),
        ("Self-energy & access", "how much Self was available; what unblended access"),
    ],
    "icf-grow": [
        ("Goal", "what the client wants, in their words"),
        ("Current reality", "the honest present-state picture"),
        ("Options & resources", "paths considered and strengths in play"),
        ("Will / commitment", "what they committed to and their readiness level"),
    ],
    "act-mi": [
        ("Values", "what matters to the client underneath the problem"),
        ("Ambivalence", "the change-vs-status-quo tension and sustain talk"),
        ("Fusion / avoidance", "thoughts they are fused with; experiences avoided"),
        ("Change talk & commitment", "DARN-C evidence and committed action"),
    ],
}


def portrait_prompt(persona, modality):
    """A safe, clearly-synthetic, courtroom-sketch line-art prompt for gpt-image-2.

    Deliberately loose and gestural — a reportage sketch reads unmistakably as hand-drawn, never a
    photo of a real person, and captures mood/posture/environment over literal likeness.
    """
    persona = str(persona) if persona not in (None, "") else "client"
    modality = modality if isinstance(modality, str) and modality else "coaching"
    return (
        f"Loose courtroom-sketch / reportage line art of a fictional therapy-client persona "
        f"named '{persona}'. Quick gestural pen-and-ink linework with a few light marker or "
        f"colored-pencil washes, expressive and unfinished, sketched on the go. Capture mood, "
        f"posture, and the session environment of a {modality.upper()} session rather than a "
        f"literal likeness. Clearly a hand-drawn sketch — not a photograph, not a polished "
        f"portrait. No text, no logos. Synthetic/illustrative character — not a real individual."
    )


def build_card(data, image_path=None):
    spec, _ = validate_session(data)
    gt = data.get("ground_truth")
    if not isinstance(gt, dict):
        gt = {}
    # Coerce to scalars: malformed JSON may carry list/dict here, which would break .get()/f-strings.
    persona = spec.get("persona")
    persona = str(persona) if persona not in (None, "") else "client"
    modality = spec.get("modality")
    modality = modality if isinstance(modality, str) else ""
    formulation = FORMULATIONS.get(modality, FORMULATIONS["cbt"])

    L = [
        frontmatter([
            ("persona", persona),
            ("modality", modality),
            ("session_position", spec.get("session_position", "")),
            ("type", "case-conceptualization-card"),
            ("synthetic", True),
            ("not_clinical_advice", True),
        ]),
        "",
        f"> {WATERMARK}",
        f"> {CARD_NOTE}",
        "",
        f"# Case Card — {persona} ({modality})",
        "",
    ]

    if image_path:
        L += [f"![Synthetic portrait of {persona}]({image_path})", ""]
    else:
        L += [
            "<!-- PORTRAIT: generate with the gpt-image-2 skill, then embed the path here. -->",
            f"<!-- Suggested prompt:\n{portrait_prompt(persona, modality)}\n-->",
            "",
        ]

    L += ["## Snapshot", "<!-- FILL: one-paragraph who-they-are, in clinical-summary voice -->", ""]
    L += ["## Presenting issue", "<!-- FILL: surface complaint and what's underneath -->", ""]

    L += [f"## Formulation ({modality or 'general'})"]
    for heading, hint in formulation:
        L += [f"### {heading}", f"<!-- FILL: {hint} -->", ""]

    themes = as_str_list(gt.get("themes"))
    L += ["## Working themes"]
    L += [f"- {t}" for t in themes] if themes else ["<!-- FILL: 2–4 themes -->"]
    L += [""]

    actions = as_str_list(gt.get("action_items"))
    L += ["## Goals & between-session experiments"]
    L += [f"- [ ] {a}" for a in actions] if actions else ["<!-- FILL: agreed experiments -->"]
    L += [""]

    arc = gt.get("emotional_arc")
    arc = str(arc) if arc else ""
    L += ["## Emotional arc", arc if arc else "<!-- FILL: arc across the session -->", ""]

    return "\n".join(L).rstrip() + "\n"


def main():
    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    p.add_argument("--in", dest="inp", required=True, help="authored session JSON")
    p.add_argument("--image", help="path to an already-generated portrait to embed")
    p.add_argument("--out", help="output path (default: stdout)")
    p.add_argument("--print-prompt", action="store_true",
                   help="print only the gpt-image-2 portrait prompt and exit")
    args = p.parse_args()

    try:
        with open(args.inp, encoding="utf-8") as fh:
            data = json.load(fh)
    except FileNotFoundError:
        print(f"ERROR: file not found: {args.inp}", file=sys.stderr)
        sys.exit(2)
    except (OSError, ValueError) as e:  # ValueError: JSON decode / bad UTF-8 / oversized ints
        print(f"ERROR: could not parse JSON ({e})", file=sys.stderr)
        sys.exit(2)

    try:
        if args.print_prompt:
            spec, _ = validate_session(data)
            print(portrait_prompt(spec.get("persona"), spec.get("modality")))
            return
        card = build_card(data, image_path=args.image)
    except SessionError as e:
        print(f"ERROR: invalid session JSON — {e}", file=sys.stderr)
        sys.exit(2)

    if args.out:
        write_text(args.out, card)
        print(f"Wrote card: {args.out}", file=sys.stderr)
    else:
        sys.stdout.write(card)


if __name__ == "__main__":
    run_cli(main)

#!/usr/bin/env python3
"""Scaffold a synthetic coaching/therapy session skeleton.

Turns a generation spec (modality, persona, session position, length/duration, language, format)
into a structured JSON skeleton with phases, a beat list, a turn budget, an empty turn array for the
model to fill, and the mandatory synthetic watermark. The model authors the actual dialogue into the
`turns` array; this script only builds the guardrails.

Defaults for modality / language / duration come from setup_config.py (config.json). Precedence:
explicit CLI flag > config value > built-in default.

Usage:
    python3 scaffold_session.py --modality cbt --persona maya --position mid-arc \
        --length standard --format json --out /tmp/session_skeleton.json
"""
import argparse
import json
import sys

from _common import (WATERMARK, LANGUAGES, MODALITIES, load_config, duration_to_length,
                     allocate_turns, positive_int, write_text, run_cli)

MODALITY_META = {
    "icf-grow": {"practitioner": "Coach",
                 "phases": ["check-in", "goal", "reality", "options", "will", "close"]},
    "cbt": {"practitioner": "Therapist",
            "phases": ["check-in", "agenda", "homework-review", "main-work", "new-homework", "summary"]},
    "ifs": {"practitioner": "Therapist",
            "phases": ["check-in", "find-target-part", "unblend", "befriend-part", "integration", "close"]},
    "act-mi": {"practitioner": "Practitioner",
               "phases": ["check-in", "evoke-values", "explore-ambivalence", "defusion", "commit", "summary"]},
}

POSITIONS = {"intake", "early", "mid-arc", "breakthrough", "rupture-and-repair", "closing"}
LENGTHS = {"short": 15, "standard": 30, "long": 50}
FORMATS = {"fathom", "plain", "json", "markdown"}


def resolve_turn_budget(length, duration, config):
    """Apply precedence: explicit --duration > explicit --length > config duration > default length."""
    if duration is not None:
        turns, bucket = duration_to_length(duration)
        return turns, bucket, duration
    if length is not None:
        return LENGTHS[length], length, None
    cfg_duration = config.get("duration_minutes")
    if isinstance(cfg_duration, int) and cfg_duration > 0:
        turns, bucket = duration_to_length(cfg_duration)
        return turns, bucket, cfg_duration
    return LENGTHS["standard"], "standard", None


def build_skeleton(modality, persona, position, length, duration, fmt, language, config):
    m = MODALITY_META[modality]
    phases = m["phases"]
    turn_budget, bucket, duration_used = resolve_turn_budget(length, duration, config)

    weights = [1] * len(phases)
    for i in range(1, len(phases) - 1):
        weights[i] = 2
    targets = allocate_turns(weights, turn_budget)
    beats = [{"phase": p, "target_turns": tt, "notes": ""} for p, tt in zip(phases, targets)]

    return {
        "watermark": WATERMARK,
        "synthetic": True,
        "not_clinical_advice": True,
        "spec": {
            "modality": modality,
            "practitioner_label": m["practitioner"],
            "client_label": "Client",
            "persona": persona,
            "session_position": position,
            "length": bucket,
            "format": fmt,
            "turn_budget": turn_budget,
            "language": language,
            "language_name": LANGUAGES.get(language, language),
            "duration_minutes": duration_used,
        },
        "beats": beats,
        "turns": [],  # model fills: [{speaker, timestamp, text, technique, emotion, phase}, ...]
        "ground_truth": {
            "themes": [],
            "action_items": [],
            "techniques_used": [],
            "emotional_arc": "",
        },
    }


def main():
    cfg = load_config()
    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    p.add_argument("--modality", default=cfg["modality"], choices=sorted(MODALITIES),
                   help="default from setup config")
    p.add_argument("--persona", required=True, help="persona id from references/personas.md")
    p.add_argument("--position", required=True, choices=sorted(POSITIONS))
    # length/duration default to None so we can detect whether the user passed them explicitly.
    p.add_argument("--length", default=None, choices=sorted(LENGTHS),
                   help="coarse length; overridden by --duration")
    p.add_argument("--duration", type=positive_int, default=None,
                   help="session minutes; overrides --length and config (e.g. 25/50/80)")
    p.add_argument("--language", default=cfg["language"], choices=sorted(LANGUAGES),
                   help="output language (default from setup config)")
    p.add_argument("--format", dest="fmt", default="json", choices=sorted(FORMATS))
    p.add_argument("--out", help="output path (default: stdout)")
    args = p.parse_args()

    skeleton = build_skeleton(args.modality, args.persona, args.position, args.length,
                              args.duration, args.fmt, args.language, cfg)
    payload = json.dumps(skeleton, ensure_ascii=False, indent=2)
    sp = skeleton["spec"]
    if args.out:
        write_text(args.out, payload + "\n")
        print(f"Wrote skeleton: {args.out}", file=sys.stderr)
        print(f"  modality={sp['modality']} persona={sp['persona']} position={sp['session_position']} "
              f"language={sp['language_name']} length={sp['length']} (~{sp['turn_budget']} turns) "
              f"format={args.fmt}", file=sys.stderr)
        print(f"Author the dialogue in {sp['language_name']} into 'turns', then run convert_format.py.",
              file=sys.stderr)
    else:
        print(payload)


if __name__ == "__main__":
    run_cli(main)

#!/usr/bin/env python3
"""Setup mode — persist default generation settings for the skill.

Writes a `config.json` next to the skill so later `scaffold_session.py` runs inherit defaults for
language, modality, and session duration without re-specifying them. Run this when the user wants to
configure the skill ("setup", "set my defaults", "always use Russian / CBT / 50-minute sessions").

Usage:
    python3 setup_config.py --language ru --modality cbt --duration 50
    python3 setup_config.py --show          # print current config (no writes)
    python3 setup_config.py --reset         # restore built-in defaults
"""
import argparse
import json
import sys

from _common import (LANGUAGES, MODALITIES, DEFAULTS, load_config, save_config,
                     duration_to_length, positive_int, run_cli)


def describe(cfg):
    turns, bucket = duration_to_length(cfg["duration_minutes"])
    return {
        "language": f"{cfg['language']} ({LANGUAGES.get(cfg['language'], cfg['language'])})",
        "modality": cfg["modality"],
        "duration_minutes": cfg["duration_minutes"],
        "derived_turn_budget": turns,
        "derived_length": bucket,
    }


def main():
    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    p.add_argument("--language", choices=sorted(LANGUAGES), help="default output language")
    p.add_argument("--modality", choices=MODALITIES, help="default modality")
    p.add_argument("--duration", type=positive_int, help="default session minutes (e.g. 25/50/80)")
    p.add_argument("--show", action="store_true", help="print current config without modifying it")
    p.add_argument("--reset", action="store_true", help="restore built-in defaults")
    args = p.parse_args()

    # --show is read-only: print and exit, no writes (unless combined with changes/reset).
    will_change = bool(args.language or args.modality or args.duration or args.reset)
    if args.show and not will_change:
        print(json.dumps(describe(load_config()), ensure_ascii=False, indent=2))
        return

    cfg = dict(DEFAULTS) if args.reset else load_config()
    if args.language:
        cfg["language"] = args.language
    if args.modality:
        cfg["modality"] = args.modality
    if args.duration:
        cfg["duration_minutes"] = args.duration

    save_config(cfg)
    print(f"Saved config → config.json", file=sys.stderr)
    print(json.dumps(describe(cfg), ensure_ascii=False, indent=2))


if __name__ == "__main__":
    run_cli(main)