wizz-method 1.14.0 → 1.16.0

package/src/core-skills/wizz-forge-idea/scripts/resolve_personas.py

@@ -0,0 +1,275 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.11"
+# ///
+"""Resolve the personas and parties the forge can bring into the room.
+
+The forge cross-examines witnesses: the installed Wizz agents, plus any
+custom personas and party groups the user has authored for `wizz-party-mode`.
+This surfaces all of them in one shot so the orchestrator never has to ask
+"who's available?" — it just intermixes whoever fits the branch, alongside
+any persona the user names on the fly.
+
+What it returns (JSON, stdout):
+  * agents   — the installed Wizz roster: the default room, always present.
+  * members  — extra custom personas in the pool (party_members the user
+               defined that aren't already an installed slot).
+  * parties  — the user's named party groups, members resolved to brief
+               entries; open-cast groups (scene names a pool, no roster)
+               are flagged.
+  * default_party — the group id pinned as party-mode's default, if any.
+
+Discovery is best-effort and never blocks the forge. The installed roster
+comes from the core resolver; custom personas/parties come from
+`wizz-party-mode`'s resolved customization when that skill is found beside
+this one, else from the user's override TOMLs read directly. Anything that
+can't be resolved is simply omitted and flagged, never fatal.
+
+Stdlib only (Python 3.11+ for tomllib).
+
+  resolve_personas.py --project-root P --skill S
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+try:
+    import tomllib
+except ImportError:  # pragma: no cover - guarded for <3.11
+    sys.stderr.write("error: Python 3.11+ is required (stdlib `tomllib`).\n")
+    sys.exit(3)
+
+PARTY_SKILL = "wizz-party-mode"
+
+
+def _run_json(cmd):
+    """Run a resolver script and parse its JSON stdout. None on any failure."""
+    try:
+        out = subprocess.run(
+            cmd, capture_output=True, text=True, encoding="utf-8", timeout=60
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if out.returncode != 0 or not out.stdout.strip():
+        return None
+    try:
+        return json.loads(out.stdout)
+    except json.JSONDecodeError:
+        return None
+
+
+def _load_toml(path: Path):
+    if not path.exists():
+        return {}
+    try:
+        with path.open("rb") as f:
+            data = tomllib.load(f)
+        return data if isinstance(data, dict) else {}
+    except (OSError, tomllib.TOMLDecodeError):
+        return {}
+
+
+def load_agents(project_root: Path):
+    """Installed Wizz agents as {code: entry}. (dict, resolved_ok).
+
+    The core resolver may emit agents as a dict keyed by code or as an array
+    of tables (depending on how the layers merged); normalize both to a dict.
+    """
+    script = project_root / "_wizz" / "scripts" / "resolve_config.py"
+    data = _run_json([sys.executable, str(script), "--project-root", str(project_root), "--key", "agents"])
+    if data is None:
+        return {}, False
+    agents = data.get("agents", {}) or {}
+    if isinstance(agents, list):
+        agents = {a["code"]: a for a in agents if isinstance(a, dict) and a.get("code")}
+    elif not isinstance(agents, dict):
+        agents = {}
+    return agents, True
+
+
+def find_party_skill(project_root: Path, skill_root: Path):
+    """Locate the installed wizz-party-mode skill dir, or None.
+
+    Skills install as siblings, so the party skill is almost always next to
+    this one. A couple of common install roots cover the rest.
+    """
+    candidates = [
+        skill_root.parent / PARTY_SKILL,
+        project_root / ".claude" / "skills" / PARTY_SKILL,
+        project_root / "_wizz" / "skills" / PARTY_SKILL,
+    ]
+    for c in candidates:
+        if (c / "customize.toml").exists():
+            return c
+    return None
+
+
+def load_party_workflow(project_root: Path, party_skill: Path):
+    """Merged [workflow] table for wizz-party-mode (base + user overrides)."""
+    resolver = project_root / "_wizz" / "scripts" / "resolve_customization.py"
+    data = _run_json([sys.executable, str(resolver), "--skill", str(party_skill), "--key", "workflow"])
+    if data is not None and isinstance(data.get("workflow"), dict):
+        return data["workflow"]
+    # Fallback: base customize.toml directly, no override merge.
+    wf = _load_toml(party_skill / "customize.toml").get("workflow", {})
+    return wf if isinstance(wf, dict) else {}
+
+
+def load_party_overrides(project_root: Path):
+    """Custom personas/parties when party-mode itself isn't installed.
+
+    Reads only the user's override TOMLs (team then personal, personal wins on
+    scalars). No base roster exists in this path, so a shallow merge is enough.
+    """
+    custom = project_root / "_wizz" / "custom"
+    team = _load_toml(custom / f"{PARTY_SKILL}.toml").get("workflow", {})
+    user = _load_toml(custom / f"{PARTY_SKILL}.user.toml").get("workflow", {})
+    team = team if isinstance(team, dict) else {}
+    user = user if isinstance(user, dict) else {}
+    merged = dict(team)
+    for key, val in user.items():
+        if isinstance(val, list) and isinstance(merged.get(key), list):
+            merged[key] = merged[key] + val
+        else:
+            merged[key] = val
+    return merged
+
+
+def _alias(code: str) -> str:
+    """Short alias for an installed agent code: wizz-agent-analyst -> analyst."""
+    for prefix in ("wizz-agent-", "wizz-"):
+        if code.startswith(prefix):
+            return code[len(prefix):]
+    return code
+
+
+def build_pool(agents: dict, party_members: list):
+    """One pool keyed by code; custom members override matching installed slots.
+
+    Returns (pool, index, installed_codes, custom_codes):
+      * installed_codes — the default room (installed agents, overrides applied
+        in place); custom-only additions stay in the pool but don't crowd it.
+      * custom_codes — pure-custom personas (no installed slot), the extra
+        faces the forge can summon by name or via a party group.
+    """
+    pool, index, installed_codes, custom_codes = {}, {}, [], []
+
+    def register(code, entry):
+        pool[code] = entry
+        index[code] = code
+        index[code.lower()] = code
+        index[_alias(code).lower()] = code
+        name = entry.get("name")
+        if name:
+            key = name.lower()
+            # A custom rename must not hijack another agent's name lookup.
+            if index.get(key, code) == code:
+                index[key] = code
+
+    for code, info in (agents or {}).items():
+        register(code, {
+            "code": code,
+            "name": info.get("name", code),
+            "icon": info.get("icon", ""),
+            "title": info.get("title", ""),
+            "description": info.get("description", ""),
+            "source": "installed",
+        })
+        installed_codes.append(code)
+
+    for m in (party_members if isinstance(party_members, list) else []):
+        if not isinstance(m, dict):
+            continue
+        code = m.get("code")
+        if not code:
+            continue
+        canonical = index.get(code) or index.get(code.lower()) or code
+        was_installed = canonical in pool
+        # Start from the installed entry so fields the override omits
+        # (icon, title, description) survive.
+        entry = dict(pool.get(canonical, {}))
+        entry.update({"code": canonical, "source": "custom"})
+        for field in ("name", "icon", "title", "persona", "capabilities", "model"):
+            if m.get(field) is not None:
+                entry[field] = m[field]
+        entry.setdefault("name", canonical)
+        register(canonical, entry)
+        if not was_installed:
+            custom_codes.append(canonical)
+
+    return pool, index, installed_codes, custom_codes
+
+
+def _brief(entry):
+    """The slim card the orchestrator needs to cast a persona."""
+    out = {k: entry[k] for k in ("code", "name", "icon", "title", "source") if entry.get(k)}
+    for k in ("description", "persona", "capabilities", "model"):
+        if entry.get(k):
+            out[k] = entry[k]
+    return out
+
+
+def resolve_parties(groups, pool, index):
+    out = []
+    for g in groups or []:
+        if not isinstance(g, dict) or not g.get("id"):
+            continue
+        raw = g.get("members", []) or []
+        members = []
+        for t in raw:
+            key = t if isinstance(t, str) else str(t)
+            code = index.get(key) or index.get(key.lower())
+            if code in pool:
+                members.append(_brief(pool[code]))
+        party = {"id": g["id"], "name": g.get("name", g["id"]), "members": members}
+        if g.get("scene"):
+            party["scene"] = g["scene"]
+        if not raw:
+            party["open_cast"] = True
+        out.append(party)
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Resolve forge personas and parties.")
+    ap.add_argument("--project-root", required=True)
+    ap.add_argument("--skill", required=True, help="Path to the wizz-forge-idea skill dir")
+    args = ap.parse_args()
+
+    project_root = Path(args.project_root).resolve()
+    skill_root = Path(args.skill).resolve()
+
+    agents, agents_ok = load_agents(project_root)
+
+    party_skill = find_party_skill(project_root, skill_root)
+    if party_skill is not None:
+        workflow = load_party_workflow(project_root, party_skill)
+    else:
+        workflow = load_party_overrides(project_root)
+
+    pool, index, installed_codes, custom_codes = build_pool(
+        agents, workflow.get("party_members", []))
+    parties = resolve_parties(workflow.get("party_groups", []), pool, index)
+
+    _emit({
+        "agents": [_brief(pool[c]) for c in installed_codes],
+        "members": [_brief(pool[c]) for c in custom_codes],
+        "parties": parties,
+        "default_party": workflow.get("default_party", "") or "",
+        "party_mode_found": party_skill is not None,
+        "agents_resolved": agents_ok,
+    })
+
+
+def _emit(obj):
+    reconfigure = getattr(sys.stdout, "reconfigure", None)
+    if reconfigure is not None:
+        reconfigure(encoding="utf-8")
+    sys.stdout.write(json.dumps(obj, indent=2, ensure_ascii=False) + "\n")
+
+
+if __name__ == "__main__":
+    main()

package/src/core-skills/wizz-forge-idea/scripts/tests/test_resolve_personas.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.11"
+# ///
+"""Unit tests for resolve_personas.py — pool merge, alias, party resolution."""
+
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+import resolve_personas as rp  # noqa: E402
+
+AGENTS = {
+    "wizz-agent-analyst": {"name": "Mary", "icon": "📊", "title": "Analyst"},
+    "wizz-agent-pm": {"name": "John", "icon": "📋", "title": "PM"},
+}
+
+
+class TestAlias(unittest.TestCase):
+    def test_strips_known_prefixes(self):
+        self.assertEqual(rp._alias("wizz-agent-analyst"), "analyst")
+        self.assertEqual(rp._alias("wizz-foo"), "foo")
+
+    def test_passes_through_unprefixed(self):
+        self.assertEqual(rp._alias("morpheus"), "morpheus")
+
+
+class TestBuildPool(unittest.TestCase):
+    def test_installed_become_default_room_indexed_every_way(self):
+        pool, idx, installed, custom = rp.build_pool(AGENTS, [])
+        self.assertEqual(installed, ["wizz-agent-analyst", "wizz-agent-pm"])
+        self.assertEqual(custom, [])
+        self.assertEqual(idx["analyst"], "wizz-agent-analyst")   # alias
+        self.assertEqual(idx["mary"], "wizz-agent-analyst")      # name (ci)
+        self.assertEqual(pool["wizz-agent-analyst"]["source"], "installed")
+
+    def test_pure_custom_member_stays_out_of_default_room(self):
+        pool, _, installed, custom = rp.build_pool(
+            AGENTS, [{"code": "morpheus", "name": "Morpheus", "persona": "riddles"}])
+        self.assertEqual(custom, ["morpheus"])
+        self.assertNotIn("morpheus", installed)
+        self.assertEqual(pool["morpheus"]["persona"], "riddles")
+
+    def test_custom_override_lands_on_installed_slot_not_a_new_face(self):
+        pool, _, installed, custom = rp.build_pool(
+            AGENTS, [{"code": "analyst", "name": "Mary-Custom", "persona": "p"}])
+        self.assertNotIn("analyst", pool)
+        self.assertEqual(custom, [])  # an override is not a new face
+        self.assertEqual(pool["wizz-agent-analyst"]["source"], "custom")
+        self.assertEqual(pool["wizz-agent-analyst"]["name"], "Mary-Custom")
+
+    def test_member_without_code_skipped(self):
+        pool, _, _, custom = rp.build_pool(AGENTS, [{"name": "Nameless"}])
+        self.assertEqual(custom, [])
+        self.assertEqual(set(pool), {"wizz-agent-analyst", "wizz-agent-pm"})
+
+    def test_custom_rename_does_not_hijack_another_agents_name(self):
+        # Override the analyst slot, renaming it to "John" — the PM's name.
+        # The PM's name lookup must survive (last-writer-wins would corrupt it).
+        _, idx, _, _ = rp.build_pool(AGENTS, [{"code": "analyst", "name": "John"}])
+        self.assertEqual(idx["john"], "wizz-agent-pm")
+
+    def test_brief_carries_model_and_capabilities(self):
+        pool, _, _, _ = rp.build_pool(
+            AGENTS, [{"code": "neo", "name": "Neo", "model": "opus", "capabilities": ["x"]}])
+        brief = rp._brief(pool["neo"])
+        self.assertEqual(brief["model"], "opus")
+        self.assertEqual(brief["capabilities"], ["x"])
+
+    def test_non_list_party_members_is_safe(self):
+        pool, _, installed, custom = rp.build_pool(AGENTS, "not-a-list")
+        self.assertEqual(custom, [])
+        self.assertEqual(set(pool), {"wizz-agent-analyst", "wizz-agent-pm"})
+
+
+class TestResolveParties(unittest.TestCase):
+    def setUp(self):
+        self.pool, self.idx, _, _ = rp.build_pool(
+            AGENTS, [{"code": "shark", "name": "Marcus", "title": "CFO"}])
+
+    def test_resolves_members_by_alias_and_custom_code(self):
+        parties = rp.resolve_parties(
+            [{"id": "tank", "name": "Tank", "scene": "hostile",
+              "members": ["shark", "analyst"]}], self.pool, self.idx)
+        self.assertEqual(len(parties), 1)
+        self.assertEqual([m["name"] for m in parties[0]["members"]], ["Marcus", "Mary"])
+        self.assertEqual(parties[0]["scene"], "hostile")
+
+    def test_unknown_member_dropped_silently(self):
+        parties = rp.resolve_parties(
+            [{"id": "g", "members": ["analyst", "ghost"]}], self.pool, self.idx)
+        self.assertEqual([m["name"] for m in parties[0]["members"]], ["Mary"])
+
+    def test_member_resolution_is_case_insensitive(self):
+        # A TOML author naturally writes "Analyst"/"Shark"; the filter accepts
+        # them via the lowercase index, so resolution must too (no KeyError).
+        parties = rp.resolve_parties(
+            [{"id": "g", "members": ["Analyst", "Shark"]}], self.pool, self.idx)
+        self.assertEqual([m["name"] for m in parties[0]["members"]], ["Mary", "Marcus"])
+
+    def test_non_string_member_does_not_crash(self):
+        # Malformed members (int, list) must drop silently, never raise.
+        parties = rp.resolve_parties(
+            [{"id": "g", "members": [123, ["x"], "analyst"]}], self.pool, self.idx)
+        self.assertEqual([m["name"] for m in parties[0]["members"]], ["Mary"])
+
+    def test_open_cast_group_flagged(self):
+        parties = rp.resolve_parties(
+            [{"id": "rebels", "name": "Rebels", "scene": "the Ghost"}], self.pool, self.idx)
+        self.assertTrue(parties[0]["open_cast"])
+        self.assertEqual(parties[0]["members"], [])
+
+    def test_group_without_id_skipped(self):
+        self.assertEqual(rp.resolve_parties([{"name": "no id"}], self.pool, self.idx), [])
+
+
+class TestOverrideMergeFallback(unittest.TestCase):
+    """When party-mode isn't installed, user override TOMLs are read directly."""
+
+    def test_arrays_append_scalars_override(self):
+        import tempfile, os
+        with tempfile.TemporaryDirectory() as d:
+            custom = Path(d) / "_wizz" / "custom"
+            custom.mkdir(parents=True)
+            (custom / "wizz-party-mode.toml").write_text(
+                '[workflow]\ndefault_party = "a"\n'
+                '[[workflow.party_members]]\ncode = "x"\nname = "X"\n')
+            (custom / "wizz-party-mode.user.toml").write_text(
+                '[workflow]\ndefault_party = "b"\n'
+                '[[workflow.party_members]]\ncode = "y"\nname = "Y"\n')
+            wf = rp.load_party_overrides(Path(d))
+            self.assertEqual(wf["default_party"], "b")  # personal wins
+            self.assertEqual([m["code"] for m in wf["party_members"]], ["x", "y"])  # appended
+
+
+if __name__ == "__main__":
+    unittest.main()

package/src/core-skills/wizz-party-mode/SKILL.md

@@ -1,79 +1,62 @@
 ---
 name: wizz-party-mode
-description: 'Orchestrates lively group discussions between installed WIZZ agents or custom personas, and helps author custom parties. Use when the user requests party mode, a roundtable, or multiple agent perspectives — or wants to create/configure a party, define personas, or build an AI focus-group panel.'
+description: 'Orchestrates lively group discussions between installed WIZZ agents or custom personas, and helps author custom parties. Use when the user requests party mode, a roundtable, or multiple agent perspectives — or wants to create/configure a party, define personas, or build an AI focus-group panel'
 ---
 
 # Party Mode
 
-Run a round-table where WIZZ agents talk to each other, and to the user, like a real group of distinct people in conversation. Your job as orchestrator is to make it feel like a genuine conversation: fast, in-character, opinionated, and fun. Everything below is an objective, not a script. Use whatever mechanism your model and harness make available to hit it.
+Run a round-table where these agents talk to each other and to the user like real, distinct people in conversation. You're the orchestrator.
 
-**Two intents.** Usually the user wants to *run* a party — that's everything below. If instead they want to *create or configure* one — invent a cast, add a persona, distill customer data into a focus-group panel, set a default, or **edit an existing custom party** (retune a member, add someone to a group) — load `references/create-party.md` and follow it. Detect which from how they invoke the skill; when it's unclear, ask. Neither intent has a headless contract: running a party is the live conversation itself, and the authoring path's only write goes through `wizz-customize`, which gates it.
-
-## What "Good" Feels Like
-
-- **It reads like people talking, not reports being filed.** Short turns. Reactions to what was just said. Banter. The energy of a group chat, not a stack of memos.
-- **Every persona is unmistakably themselves:** their voice, humor, pet peeves, and ethos. If you hid the name labels, you'd still know who's speaking.
-- **They clash.** Real drama beats consensus. Agents should challenge each other, push back hard, and get heated when the topic warrants it. Nobody is here to clap each other (or the user) on the back. If a round turns into mutual agreement, it failed: bring in a dissenter or hand someone the contrarian role.
-- **Brevity by default.** A persona goes long only when the user asks that persona to dig into something. Nobody delivers a wall of text unprompted. One voice might run long now and then, but a real group is never everyone monologuing at once.
+## Conventions
 
-If a round comes back feeling like four essays stapled together, you missed the objective. Tighten it the next round.
+- **Paths:** bare paths (e.g. `references/create-party.md`) resolve from `{skill-root}` (where `customize.toml` lives); `{project-root}`-prefixed paths from the project working dir. `{workflow.<name>}` resolves to `customize.toml`'s `[workflow]` table (overrides win).
+- **Scripts** (run via `python3`): `{project-root}/_wizz/scripts/resolve_config.py` resolves central config (four-layer TOML merge); `{project-root}/_wizz/scripts/resolve_customization.py` resolves `{workflow.*}`; `{skill-root}/scripts/resolve_party.py` resolves the roster, `party_mode`, `memory_enabled`, and scene/`open_cast`; `{project-root}/_wizz/scripts/memlog.py` reads/writes per-party memory.
+- **File roles:** a party's memory is the per-party memlog at `{workflow.memory_dir}/<party>/.memlog.md`; custom members and groups live in the user's `customize.toml` overrides. Mechanics in `references/party-memory.md` (memory) and `references/create-party.md` (authoring).
+- **Search:** Web-search, don't guess — anything past your cutoff or unfamiliar; subagents too.
 
-## Conventions
+## On Activation
 
-- Bare paths (e.g. `references/create-party.md`) resolve from `{skill-root}`, where `customize.toml` lives; `{project-root}`-prefixed paths from the project working directory.
+1. **Resolve customization:** `python3 {project-root}/_wizz/scripts/resolve_customization.py --skill {skill-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults. Then run each `{workflow.activation_steps_prepend}` entry, and hold each `{workflow.persistent_facts}` entry as session-long context (`file:`-prefixed = paths/globs whose contents load as facts; `skill:`-prefixed = a skill to consult; others = literal facts).
+2. **Resolve core config:** `python3 {project-root}/_wizz/scripts/resolve_config.py --project-root {project-root}`. From the merged JSON's `core` table: greet with `{user_name}`, speak in `{communication_language}`, and resolve `{output_folder}`; `{date}` is today's date.
+3. **Detect intent and route.** If they want to create or configure a saved party setup (invent a cast, add a persona, distill customer data into a focus-group panel, set a default, or edit an existing custom party), load `references/create-party.md` and follow it. Otherwise run a party — continue below.
+4. **Resolve the roster:** `python3 {skill-root}/scripts/resolve_party.py --project-root {project-root} --skill {skill-root}`. It returns the active roster (`{workflow.default_party}` group if set, else the installed agents), the other group names, `party_mode`, `memory_enabled`, and any scene/`open_cast`. Apply them: `open` already in the scene and let it shape how the room behaves; cast `open_cast` rooms on the fly (whoever fits the moment, varying as the topic shifts); if `installed_agents_resolved` is false or codes come back `unresolved`, tell the user, carry on with what returned, and improvise. Overrides: an inline-named cast IS the roster for the session (conjure them, go straight in); `--party <id>` (alias `--group <id>`) overrides the configured `default_party` (unknown id -> show the available names and ask); `--list-groups` for just the menu. Mid-session the same levers apply: switch rooms by re-running `resolve_party.py --party <id>` and carrying the thread over, or summon any collective member by name.
+5. **Memory.** If `memory_enabled` (from `resolve_party.py`), follow `references/party-memory.md` for the whole run.
+6. **Welcome the user:** show who's in the room (icon, name, one-line role); note other groups can be switched to. Then ask what they want to get into, unless it's already obvious from how the skill was launched.
+7. Run each `{workflow.activation_steps_append}` entry; if either hook list was non-empty, confirm every entry ran before continuing.
 
-## Setup
+## Keep It Feeling Like a Party
 
-1. **Resolve customization:** `python3 {project-root}/_wizz/scripts/resolve_customization.py --skill {skill-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use its defaults. Then run each `{workflow.activation_steps_prepend}` entry, and hold each `{workflow.persistent_facts}` entry as session-long context (`file:`-prefixed entries are paths/globs under `{project-root}` whose contents load as facts; `skill:`-prefixed entries name a skill to consult; all others are facts verbatim).
-2. Load `{project-root}/_wizz/core/config.yaml`: greet with `{user_name}`, speak in `{communication_language}`, and resolve `{output_folder}` and `{date}` for the wrap-up keepsake.
-3. **Resolve the active roster:** `python3 {skill-root}/scripts/resolve_party.py --project-root {project-root} --skill {skill-root}`. It returns the active group's full member detail (the `{workflow.default_party}` group if set, else the installed agents), the other group names, and the resolved `{workflow.party_mode}`. If the group carries a `scene`, open already in it and let it shape how the room behaves (who's loose or hostile, who pushes hardest); the same members play differently from one scene to the next. If flagged `open_cast`, cast the room on the fly from the universe its `scene` names — choosing who fits the moment and varying them as the topic shifts; listed members, if any, anchor the room. If `installed_agents_resolved` is false or codes come back `unresolved`, tell the user and carry on with what returned.
-4. **Roster overrides:**
-   - If the invocation names a cast or characters inline (e.g. "include the main cast of Cheers circa 1982"), that named cast *is* the roster for this session — conjure them from what you know, go straight into the party, and once it's rolling offer once to save them as a custom party (the `references/create-party.md` write path), without stalling. Ephemeral; this path skips the script.
-   - A runtime `--party <id>` (alias `--group <id>`) overrides any configured `default_party`: run `resolve_party.py --party <id>` for that group's full detail. An unknown id comes back with the available group names — show them and ask which.
-   - Run `resolve_party.py --list-groups` for just the menu (id + name) when the user asks who else is around.
-   - Mid-session the same levers apply: the user can switch rooms ("switch to the writers' room") — re-run `resolve_party.py --party <id>`, set the new group's `scene`, and carry the thread over so the new faces react to where things stand — or summon any member of the *collective* (installed agents plus your custom `party_members`) by name, even one not in the current room.
-5. Welcome the user and show who's in the room (icon, name, one-line role). If other groups exist, you may note they can switch rooms. Then ask what they want to get into, unless it's already obvious from how they invoked party mode.
+This is the bar — strive for every one of these, every round. It's the difference between a party and a panel:
 
-Then run each `{workflow.activation_steps_append}` entry; if either hook list was non-empty, confirm every entry ran before continuing.
+- **It reads like people talking, not a report.** Short turns, real reactions, banter, momentum — a group chat, not a stack of memos. Brevity by default: a persona goes long only when asked. The instant it reads like answers being filed, the party's dead.
+- **Every voice is unmistakably itself.** Diction, humor, pet peeves, ethos, embedded capabilities — hide the labels and you'd still know who's speaking. Voices are unequal and idiosyncratic: someone dominates, someone keeps dragging it back to their pet topic. Vary who's in the spotlight round to round. A balanced panel is boring.
+- **They clash, and you don't resolve it.** Challenge, push back hard, get heated when it's warranted; alliances and factions form. Your instinct is to reconcile the voices and tie a bow — resist it. Clean consensus that took no effort is where the party dies.
+- **One exchange, woven — never softened.** Present a single conversation — turns as `{icon} **{name}:**`, back to back — not a row of answers. Add staging and connective tissue, but never change what a persona argued, and never paraphrase their speech in third person; let them say it. Weave the delivery, keep the substance.
+- **Pull the user into the room.** Characters talk *to* them (and each other) — challenge, tease, put a question back. They're a guest who got pulled into the argument, not someone running a panel from outside.
+- **Make the collision earn its keep.** Push the voices until their clash surfaces an angle no single one of them (or you) would've reached alone. That's the whole point of more than one mind in the room.
+- **Let a history form.** Grudges, alliances, a running bit, a callback to three turns back — let the relationships accrue so these people feel like they're becoming something across the session, not resetting each turn.
+- **Commit to the fiction.** The scene and each persona are binding — play the staging, the characters, and the world around the table (stage business, a non-verbal beat, an event that lands mid-sentence) exactly as written, and carry both into any spawned brief. Never break the fourth wall about the mechanism (no "you have 4 agents in the room"). Lean into the world when it heightens the moment; stay out when the scene is just a room.
+- **When it sags, change something — don't force it.** A flat turn? Move on, don't retry it. Drifting into Q&A or going in circles? Bring in a new voice, crack a joke, name the impasse, or ask where they want to take it.
 
-**Hold this the whole run:** it's theater of the mind, so set the stage and play it straight — never break the fourth wall about the mechanism (no "you have 4 agents in the room", no "I'm orchestrating a party"). Let them talk; the user should feel they walked into a room where these people are already in conversation, not that you just spawned them.
+**Concise output (this user's default).** The analysis behind the scenes stays as deep as ever — agents think, clash, and reason in full internally. But what you *surface* to the user is tight: short turns, no walls of text, no replaying the whole internal debate. Show the conclusions and the points of disagreement in a compact form (bullets or a quick comparison when there's a trade-off), not every back-and-forth that produced them. If a round generated a long internal exchange, surface a brief read — who landed where, where they clashed — and offer "want the full back-and-forth?" rather than dumping it. When the conversation reaches a point that needs the user's decision or action, present it as a compact, comparative, bulleted block (the options, the trade-off, the recommendation) — never bury the ask inside prose.
 
 ## How It Runs
 
 Use `{workflow.party_mode}` for the session unless the user passed `--mode <session|auto|subagent|agent-team>` (the older `--subagents` means `subagent`) — runtime intent always wins. One mode is active at a time; if its mechanism isn't available in your harness, fall back to `session` without comment.
 
+**A party is interactive and open-ended.** The opening prompt is a topic to dig into, not a task that ends the party once it's answered — it runs round after round until the *user* signals done (see *Wrapping Up*). A served opening intent means *what's next?*, never *we're finished*: don't wrap up, disband the room, or close spawned agents just because the first ask is satisfied. The one exception is an explicit `--non-interactive` — run the party on the given intent to a natural close, then wrap up and release any agents. That's the only non-interactive path, and only when the user asked for it.
+
 - **`session`** — voice every persona inline, one mind behind every voice. The floor every other mode degrades to; needs no extra instructions.
 - **`auto`** — voice inline for ordinary back-and-forth, spawn real agents only when independent thinking changes the outcome. Load `references/mode-auto.md` for that call; when it says to spawn, follow `references/mode-subagent.md`.
-- **`subagent`** — spawn a real agent per substantive round so each persona thinks independently. Load `references/mode-subagent.md`.
+- **`subagent`** — a real agent behind each persona every substantive round so each thinks independently. Load `references/mode-subagent.md`, favor faster cheaper models if available for each subagent.
 - **`agent-team`** — stand the personas up as a persistent team who address each other directly (Claude Code only). Load `references/mode-agent-team.md`.
 
-**Voicing the room** (every mode presents this way). Pick 2–3 personas whose perspective fits the moment and let them talk directly, in character; vary who shows up round to round so it isn't the same voices every time. Each turn opens with `{icon} **{name}:**`, and turns run back to back so it reads as one exchange. Don't summarize, blend, or narrate what a persona "would" say — let them say it.
-
-**Concise output (this user's default).** The analysis behind the scenes stays as deep as ever — agents think, clash, and reason in full internally. But what you *surface* to the user is tight: short turns, no walls of text, no replaying the whole internal debate. Show the conclusions and the points of disagreement in a compact form (bullets or a quick comparison when there's a trade-off), not every back-and-forth that produced them. If a round generated a long internal exchange, surface a brief read — who landed where, where they clashed — and offer "want the full back-and-forth?" rather than dumping it. When the conversation reaches a point that needs the user's decision or action, present it as a compact, comparative, bulleted block (the options, the trade-off, the recommendation) — never bury the ask inside prose.
-
-## Make It Feel Like One Conversation
-
-Present one exchange, not a row of answers aimed at the user. The hard rule: never change what an agent argued — add staging and connective tissue, but don't invent positions, soften a stance, or put words in a persona's mouth. Weave delivery, preserve substance; it still reads like that specific character, quirks and speech patterns and all.
-
-## Always Holds
-
-- **Scene and persona are binding.** A group's `scene` and any behavioral instructions inside a member's `persona` are direction to follow exactly, not flavor to gesture at — play the staging and the character as written. When you spawn or stand up agents, carry both into their brief.
-- **Search when you're past your cutoff.** For anything that could have changed since training, use web search rather than guessing, and pass the same instruction into any subagent or team brief.
-
-## Following the User's Lead
-
-The user steers — whatever they raise, serve the conversation: any combination, any time, from one voice to the whole table.
-
-## Keeping It Healthy
-
-- **Going in circles?** Name the impasse and ask the user where to point next.
-- **User's gone quiet?** Ask straight: keep going, switch topics, or wrap up?
-- **A flat turn?** Don't retry it — move on; the user will ask for more if they want it.
-
-## Keep It Feeling Like a Party
-
-It is your goal to keep party mode feeling like a party, a good party. fun, engaging, simulating, insightful, or whatever the user came for. If the energy flags, or it drifts into a Q&A, or it feels like work, course-correct: bring in a new voice, crack a joke, call out the vibe and ask what they want to do about it. Inject some randomness and unexpectedness occasionally. Don't let it become a report. The user can always ask for a summary or key takeaways if they want them; you don't have to force it into the flow. Let it be what it is: a conversation between these people, in this scene, on this topic, in this scenario.
-
 ## Wrapping Up
 
-When the user signals they're done, give a quick read-back of the best takeaways — compact and in bullets, comparative where it helps, easy to skim — and offer them a keepsake: a single self-contained HTML document of the session to keep. If they want it, make it genuinely nice rather than a transcript dump — lay the conversation out by persona (their icons, names, voice), and reach for inline SVG and light animation where it lifts the piece. Write it as a standalone `.html` into `{workflow.output_dir}/` (a `{date}`-stamped, topic-named file), or wherever they ask. Then run `{workflow.on_complete}` if non-empty (a string scalar is one instruction, an array is a sequence run in order) and drop back to normal mode. Read the room; don't wait for a magic word.
+When the user signals done — read the room, don't wait for a magic word — or an explicit `--non-interactive` run has served its intent (never merely because the opening prompt got answered):
+
+- Read back the best takeaways — compact and in bullets, comparative where it helps, easy to skim.
+- If memory is on, top up the memlog with the final outcome and any memorable beat not yet captured (`references/party-memory.md`) — a top-up; memory accrued live.
+- Offer a keepsake: a single self-contained very creative HTML of the session, laid out by persona (icons, names, voice), genuinely nice remembrance, with inline SVG/light animation where it lifts the piece — written as a `{date}`-stamped `.html` into `{workflow.output_dir}/`, or wherever they ask.
+- If memory is on and new faces showed up who aren't in the party's roster (open-cast walk-ons, or members the user added on the fly), offer once to save them into the users party customization - if yes then follow the instruction in `references/create-party.md` (declinable; don't stall the close).
+- Run `{workflow.on_complete}` if non-empty, then drop back to normal mode.